Encapsulates a point of interest in an image containing a barcode. Typically, this\n * would be the location of a finder pattern or the corner of the barcode, for example.
\n *\n * @author Sean Owen\n */\nexport default class ResultPoint {\n\n public constructor(private x: float, private y: float) { }\n\n public getX(): float {\n return this.x;\n }\n\n public getY(): float {\n return this.y;\n }\n\n /*@Override*/\n public equals(other: Object): boolean {\n if (other instanceof ResultPoint) {\n const otherPoint =Encapsulates the result of decoding a barcode within an image.
\n *\n * @author Sean Owen\n */\nexport default class Result {\n\n private resultMetadata: MapRepresents a 2D matrix of bits. In function arguments below, and throughout the common\n * module, x is the column position, and y is the row position. The ordering is always x, y.\n * The origin is at the top-left.
\n *\n *Internally the bits are represented in a 1-D array of 32-bit ints. However, each row begins\n * with a new int. This is done intentionally so that we can copy out a row into a BitArray very\n * efficiently.
\n *\n *The ordering of bits is row-major. Within each int, the least significant bits are used first,\n * meaning they represent lower x values. This is compatible with BitArray's implementation.
\n *\n * @author Sean Owen\n * @author dswitkin@google.com (Daniel Switkin)\n */\nexport default class BitMatrix /*implements Cloneable*/ {\n\n /**\n * Creates an empty square {@link BitMatrix}.\n *\n * @param dimension height and width\n */\n // public constructor(dimension: number /*int*/) {\n // this(dimension, dimension)\n // }\n\n /**\n * Creates an empty {@link BitMatrix}.\n *\n * @param width bit matrix width\n * @param height bit matrix height\n */\n // public constructor(width: number /*int*/, height: number /*int*/) {\n // if (width < 1 || height < 1) {\n // throw new IllegalArgumentException(\"Both dimensions must be greater than 0\")\n // }\n // this.width = width\n // this.height = height\n // this.rowSize = (width + 31) / 32\n // bits = new int[rowSize * height];\n // }\n\n public constructor(private width: number /*int*/, private height?: number /*int*/,\n private rowSize?: number /*int*/, private bits?: Int32Array) {\n if (undefined === height || null === height) {\n height = width;\n }\n this.height = height;\n if (width < 1 || height < 1) {\n throw new IllegalArgumentException('Both dimensions must be greater than 0');\n }\n if (undefined === rowSize || null === rowSize) {\n rowSize = Math.floor((width + 31) / 32);\n }\n this.rowSize = rowSize;\n if (undefined === bits || null === bits) {\n this.bits = new Int32Array(this.rowSize * this.height);\n }\n }\n\n /**\n * Interprets a 2D array of booleans as a {@link BitMatrix}, where \"true\" means an \"on\" bit.\n *\n * @function parse\n * @param image bits of the image, as a row-major 2D array. Elements are arrays representing rows\n * @return {@link BitMatrix} representation of image\n */\n public static parseFromBooleanArray(image: boolean[][]): BitMatrix {\n const height = image.length;\n const width = image[0].length;\n const bits = new BitMatrix(width, height);\n for (let i = 0; i < height; i++) {\n const imageI = image[i];\n for (let j = 0; j < width; j++) {\n if (imageI[j]) {\n bits.set(j, i);\n }\n }\n }\n return bits;\n }\n\n /**\n *\n * @function parse\n * @param stringRepresentation\n * @param setString\n * @param unsetString\n */\n public static parseFromString(stringRepresentation: string, setString: string, unsetString: string): BitMatrix {\n if (stringRepresentation === null) {\n throw new IllegalArgumentException('stringRepresentation cannot be null');\n }\n\n const bits = new ArrayGets the requested bit, where true means black.
\n *\n * @param x The horizontal component (i.e. which column)\n * @param y The vertical component (i.e. which row)\n * @return value of given bit in matrix\n */\n public get(x: number /*int*/, y: number /*int*/): boolean {\n const offset = y * this.rowSize + Math.floor(x / 32);\n return ((this.bits[offset] >>> (x & 0x1f)) & 1) !== 0;\n }\n\n /**\n *Sets the given bit to true.
\n *\n * @param x The horizontal component (i.e. which column)\n * @param y The vertical component (i.e. which row)\n */\n public set(x: number /*int*/, y: number /*int*/): void {\n const offset = y * this.rowSize + Math.floor(x / 32);\n this.bits[offset] |= (1 << (x & 0x1f)) & 0xFFFFFFFF;\n }\n\n public unset(x: number /*int*/, y: number /*int*/): void {\n const offset = y * this.rowSize + Math.floor(x / 32);\n this.bits[offset] &= ~((1 << (x & 0x1f)) & 0xFFFFFFFF);\n }\n\n /**\n *Flips the given bit.
\n *\n * @param x The horizontal component (i.e. which column)\n * @param y The vertical component (i.e. which row)\n */\n public flip(x: number /*int*/, y: number /*int*/): void {\n const offset = y * this.rowSize + Math.floor(x / 32);\n this.bits[offset] ^= ((1 << (x & 0x1f)) & 0xFFFFFFFF);\n }\n\n /**\n * Exclusive-or (XOR): Flip the bit in this {@code BitMatrix} if the corresponding\n * mask bit is set.\n *\n * @param mask XOR mask\n */\n public xor(mask: BitMatrix): void {\n if (this.width !== mask.getWidth() || this.height !== mask.getHeight()\n || this.rowSize !== mask.getRowSize()) {\n throw new IllegalArgumentException('input matrix dimensions do not match');\n }\n const rowArray = new BitArray(Math.floor(this.width / 32) + 1);\n const rowSize = this.rowSize;\n const bits = this.bits;\n for (let y = 0, height = this.height; y < height; y++) {\n const offset = y * rowSize;\n const row = mask.getRow(y, rowArray).getBitArray();\n for (let x = 0; x < rowSize; x++) {\n bits[offset + x] ^= row[x];\n }\n }\n }\n\n /**\n * Clears all bits (sets to false).\n */\n public clear(): void {\n const bits = this.bits;\n const max = bits.length;\n for (let i = 0; i < max; i++) {\n bits[i] = 0;\n }\n }\n\n /**\n *Sets a square region of the bit matrix to true.
\n *\n * @param left The horizontal position to begin at (inclusive)\n * @param top The vertical position to begin at (inclusive)\n * @param width The width of the region\n * @param height The height of the region\n */\n public setRegion(left: number /*int*/, top: number /*int*/, width: number /*int*/, height: number /*int*/): void {\n if (top < 0 || left < 0) {\n throw new IllegalArgumentException('Left and top must be nonnegative');\n }\n if (height < 1 || width < 1) {\n throw new IllegalArgumentException('Height and width must be at least 1');\n }\n const right = left + width;\n const bottom = top + height;\n if (bottom > this.height || right > this.width) {\n throw new IllegalArgumentException('The region must fit inside the matrix');\n }\n const rowSize = this.rowSize;\n const bits = this.bits;\n for (let y = top; y < bottom; y++) {\n const offset = y * rowSize;\n for (let x = left; x < right; x++) {\n bits[offset + Math.floor(x / 32)] |= ((1 << (x & 0x1f)) & 0xFFFFFFFF);\n }\n }\n }\n\n /**\n * A fast method to retrieve one row of data from the matrix as a BitArray.\n *\n * @param y The row to retrieve\n * @param row An optional caller-allocated BitArray, will be allocated if null or too small\n * @return The resulting BitArray - this reference should always be used even when passing\n * your own row\n */\n public getRow(y: number /*int*/, row?: BitArray): BitArray {\n if (row === null || row === undefined || row.getSize() < this.width) {\n row = new BitArray(this.width);\n } else {\n row.clear();\n }\n const rowSize = this.rowSize;\n const bits = this.bits;\n const offset = y * rowSize;\n for (let x = 0; x < rowSize; x++) {\n row.setBulk(x * 32, bits[offset + x]);\n }\n return row;\n }\n\n /**\n * @param y row to set\n * @param row {@link BitArray} to copy from\n */\n public setRow(y: number /*int*/, row: BitArray): void {\n System.arraycopy(row.getBitArray(), 0, this.bits, y * this.rowSize, this.rowSize);\n }\n\n /**\n * Modifies this {@code BitMatrix} to represent the same but rotated 180 degrees\n */\n public rotate180(): void {\n const width = this.getWidth();\n const height = this.getHeight();\n let topRow = new BitArray(width);\n let bottomRow = new BitArray(width);\n for (let i = 0, length = Math.floor((height + 1) / 2); i < length; i++) {\n topRow = this.getRow(i, topRow);\n bottomRow = this.getRow(height - 1 - i, bottomRow);\n topRow.reverse();\n bottomRow.reverse();\n this.setRow(i, bottomRow);\n this.setRow(height - 1 - i, topRow);\n }\n }\n\n /**\n * This is useful in detecting the enclosing rectangle of a 'pure' barcode.\n *\n * @return {@code left,top,width,height} enclosing rectangle of all 1 bits, or null if it is all white\n */\n public getEnclosingRectangle(): Int32Array {\n const width = this.width;\n const height = this.height;\n const rowSize = this.rowSize;\n const bits = this.bits;\n\n let left = width;\n let top = height;\n let right = -1;\n let bottom = -1;\n\n for (let y = 0; y < height; y++) {\n for (let x32 = 0; x32 < rowSize; x32++) {\n const theBits = bits[y * rowSize + x32];\n if (theBits !== 0) {\n if (y < top) {\n top = y;\n }\n if (y > bottom) {\n bottom = y;\n }\n if (x32 * 32 < left) {\n let bit = 0;\n while (((theBits << (31 - bit)) & 0xFFFFFFFF) === 0) {\n bit++;\n }\n if ((x32 * 32 + bit) < left) {\n left = x32 * 32 + bit;\n }\n }\n if (x32 * 32 + 31 > right) {\n let bit = 31;\n while ((theBits >>> bit) === 0) {\n bit--;\n }\n if ((x32 * 32 + bit) > right) {\n right = x32 * 32 + bit;\n }\n }\n }\n }\n }\n\n if (right < left || bottom < top) {\n return null;\n }\n\n return Int32Array.from([left, top, right - left + 1, bottom - top + 1]);\n }\n\n /**\n * This is useful in detecting a corner of a 'pure' barcode.\n *\n * @return {@code x,y} coordinate of top-left-most 1 bit, or null if it is all white\n */\n public getTopLeftOnBit(): Int32Array {\n const rowSize = this.rowSize;\n const bits = this.bits;\n\n let bitsOffset = 0;\n while (bitsOffset < bits.length && bits[bitsOffset] === 0) {\n bitsOffset++;\n }\n if (bitsOffset === bits.length) {\n return null;\n }\n const y = bitsOffset / rowSize;\n let x = (bitsOffset % rowSize) * 32;\n\n const theBits = bits[bitsOffset];\n let bit = 0;\n while (((theBits << (31 - bit)) & 0xFFFFFFFF) === 0) {\n bit++;\n }\n x += bit;\n return Int32Array.from([x, y]);\n }\n\n public getBottomRightOnBit(): Int32Array {\n const rowSize = this.rowSize;\n const bits = this.bits;\n\n let bitsOffset = bits.length - 1;\n while (bitsOffset >= 0 && bits[bitsOffset] === 0) {\n bitsOffset--;\n }\n if (bitsOffset < 0) {\n return null;\n }\n\n const y = Math.floor(bitsOffset / rowSize);\n let x = Math.floor(bitsOffset % rowSize) * 32;\n\n const theBits = bits[bitsOffset];\n let bit = 31;\n while ((theBits >>> bit) === 0) {\n bit--;\n }\n x += bit;\n\n return Int32Array.from([x, y]);\n }\n\n /**\n * @return The width of the matrix\n */\n public getWidth(): number /*int*/ {\n return this.width;\n }\n\n /**\n * @return The height of the matrix\n */\n public getHeight(): number /*int*/ {\n return this.height;\n }\n\n /**\n * @return The row size of the matrix\n */\n public getRowSize(): number /*int*/ {\n return this.rowSize;\n }\n\n /*@Override*/\n public equals(o: Object): boolean {\n if (!(o instanceof BitMatrix)) {\n return false;\n }\n const other =2D barcode formats typically encode text, but allow for a sort of 'byte mode'\n * which is sometimes used to encode binary data. While {@link Result} makes available\n * the complete raw bytes in the barcode for these formats, it does not offer the bytes\n * from the byte segments alone.
\n *\n *This maps to a {@link java.util.List} of byte arrays corresponding to the\n * raw bytes in the byte segments in the barcode, in order.
\n */\n BYTE_SEGMENTS,\n\n /**\n * Error correction level used, if applicable. The value type depends on the\n * format, but is typically a String.\n */\n ERROR_CORRECTION_LEVEL,\n\n /**\n * For some periodicals, indicates the issue number as an {@link Integer}.\n */\n ISSUE_NUMBER,\n\n /**\n * For some products, indicates the suggested retail price in the barcode as a\n * formatted {@link String}.\n */\n SUGGESTED_PRICE,\n\n /**\n * For some products, the possible country of manufacture as a {@link String} denoting the\n * ISO country code. Some map to multiple possible countries, like \"US/CA\".\n */\n POSSIBLE_COUNTRY,\n\n /**\n * For some products, the extension text\n */\n UPC_EAN_EXTENSION,\n\n /**\n * PDF417-specific metadata\n */\n PDF417_EXTRA_METADATA,\n\n /**\n * If the code format supports structured append and the current scanned code is part of one then the\n * sequence number is given with it.\n */\n STRUCTURED_APPEND_SEQUENCE,\n\n /**\n * If the code format supports structured append and the current scanned code is part of one then the\n * parity is given with it.\n */\n STRUCTURED_APPEND_PARITY,\n\n}\n\nexport default ResultMetadataType;\n","/*\n * Copyright 2008 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/*namespace com.google.zxing.oned {*/\n\nimport BinaryBitmap from '../BinaryBitmap';\nimport BitArray from '../common/BitArray';\nimport DecodeHintType from '../DecodeHintType';\n\nimport Reader from '../Reader';\nimport Result from '../Result';\nimport ResultMetadataType from '../ResultMetadataType';\nimport ResultPoint from '../ResultPoint';\nimport NotFoundException from '../NotFoundException';\n\n/**\n * Encapsulates functionality and implementation that is common to all families\n * of one-dimensional barcodes.\n *\n * @author dswitkin@google.com (Daniel Switkin)\n * @author Sean Owen\n */\nexport default abstract class OneDReader implements Reader {\n\n /*\n @Override\n public Result decode(BinaryBitmap image) throws NotFoundException, FormatException {\n return decode(image, null);\n }\n */\n\n // Note that we don't try rotation without the try harder flag, even if rotation was supported.\n // @Override\n public decode(image: BinaryBitmap, hints?: MapAttempts to decode a one-dimensional barcode format given a single row of\n * an image.
\n *\n * @param rowNumber row number from top of the row\n * @param row the black/white pixel data of the row\n * @param hints decode hints\n * @return {@link Result} containing encoded string and start/end of barcode\n * @throws NotFoundException if no potential barcode is found\n * @throws ChecksumException if a potential barcode is found but does not pass its checksum\n * @throws FormatException if a potential barcode is found but format is invalid\n */\n public abstract decodeRow(rowNumber: number, row: BitArray, hints?: MapA simple, fast array of bits, represented compactly by an array of ints internally.
\n *\n * @author Sean Owen\n */\nexport default class BitArray /*implements Cloneable*/ {\n\n private size: number;\n private bits: Int32Array;\n\n // public constructor() {\n // this.size = 0\n // this.bits = new Int32Array(1)\n // }\n\n // public constructor(size?: number /*int*/) {\n // if (undefined === size) {\n // this.size = 0\n // } else {\n // this.size = size\n // }\n // this.bits = this.makeArray(size)\n // }\n\n // For testing only\n public constructor(size?: number /*int*/, bits?: Int32Array) {\n if (undefined === size) {\n this.size = 0;\n this.bits = new Int32Array(1);\n } else {\n this.size = size;\n if (undefined === bits || null === bits) {\n this.bits = BitArray.makeArray(size);\n } else {\n this.bits = bits;\n }\n }\n }\n\n public getSize(): number /*int*/ {\n return this.size;\n }\n\n public getSizeInBytes(): number /*int*/ {\n return Math.floor((this.size + 7) / 8);\n }\n\n private ensureCapacity(size: number /*int*/): void {\n if (size > this.bits.length * 32) {\n const newBits = BitArray.makeArray(size);\n System.arraycopy(this.bits, 0, newBits, 0, this.bits.length);\n this.bits = newBits;\n }\n }\n\n /**\n * @param i bit to get\n * @return true iff bit i is set\n */\n public get(i: number /*int*/): boolean {\n return (this.bits[Math.floor(i / 32)] & (1 << (i & 0x1F))) !== 0;\n }\n\n /**\n * Sets bit i.\n *\n * @param i bit to set\n */\n public set(i: number /*int*/): void {\n this.bits[Math.floor(i / 32)] |= 1 << (i & 0x1F);\n }\n\n /**\n * Flips bit i.\n *\n * @param i bit to set\n */\n public flip(i: number /*int*/): void {\n this.bits[Math.floor(i / 32)] ^= 1 << (i & 0x1F);\n }\n\n /**\n * @param from first bit to check\n * @return index of first bit that is set, starting from the given index, or size if none are set\n * at or beyond this given index\n * @see #getNextUnset(int)\n */\n public getNextSet(from: number /*int*/): number /*int*/ {\n const size = this.size;\n if (from >= size) {\n return size;\n }\n const bits = this.bits;\n let bitsOffset = Math.floor(from / 32);\n let currentBits = bits[bitsOffset];\n // mask off lesser bits first\n currentBits &= ~((1 << (from & 0x1F)) - 1);\n const length = bits.length;\n while (currentBits === 0) {\n if (++bitsOffset === length) {\n return size;\n }\n currentBits = bits[bitsOffset];\n }\n const result = (bitsOffset * 32) + Integer.numberOfTrailingZeros(currentBits);\n return result > size ? size : result;\n }\n\n /**\n * @param from index to start looking for unset bit\n * @return index of next unset bit, or {@code size} if none are unset until the end\n * @see #getNextSet(int)\n */\n public getNextUnset(from: number /*int*/): number /*int*/ {\n const size = this.size;\n if (from >= size) {\n return size;\n }\n const bits = this.bits;\n let bitsOffset = Math.floor(from / 32);\n let currentBits = ~bits[bitsOffset];\n // mask off lesser bits first\n currentBits &= ~((1 << (from & 0x1F)) - 1);\n const length = bits.length;\n while (currentBits === 0) {\n if (++bitsOffset === length) {\n return size;\n }\n currentBits = ~bits[bitsOffset];\n }\n const result = (bitsOffset * 32) + Integer.numberOfTrailingZeros(currentBits);\n return result > size ? size : result;\n }\n\n /**\n * Sets a block of 32 bits, starting at bit i.\n *\n * @param i first bit to set\n * @param newBits the new value of the next 32 bits. Note again that the least-significant bit\n * corresponds to bit i, the next-least-significant to i+1, and so on.\n */\n public setBulk(i: number /*int*/, newBits: number /*int*/): void {\n this.bits[Math.floor(i / 32)] = newBits;\n }\n\n /**\n * Sets a range of bits.\n *\n * @param start start of range, inclusive.\n * @param end end of range, exclusive\n */\n public setRange(start: number /*int*/, end: number /*int*/): void {\n if (end < start || start < 0 || end > this.size) {\n throw new IllegalArgumentException();\n }\n if (end === start) {\n return;\n }\n end--; // will be easier to treat this as the last actually set bit -- inclusive\n const firstInt = Math.floor(start / 32);\n const lastInt = Math.floor(end / 32);\n const bits = this.bits;\n for (let i = firstInt; i <= lastInt; i++) {\n const firstBit = i > firstInt ? 0 : start & 0x1F;\n const lastBit = i < lastInt ? 31 : end & 0x1F;\n // Ones from firstBit to lastBit, inclusive\n const mask = (2 << lastBit) - (1 << firstBit);\n bits[i] |= mask;\n }\n }\n\n /**\n * Clears all bits (sets to false).\n */\n public clear(): void {\n const max = this.bits.length;\n const bits = this.bits;\n for (let i = 0; i < max; i++) {\n bits[i] = 0;\n }\n }\n\n /**\n * Efficient method to check if a range of bits is set, or not set.\n *\n * @param start start of range, inclusive.\n * @param end end of range, exclusive\n * @param value if true, checks that bits in range are set, otherwise checks that they are not set\n * @return true iff all bits are set or not set in range, according to value argument\n * @throws IllegalArgumentException if end is less than start or the range is not contained in the array\n */\n public isRange(start: number /*int*/, end: number /*int*/, value: boolean): boolean {\n if (end < start || start < 0 || end > this.size) {\n throw new IllegalArgumentException();\n }\n if (end === start) {\n return true; // empty range matches\n }\n end--; // will be easier to treat this as the last actually set bit -- inclusive\n const firstInt = Math.floor(start / 32);\n const lastInt = Math.floor(end / 32);\n const bits = this.bits;\n for (let i = firstInt; i <= lastInt; i++) {\n const firstBit = i > firstInt ? 0 : start & 0x1F;\n const lastBit = i < lastInt ? 31 : end & 0x1F;\n // Ones from firstBit to lastBit, inclusive\n const mask = (2 << lastBit) - (1 << firstBit) & 0xFFFFFFFF;\n // TYPESCRIPTPORT: & 0xFFFFFFFF added to discard anything after 32 bits, as ES has 53 bits\n // Return false if we're looking for 1s and the masked bits[i] isn't all 1s (is: that,\n // equals the mask, or we're looking for 0s and the masked portion is not all 0s\n if ((bits[i] & mask) !== (value ? mask : 0)) {\n return false;\n }\n }\n return true;\n }\n\n public appendBit(bit: boolean): void {\n this.ensureCapacity(this.size + 1);\n if (bit) {\n this.bits[Math.floor(this.size / 32)] |= 1 << (this.size & 0x1F);\n }\n this.size++;\n }\n\n /**\n * Appends the least-significant bits, from value, in order from most-significant to\n * least-significant. For example, appending 6 bits from 0x000001E will append the bits\n * 0, 1, 1, 1, 1, 0 in that order.\n *\n * @param value {@code int} containing bits to append\n * @param numBits bits from value to append\n */\n public appendBits(value: number /*int*/, numBits: number /*int*/): void {\n if (numBits < 0 || numBits > 32) {\n throw new IllegalArgumentException('Num bits must be between 0 and 32');\n }\n this.ensureCapacity(this.size + numBits);\n const appendBit = this.appendBit;\n for (let numBitsLeft = numBits; numBitsLeft > 0; numBitsLeft--) {\n this.appendBit(((value >> (numBitsLeft - 1)) & 0x01) === 1);\n }\n }\n\n public appendBitArray(other: BitArray): void {\n const otherSize = other.size;\n this.ensureCapacity(this.size + otherSize);\n const appendBit = this.appendBit;\n for (let i = 0; i < otherSize; i++) {\n this.appendBit(other.get(i));\n }\n }\n\n public xor(other: BitArray): void {\n if (this.size !== other.size) {\n throw new IllegalArgumentException('Sizes don\\'t match');\n }\n const bits = this.bits;\n for (let i = 0, length = bits.length; i < length; i++) {\n // The last int could be incomplete (i.e. not have 32 bits in\n // it) but there is no problem since 0 XOR 0 == 0.\n bits[i] ^= other.bits[i];\n }\n }\n\n /**\n *\n * @param bitOffset first bit to start writing\n * @param array array to write into. Bytes are written most-significant byte first. This is the opposite\n * of the internal representation, which is exposed by {@link #getBitArray()}\n * @param offset position in array to start writing\n * @param numBytes how many bytes to write\n */\n public toBytes(bitOffset: number /*int*/, array: Uint8Array, offset: number /*int*/, numBytes: number /*int*/): void {\n for (let i = 0; i < numBytes; i++) {\n let theByte = 0;\n for (let j = 0; j < 8; j++) {\n if (this.get(bitOffset)) {\n theByte |= 1 << (7 - j);\n }\n bitOffset++;\n }\n array[offset + i] = /*(byte)*/ theByte;\n }\n }\n\n /**\n * @return underlying array of ints. The first element holds the first 32 bits, and the least\n * significant bit is bit 0.\n */\n public getBitArray(): Int32Array {\n return this.bits;\n }\n\n /**\n * Reverses all bits in the array.\n */\n public reverse(): void {\n const newBits = new Int32Array(this.bits.length);\n // reverse all int's first\n const len = Math.floor((this.size - 1) / 32);\n const oldBitsLen = len + 1;\n const bits = this.bits;\n for (let i = 0; i < oldBitsLen; i++) {\n let x = bits[i];\n x = ((x >> 1) & 0x55555555) | ((x & 0x55555555) << 1);\n x = ((x >> 2) & 0x33333333) | ((x & 0x33333333) << 2);\n x = ((x >> 4) & 0x0f0f0f0f) | ((x & 0x0f0f0f0f) << 4);\n x = ((x >> 8) & 0x00ff00ff) | ((x & 0x00ff00ff) << 8);\n x = ((x >> 16) & 0x0000ffff) | ((x & 0x0000ffff) << 16);\n newBits[len - i] = /*(int)*/ x;\n }\n // now correct the int's if the bit size isn't a multiple of 32\n if (this.size !== oldBitsLen * 32) {\n const leftOffset = oldBitsLen * 32 - this.size;\n let currentInt = newBits[0] >>> leftOffset;\n for (let i = 1; i < oldBitsLen; i++) {\n const nextInt = newBits[i];\n currentInt |= nextInt << (32 - leftOffset);\n newBits[i - 1] = currentInt;\n currentInt = nextInt >>> leftOffset;\n }\n newBits[oldBitsLen - 1] = currentInt;\n }\n this.bits = newBits;\n }\n\n private static makeArray(size: number /*int*/): Int32Array {\n return new Int32Array(Math.floor((size + 31) / 32));\n }\n\n /*@Override*/\n public equals(o: any): boolean {\n if (!(o instanceof BitArray)) {\n return false;\n }\n const other =This class contains utility methods for performing mathematical operations over\n * the Galois Fields. Operations use a given primitive polynomial in calculations.
\n *\n *Throughout this package, elements of the GF are represented as an {@code int}\n * for convenience and speed (but at the cost of memory).\n *
\n *\n * @author Sean Owen\n * @author David Olivier\n */\nexport default class GenericGF extends AbstractGenericGF {\n public static AZTEC_DATA_12 = new GenericGF(0x1069, 4096, 1); // x^12 + x^6 + x^5 + x^3 + 1\n public static AZTEC_DATA_10 = new GenericGF(0x409, 1024, 1); // x^10 + x^3 + 1\n public static AZTEC_DATA_6 = new GenericGF(0x43, 64, 1); // x^6 + x + 1\n public static AZTEC_PARAM = new GenericGF(0x13, 16, 1); // x^4 + x + 1\n public static QR_CODE_FIELD_256 = new GenericGF(0x011d, 256, 0); // x^8 + x^4 + x^3 + x^2 + 1\n public static DATA_MATRIX_FIELD_256 = new GenericGF(0x012d, 256, 1); // x^8 + x^5 + x^3 + x^2 + 1\n public static AZTEC_DATA_8 = GenericGF.DATA_MATRIX_FIELD_256;\n public static MAXICODE_FIELD_64 = GenericGF.AZTEC_DATA_6;\n\n private zero: GenericGFPoly;\n private one: GenericGFPoly;\n\n /**\n * Create a representation of GF(size) using the given primitive polynomial.\n *\n * @param primitive irreducible polynomial whose coefficients are represented by\n * the bits of an int, where the least-significant bit represents the constant\n * coefficient\n * @param size the size of the field\n * @param b the factor b in the generator polynomial can be 0- or 1-based\n * (g(x) = (x+a^b)(x+a^(b+1))...(x+a^(b+2t-1))).\n * In most cases it should be 1, but for QR code it is 0.\n */\n public constructor(\n private primitive: number /*int*/,\n private size: number /*int*/,\n private generatorBase: number /*int*/\n ) {\n super();\n const expTable = new Int32Array(size);\n let x = 1;\n for (let i = 0; i < size; i++) {\n expTable[i] = x;\n x *= 2; // we're assuming the generator alpha is 2\n if (x >= size) {\n x ^= primitive;\n x &= size - 1;\n }\n }\n this.expTable = expTable;\n\n const logTable = new Int32Array(size);\n for (let i = 0; i < size - 1; i++) {\n logTable[expTable[i]] = i;\n }\n this.logTable = logTable;\n\n // logTable[0] == 0 but this should never be used\n this.zero = new GenericGFPoly(this, Int32Array.from([0]));\n this.one = new GenericGFPoly(this, Int32Array.from([1]));\n }\n\n public getZero(): GenericGFPoly {\n return this.zero;\n }\n\n public getOne(): GenericGFPoly {\n return this.one;\n }\n\n /**\n * @return the monomial representing coefficient * x^degree\n */\n public buildMonomial(\n degree: number /*int*/,\n coefficient: number /*int*/\n ): GenericGFPoly {\n if (degree < 0) {\n throw new IllegalArgumentException();\n }\n if (coefficient === 0) {\n return this.zero;\n }\n const coefficients = new Int32Array(degree + 1);\n coefficients[0] = coefficient;\n return new GenericGFPoly(this, coefficients);\n }\n\n /**\n * @return multiplicative inverse of a\n */\n public inverse(a: number /*int*/): number /*int*/ {\n if (a === 0) {\n throw new ArithmeticException();\n }\n return this.expTable[this.size - this.logTable[a] - 1];\n }\n\n /**\n * @return product of a and b in GF(size)\n */\n public multiply(a: number /*int*/, b: number /*int*/): number /*int*/ {\n if (a === 0 || b === 0) {\n return 0;\n }\n return this.expTable[\n (this.logTable[a] + this.logTable[b]) % (this.size - 1)\n ];\n }\n\n public getSize(): number /*int*/ {\n return this.size;\n }\n\n public getGeneratorBase(): number /*int*/ {\n return this.generatorBase;\n }\n\n /*@Override*/\n public toString(): string {\n return (\n 'GF(0x' + Integer.toHexString(this.primitive) + ',' + this.size + ')'\n );\n }\n\n public equals(o: Object): boolean {\n return o === this;\n }\n}\n","/*\n* Copyright 2009 ZXing authors\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n* http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n// package com.google.zxing.pdf417;\n\n// import java.util.Arrays;\nimport Arrays from '../util/Arrays';\n// import java.util.Collection;\n\n// import com.google.zxing.common.detector.MathUtils;\nimport MathUtils from '../common/detector/MathUtils';\n\nimport { int } from '../../customTypings';\n\n/**\n * @author SITA Lab (kevin.osullivan@sita.aero)\n * @author Guenther Grau\n */\nexport default /*public final*/ class PDF417Common {\n\n public static /*final int*/ NUMBER_OF_CODEWORDS = 929;\n // Maximum Codewords (Data + Error).\n public static /*final int*/ MAX_CODEWORDS_IN_BARCODE = PDF417Common.NUMBER_OF_CODEWORDS - 1;\n public static /*final int*/ MIN_ROWS_IN_BARCODE = 3;\n public static /*final int*/ MAX_ROWS_IN_BARCODE = 90;\n // One left row indication column + max 30 data columns + one right row indicator column\n // public static /*final*/ MAX_CODEWORDS_IN_ROW: /*int*/ number = 32;\n public static /*final int*/ MODULES_IN_CODEWORD = 17;\n public static /*final int*/ MODULES_IN_STOP_PATTERN = 18;\n public static /*final int*/ BARS_IN_MODULE = 8;\n\n private static /*final int[]*/ EMPTY_INT_ARRAY: Int32Array = new Int32Array([]);\n\n private PDF417Common() {\n }\n\n /**\n * @param moduleBitCount values to sum\n * @return sum of values\n * @deprecated call {@link MathUtils#sum(int[])}\n */\n // @Deprecated\n public static getBitCountSum(moduleBitCount: Int32Array): int {\n return MathUtils.sum(moduleBitCount);\n }\n\n public static toIntArray(list: /*CollectionEncapsulates the result of decoding a matrix of bits. This typically\n * applies to 2D barcode formats. For now it contains the raw bytes obtained,\n * as well as a String interpretation of those bytes, if applicable.
\n *\n * @author Sean Owen\n */\nexport default class DecoderResult {\n\n private numBits: number; /*int*/\n private errorsCorrected: number; /*Integer*/\n private erasures: number; /*Integer*/\n private other: any;\n\n // public constructor(rawBytes: Uint8Array,\n // text: string,\n // ListImplements Reed-Solomon decoding, as the name implies.
\n *\n *The algorithm will not be explained here, but the following references were helpful\n * in creating this implementation:
\n *\n *Much credit is due to William Rucklidge since portions of this code are an indirect\n * port of his C++ Reed-Solomon implementation.
\n *\n * @author Sean Owen\n * @author William Rucklidge\n * @author sanfordsquires\n */\nexport default class ReedSolomonDecoder {\n\n public constructor(private field: GenericGF) { }\n\n /**\n *Decodes given set of received codewords, which include both data and error-correction\n * codewords. Really, this means it uses Reed-Solomon to detect and correct errors, in-place,\n * in the input.
\n *\n * @param received data and error-correction codewords\n * @param twoS number of error-correction codewords available\n * @throws ReedSolomonException if decoding fails for any reason\n */\n public decode(received: Int32Array, twoS: number /*int*/): void /*throws ReedSolomonException*/ {\n const field = this.field;\n const poly = new GenericGFPoly(field, received);\n const syndromeCoefficients = new Int32Array(twoS);\n let noError: boolean = true;\n for (let i = 0; i < twoS; i++) {\n const evalResult = poly.evaluateAt(field.exp(i + field.getGeneratorBase()));\n syndromeCoefficients[syndromeCoefficients.length - 1 - i] = evalResult;\n if (evalResult !== 0) {\n noError = false;\n }\n }\n if (noError) {\n return;\n }\n const syndrome = new GenericGFPoly(field, syndromeCoefficients);\n const sigmaOmega = this.runEuclideanAlgorithm(field.buildMonomial(twoS, 1), syndrome, twoS);\n const sigma = sigmaOmega[0];\n const omega = sigmaOmega[1];\n const errorLocations = this.findErrorLocations(sigma);\n const errorMagnitudes = this.findErrorMagnitudes(omega, errorLocations);\n for (let i = 0; i < errorLocations.length; i++) {\n const position = received.length - 1 - field.log(errorLocations[i]);\n if (position < 0) {\n throw new ReedSolomonException('Bad error location');\n }\n received[position] = GenericGF.addOrSubtract(received[position], errorMagnitudes[i]);\n }\n }\n\n private runEuclideanAlgorithm(a: GenericGFPoly, b: GenericGFPoly, R: number /*int*/): GenericGFPoly[] {\n // Assume a's degree is >= b's\n if (a.getDegree() < b.getDegree()) {\n const temp = a;\n a = b;\n b = temp;\n }\n\n const field = this.field;\n\n let rLast = a;\n let r = b;\n let tLast = field.getZero();\n let t = field.getOne();\n\n // Run Euclidean algorithm until r's degree is less than R/2\n while (r.getDegree() >= (R / 2 | 0)) {\n let rLastLast = rLast;\n let tLastLast = tLast;\n rLast = r;\n tLast = t;\n\n // Divide rLastLast by rLast, with quotient in q and remainder in r\n if (rLast.isZero()) {\n // Oops, Euclidean algorithm already terminated?\n throw new ReedSolomonException('r_{i-1} was zero');\n }\n r = rLastLast;\n let q = field.getZero();\n const denominatorLeadingTerm = rLast.getCoefficient(rLast.getDegree());\n const dltInverse = field.inverse(denominatorLeadingTerm);\n while (r.getDegree() >= rLast.getDegree() && !r.isZero()) {\n const degreeDiff = r.getDegree() - rLast.getDegree();\n const scale = field.multiply(r.getCoefficient(r.getDegree()), dltInverse);\n q = q.addOrSubtract(field.buildMonomial(degreeDiff, scale));\n r = r.addOrSubtract(rLast.multiplyByMonomial(degreeDiff, scale));\n }\n\n t = q.multiply(tLast).addOrSubtract(tLastLast);\n\n if (r.getDegree() >= rLast.getDegree()) {\n throw new IllegalStateException('Division algorithm failed to reduce polynomial?');\n }\n }\n\n const sigmaTildeAtZero = t.getCoefficient(0);\n if (sigmaTildeAtZero === 0) {\n throw new ReedSolomonException('sigmaTilde(0) was zero');\n }\n\n const inverse = field.inverse(sigmaTildeAtZero);\n const sigma = t.multiplyScalar(inverse);\n const omega = r.multiplyScalar(inverse);\n return [sigma, omega];\n }\n\n private findErrorLocations(errorLocator: GenericGFPoly): Int32Array /*throws ReedSolomonException*/ {\n // This is a direct application of Chien's search\n const numErrors = errorLocator.getDegree();\n if (numErrors === 1) { // shortcut\n return Int32Array.from([errorLocator.getCoefficient(1)]);\n }\n const result = new Int32Array(numErrors);\n let e = 0;\n const field = this.field;\n for (let i = 1; i < field.getSize() && e < numErrors; i++) {\n if (errorLocator.evaluateAt(i) === 0) {\n result[e] = field.inverse(i);\n e++;\n }\n }\n if (e !== numErrors) {\n throw new ReedSolomonException('Error locator degree does not match number of roots');\n }\n return result;\n }\n\n private findErrorMagnitudes(errorEvaluator: GenericGFPoly, errorLocations: Int32Array): Int32Array {\n // This is directly applying Forney's Formula\n const s = errorLocations.length;\n const result = new Int32Array(s);\n const field = this.field;\n for (let i = 0; i < s; i++) {\n const xiInverse = field.inverse(errorLocations[i]);\n let denominator = 1;\n for (let j = 0; j < s; j++) {\n if (i !== j) {\n // denominator = field.multiply(denominator,\n // GenericGF.addOrSubtract(1, field.multiply(errorLocations[j], xiInverse)))\n // Above should work but fails on some Apple and Linux JDKs due to a Hotspot bug.\n // Below is a funny-looking workaround from Steven Parkes\n const term = field.multiply(errorLocations[j], xiInverse);\n const termPlus1 = (term & 0x1) === 0 ? term | 1 : term & ~1;\n denominator = field.multiply(denominator, termPlus1);\n }\n }\n result[i] = field.multiply(errorEvaluator.evaluateAt(xiInverse),\n field.inverse(denominator));\n if (field.getGeneratorBase() !== 0) {\n result[i] = field.multiply(result[i], xiInverse);\n }\n }\n return result;\n }\n\n}\n","/*\n * Copyright (C) 2010 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/*namespace com.google.zxing.common {*/\n\n/*import java.nio.charset.Charset;*/\n/*import java.util.Map;*/\n\nimport DecodeHintType from '../DecodeHintType';\nimport CharacterSetECI from './CharacterSetECI';\nimport StringEncoding from '../util/StringEncoding';\nimport { int } from '../../customTypings';\nimport Charset from '../util/Charset';\n\n/**\n * Common string-related functions.\n *\n * @author Sean Owen\n * @author Alex Dupre\n */\nexport default class StringUtils {\n\n public static SHIFT_JIS = CharacterSetECI.SJIS.getName(); // \"SJIS\"\n public static GB2312 = 'GB2312';\n public static ISO88591 = CharacterSetECI.ISO8859_1.getName(); // \"ISO8859_1\"\n private static EUC_JP = 'EUC_JP';\n private static UTF8 = CharacterSetECI.UTF8.getName(); // \"UTF8\"\n private static PLATFORM_DEFAULT_ENCODING = StringUtils.UTF8; // \"UTF8\"//Charset.defaultCharset().name()\n private static ASSUME_SHIFT_JIS = false;\n // SHIFT_JIS.equalsIgnoreCase(PLATFORM_DEFAULT_ENCODING) ||\n // EUC_JP.equalsIgnoreCase(PLATFORM_DEFAULT_ENCODING);\n\n static castAsNonUtf8Char(code: number, encoding: Charset = null) {\n // ISO 8859-1 is the Java default as UTF-8 is JavaScripts\n // you can see this method as a Java version of String.fromCharCode\n const e = encoding ? encoding.getName() : this.ISO88591;\n // use passed format (fromCharCode will return UTF8 encoding)\n return StringEncoding.decode(new Uint8Array([code]), e);\n }\n\n /**\n * @param bytes bytes encoding a string, whose encoding should be guessed\n * @param hints decode hints if applicable\n * @return name of guessed encoding; at the moment will only guess one of:\n * {@link #SHIFT_JIS}, {@link #UTF8}, {@link #ISO88591}, or the platform\n * default encoding if none of these can possibly be correct\n */\n public static guessEncoding(bytes: Uint8Array, hints: MapRepresents a polynomial whose coefficients are elements of a GF.\n * Instances of this class are immutable.
\n *\n *Much credit is due to William Rucklidge since portions of this code are an indirect\n * port of his C++ Reed-Solomon implementation.
\n *\n * @author Sean Owen\n */\nexport default class GenericGFPoly {\n\n private field: AbstractGenericGF;\n private coefficients: Int32Array;\n\n /**\n * @param field the {@link GenericGF} instance representing the field to use\n * to perform computations\n * @param coefficients coefficients as ints representing elements of GF(size), arranged\n * from most significant (highest-power term) coefficient to least significant\n * @throws IllegalArgumentException if argument is null or empty,\n * or if leading coefficient is 0 and this is not a\n * constant polynomial (that is, it is not the monomial \"0\")\n */\n public constructor(field: AbstractGenericGF, coefficients: Int32Array) {\n if (coefficients.length === 0) {\n throw new IllegalArgumentException();\n }\n this.field = field;\n const coefficientsLength = coefficients.length;\n if (coefficientsLength > 1 && coefficients[0] === 0) {\n // Leading term must be non-zero for anything except the constant polynomial \"0\"\n let firstNonZero = 1;\n while (firstNonZero < coefficientsLength && coefficients[firstNonZero] === 0) {\n firstNonZero++;\n }\n if (firstNonZero === coefficientsLength) {\n this.coefficients = Int32Array.from([0]);\n } else {\n this.coefficients = new Int32Array(coefficientsLength - firstNonZero);\n System.arraycopy(coefficients,\n firstNonZero,\n this.coefficients,\n 0,\n this.coefficients.length);\n }\n } else {\n this.coefficients = coefficients;\n }\n }\n\n public getCoefficients(): Int32Array {\n return this.coefficients;\n }\n\n /**\n * @return degree of this polynomial\n */\n public getDegree(): number {\n return this.coefficients.length - 1;\n }\n\n /**\n * @return true iff this polynomial is the monomial \"0\"\n */\n public isZero(): boolean {\n return this.coefficients[0] === 0;\n }\n\n /**\n * @return coefficient of x^degree term in this polynomial\n */\n public getCoefficient(degree: number /*int*/): number {\n return this.coefficients[this.coefficients.length - 1 - degree];\n }\n\n /**\n * @return evaluation of this polynomial at a given point\n */\n public evaluateAt(a: number /*int*/): number {\n if (a === 0) {\n // Just return the x^0 coefficient\n return this.getCoefficient(0);\n }\n const coefficients = this.coefficients;\n let result: number;\n if (a === 1) {\n // Just the sum of the coefficients\n result = 0;\n for (let i = 0, length = coefficients.length; i !== length; i++) {\n const coefficient = coefficients[i];\n result = AbstractGenericGF.addOrSubtract(result, coefficient);\n }\n return result;\n }\n result = coefficients[0];\n const size = coefficients.length;\n const field = this.field;\n for (let i = 1; i < size; i++) {\n result = AbstractGenericGF.addOrSubtract(field.multiply(a, result), coefficients[i]);\n }\n return result;\n }\n\n public addOrSubtract(other: GenericGFPoly): GenericGFPoly {\n if (!this.field.equals(other.field)) {\n throw new IllegalArgumentException('GenericGFPolys do not have same GenericGF field');\n }\n if (this.isZero()) {\n return other;\n }\n if (other.isZero()) {\n return this;\n }\n\n let smallerCoefficients = this.coefficients;\n let largerCoefficients = other.coefficients;\n if (smallerCoefficients.length > largerCoefficients.length) {\n const temp = smallerCoefficients;\n smallerCoefficients = largerCoefficients;\n largerCoefficients = temp;\n }\n let sumDiff = new Int32Array(largerCoefficients.length);\n const lengthDiff = largerCoefficients.length - smallerCoefficients.length;\n // Copy high-order terms only found in higher-degree polynomial's coefficients\n System.arraycopy(largerCoefficients, 0, sumDiff, 0, lengthDiff);\n\n for (let i = lengthDiff; i < largerCoefficients.length; i++) {\n sumDiff[i] = AbstractGenericGF.addOrSubtract(smallerCoefficients[i - lengthDiff], largerCoefficients[i]);\n }\n\n return new GenericGFPoly(this.field, sumDiff);\n }\n\n public multiply(other: GenericGFPoly): GenericGFPoly {\n if (!this.field.equals(other.field)) {\n throw new IllegalArgumentException('GenericGFPolys do not have same GenericGF field');\n }\n if (this.isZero() || other.isZero()) {\n return this.field.getZero();\n }\n const aCoefficients = this.coefficients;\n const aLength = aCoefficients.length;\n const bCoefficients = other.coefficients;\n const bLength = bCoefficients.length;\n const product = new Int32Array(aLength + bLength - 1);\n const field = this.field;\n for (let i = 0; i < aLength; i++) {\n const aCoeff = aCoefficients[i];\n for (let j = 0; j < bLength; j++) {\n product[i + j] = AbstractGenericGF.addOrSubtract(product[i + j],\n field.multiply(aCoeff, bCoefficients[j]));\n }\n }\n return new GenericGFPoly(field, product);\n }\n\n public multiplyScalar(scalar: number /*int*/): GenericGFPoly {\n if (scalar === 0) {\n return this.field.getZero();\n }\n if (scalar === 1) {\n return this;\n }\n const size = this.coefficients.length;\n const field = this.field;\n const product = new Int32Array(size);\n const coefficients = this.coefficients;\n for (let i = 0; i < size; i++) {\n product[i] = field.multiply(coefficients[i], scalar);\n }\n return new GenericGFPoly(field, product);\n }\n\n public multiplyByMonomial(degree: number /*int*/, coefficient: number /*int*/): GenericGFPoly {\n if (degree < 0) {\n throw new IllegalArgumentException();\n }\n if (coefficient === 0) {\n return this.field.getZero();\n }\n const coefficients = this.coefficients;\n const size = coefficients.length;\n const product = new Int32Array(size + degree);\n const field = this.field;\n for (let i = 0; i < size; i++) {\n product[i] = field.multiply(coefficients[i], coefficient);\n }\n return new GenericGFPoly(field, product);\n }\n\n public divide(other: GenericGFPoly): GenericGFPoly[] {\n if (!this.field.equals(other.field)) {\n throw new IllegalArgumentException('GenericGFPolys do not have same GenericGF field');\n }\n if (other.isZero()) {\n throw new IllegalArgumentException('Divide by 0');\n }\n\n const field = this.field;\n\n let quotient: GenericGFPoly = field.getZero();\n let remainder: GenericGFPoly = this;\n\n const denominatorLeadingTerm = other.getCoefficient(other.getDegree());\n const inverseDenominatorLeadingTerm = field.inverse(denominatorLeadingTerm);\n\n while (remainder.getDegree() >= other.getDegree() && !remainder.isZero()) {\n const degreeDifference = remainder.getDegree() - other.getDegree();\n const scale = field.multiply(remainder.getCoefficient(remainder.getDegree()), inverseDenominatorLeadingTerm);\n const term = other.multiplyByMonomial(degreeDifference, scale);\n const iterationQuotient = field.buildMonomial(degreeDifference, scale);\n quotient = quotient.addOrSubtract(iterationQuotient);\n remainder = remainder.addOrSubtract(term);\n }\n\n return [quotient, remainder];\n }\n\n /*@Override*/\n public toString(): string {\n let result = '';\n for (let degree = this.getDegree(); degree >= 0; degree--) {\n let coefficient = this.getCoefficient(degree);\n if (coefficient !== 0) {\n if (coefficient < 0) {\n result += ' - ';\n coefficient = -coefficient;\n } else {\n if (result.length > 0) {\n result += ' + ';\n }\n }\n if (degree === 0 || coefficient !== 1) {\n const alphaPower = this.field.log(coefficient);\n if (alphaPower === 0) {\n result += '1';\n } else if (alphaPower === 1) {\n result += 'a';\n } else {\n result += 'a^';\n result += alphaPower;\n }\n }\n if (degree !== 0) {\n if (degree === 1) {\n result += 'x';\n } else {\n result += 'x^';\n result += degree;\n }\n }\n }\n }\n return result;\n }\n\n}\n","/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/*namespace com.google.zxing.common {*/\n\nimport ResultPoint from '../ResultPoint';\nimport BitMatrix from './BitMatrix';\n\n/**\n *Encapsulates the result of detecting a barcode in an image. This includes the raw\n * matrix of black/white pixels corresponding to the barcode, and possibly points of interest\n * in the image, like the location of finder patterns or corners of the barcode in the image.
\n *\n * @author Sean Owen\n */\nexport default class DetectorResult {\n\n private bits: BitMatrix;\n private points: ArrayEncapsulates functionality and implementation that is common to UPC and EAN families\n * of one-dimensional barcodes.
\n *\n * @author dswitkin@google.com (Daniel Switkin)\n * @author Sean Owen\n * @author alasdair@google.com (Alasdair Mackintosh)\n */\nexport default abstract class AbstractUPCEANReader extends OneDReader {\n // These two values are critical for determining how permissive the decoding will be.\n // We've arrived at these values through a lot of trial and error. Setting them any higher\n // lets false positives creep in quickly.\n private static MAX_AVG_VARIANCE = 0.48;\n private static MAX_INDIVIDUAL_VARIANCE = 0.7;\n\n /**\n * Start/end guard pattern.\n */\n public static START_END_PATTERN: number[] = [1, 1, 1];\n\n /**\n * Pattern marking the middle of a UPC/EAN pattern, separating the two halves.\n */\n public static MIDDLE_PATTERN: number[] = [1, 1, 1, 1, 1];\n /**\n * end guard pattern.\n */\n public static END_PATTERN: number[] = [1, 1, 1, 1, 1, 1];\n /**\n * \"Odd\", or \"L\" patterns used to encode UPC/EAN digits.\n */\n public static L_PATTERNS: number[][] = [\n [3, 2, 1, 1], // 0\n [2, 2, 2, 1], // 1\n [2, 1, 2, 2], // 2\n [1, 4, 1, 1], // 3\n [1, 1, 3, 2], // 4\n [1, 2, 3, 1], // 5\n [1, 1, 1, 4], // 6\n [1, 3, 1, 2], // 7\n [1, 2, 1, 3], // 8\n [3, 1, 1, 2], // 9\n ];\n\n /**\n * As above but also including the \"even\", or \"G\" patterns used to encode UPC/EAN digits.\n */\n public static L_AND_G_PATTERNS: number[][];\n\n protected decodeRowStringBuffer = '';\n // private final UPCEANExtensionSupport extensionReader;\n // private final EANManufacturerOrgSupport eanManSupport;\n\n\n /*\n protected UPCEANReader() {\n decodeRowStringBuffer = new StringBuilder(20);\n extensionReader = new UPCEANExtensionSupport();\n eanManSupport = new EANManufacturerOrgSupport();\n }\n */\n\n static findStartGuardPattern(row: BitArray): number[] {\n let foundStart = false;\n let startRange: number[] = null;\n let nextStart = 0;\n let counters = [0, 0, 0];\n while (!foundStart) {\n counters = [0, 0, 0];\n startRange = AbstractUPCEANReader.findGuardPattern(row, nextStart, false, this.START_END_PATTERN, counters);\n let start = startRange[0];\n nextStart = startRange[1];\n let quietStart = start - (nextStart - start);\n if (quietStart >= 0) {\n foundStart = row.isRange(quietStart, start, false);\n }\n }\n return startRange;\n }\n\n public abstract decodeRow(rowNumber: number, row: BitArray, hints?: MapSee ISO 18004:2006, 6.5.1. This enum encapsulates the four error correction levels\n * defined by the QR code standard.
\n *\n * @author Sean Owen\n */\nexport default class ErrorCorrectionLevel {\n\n private static FOR_BITS = new Map\n * Detects a candidate barcode-like rectangular region within an image. It\n * starts around the center of the image, increases the size of the candidate\n * region until it finds a white rectangular region. By keeping track of the\n * last black points it encountered, it determines the corners of the barcode.\n *
\n *\n * @author David Olivier\n */\nexport default class WhiteRectangleDetector {\n\n private static INIT_SIZE = 10;\n private static CORR = 1;\n\n private height: number; /*int*/\n private width: number; /*int*/\n private leftInit: number; /*int*/\n private rightInit: number; /*int*/\n private downInit: number; /*int*/\n private upInit: number; /*int*/\n\n // public constructor(private image: BitMatrix) /*throws NotFoundException*/ {\n // this(image, INIT_SIZE, image.getWidth() / 2, image.getHeight() / 2)\n // }\n\n /**\n * @param image barcode image to find a rectangle in\n * @param initSize initial size of search area around center\n * @param x x position of search center\n * @param y y position of search center\n * @throws NotFoundException if image is too small to accommodate {@code initSize}\n */\n public constructor(private image: BitMatrix, initSize?: number /*int*/, x?: number /*int*/, y?: number /*int*/) /*throws NotFoundException*/ {\n this.height = image.getHeight();\n this.width = image.getWidth();\n if (undefined === initSize || null === initSize) {\n initSize = WhiteRectangleDetector.INIT_SIZE;\n }\n if (undefined === x || null === x) {\n x = image.getWidth() / 2 | 0;\n }\n if (undefined === y || null === y) {\n y = image.getHeight() / 2 | 0;\n }\n const halfsize = initSize / 2 | 0;\n this.leftInit = x - halfsize;\n this.rightInit = x + halfsize;\n this.upInit = y - halfsize;\n this.downInit = y + halfsize;\n if (this.upInit < 0 || this.leftInit < 0 || this.downInit >= this.height || this.rightInit >= this.width) {\n throw new NotFoundException();\n }\n }\n\n /**\n *\n * Detects a candidate barcode-like rectangular region within an image. It\n * starts around the center of the image, increases the size of the candidate\n * region until it finds a white rectangular region.\n *
\n *\n * @return {@link ResultPoint}[] describing the corners of the rectangular\n * region. The first and last points are opposed on the diagonal, as\n * are the second and third. The first point will be the topmost\n * point and the last, the bottommost. The second point will be\n * leftmost and the third, the rightmost\n * @throws NotFoundException if no Data Matrix Code can be found\n */\n public detect(): ArrayThis class implements a perspective transform in two dimensions. Given four source and four\n * destination points, it will compute the transformation implied between them. The code is based\n * directly upon section 3.4.2 of George Wolberg's \"Digital Image Warping\"; see pages 54-56.
\n *\n * @author Sean Owen\n */\nexport default class PerspectiveTransform {\n\n private constructor(private a11: number/*float*/, private a21: number/*float*/, private a31: number/*float*/,\n private a12: number/*float*/, private a22: number/*float*/, private a32: number/*float*/,\n private a13: number/*float*/, private a23: number/*float*/, private a33: number/*float*/) { }\n\n public static quadrilateralToQuadrilateral(\n x0: number/*float*/, y0: number/*float*/,\n x1: number/*float*/, y1: number/*float*/,\n x2: number/*float*/, y2: number/*float*/,\n x3: number/*float*/, y3: number/*float*/,\n x0p: number/*float*/, y0p: number/*float*/,\n x1p: number/*float*/, y1p: number/*float*/,\n x2p: number/*float*/, y2p: number/*float*/,\n x3p: number/*float*/, y3p: number/*float*/\n ): PerspectiveTransform {\n\n const qToS = PerspectiveTransform.quadrilateralToSquare(x0, y0, x1, y1, x2, y2, x3, y3);\n const sToQ = PerspectiveTransform.squareToQuadrilateral(x0p, y0p, x1p, y1p, x2p, y2p, x3p, y3p);\n\n return sToQ.times(qToS);\n }\n\n public transformPoints(points: Float32Array): void {\n\n const max = points.length;\n\n const a11 = this.a11;\n const a12 = this.a12;\n const a13 = this.a13;\n const a21 = this.a21;\n const a22 = this.a22;\n const a23 = this.a23;\n const a31 = this.a31;\n const a32 = this.a32;\n const a33 = this.a33;\n\n for (let i = 0; i < max; i += 2) {\n const x = points[i];\n const y = points[i + 1];\n const denominator = a13 * x + a23 * y + a33;\n points[i] = (a11 * x + a21 * y + a31) / denominator;\n points[i + 1] = (a12 * x + a22 * y + a32) / denominator;\n }\n }\n\n public transformPointsWithValues(xValues: Float32Array, yValues: Float32Array): void {\n\n const a11 = this.a11;\n const a12 = this.a12;\n const a13 = this.a13;\n const a21 = this.a21;\n const a22 = this.a22;\n const a23 = this.a23;\n const a31 = this.a31;\n const a32 = this.a32;\n const a33 = this.a33;\n\n const n = xValues.length;\n\n for (let i = 0; i < n; i++) {\n const x = xValues[i];\n const y = yValues[i];\n const denominator = a13 * x + a23 * y + a33;\n\n xValues[i] = (a11 * x + a21 * y + a31) / denominator;\n yValues[i] = (a12 * x + a22 * y + a32) / denominator;\n }\n }\n\n public static squareToQuadrilateral(\n x0: number/*float*/, y0: number/*float*/,\n x1: number/*float*/, y1: number/*float*/,\n x2: number/*float*/, y2: number/*float*/,\n x3: number/*float*/, y3: number/*float*/\n ): PerspectiveTransform {\n\n const dx3 = x0 - x1 + x2 - x3;\n const dy3 = y0 - y1 + y2 - y3;\n\n if (dx3 === 0.0 && dy3 === 0.0) {\n // Affine\n return new PerspectiveTransform(x1 - x0, x2 - x1, x0,\n y1 - y0, y2 - y1, y0,\n 0.0, 0.0, 1.0);\n } else {\n const dx1 = x1 - x2;\n const dx2 = x3 - x2;\n const dy1 = y1 - y2;\n const dy2 = y3 - y2;\n\n const denominator = dx1 * dy2 - dx2 * dy1;\n\n const a13 = (dx3 * dy2 - dx2 * dy3) / denominator;\n const a23 = (dx1 * dy3 - dx3 * dy1) / denominator;\n\n return new PerspectiveTransform(\n x1 - x0 + a13 * x1, x3 - x0 + a23 * x3, x0,\n y1 - y0 + a13 * y1, y3 - y0 + a23 * y3, y0,\n a13, a23, 1.0\n );\n }\n }\n\n public static quadrilateralToSquare(\n x0: number/*float*/, y0: number/*float*/,\n x1: number/*float*/, y1: number/*float*/,\n x2: number/*float*/, y2: number/*float*/,\n x3: number/*float*/, y3: number/*float*/\n ): PerspectiveTransform {\n // Here, the adjoint serves as the inverse:\n return PerspectiveTransform.squareToQuadrilateral(x0, y0, x1, y1, x2, y2, x3, y3).buildAdjoint();\n }\n\n protected buildAdjoint(): PerspectiveTransform {\n // Adjoint is the transpose of the cofactor matrix:\n return new PerspectiveTransform(\n this.a22 * this.a33 - this.a23 * this.a32,\n this.a23 * this.a31 - this.a21 * this.a33,\n this.a21 * this.a32 - this.a22 * this.a31,\n this.a13 * this.a32 - this.a12 * this.a33,\n this.a11 * this.a33 - this.a13 * this.a31,\n this.a12 * this.a31 - this.a11 * this.a32,\n this.a12 * this.a23 - this.a13 * this.a22,\n this.a13 * this.a21 - this.a11 * this.a23,\n this.a11 * this.a22 - this.a12 * this.a21\n );\n }\n\n protected times(other: PerspectiveTransform): PerspectiveTransform {\n return new PerspectiveTransform(\n this.a11 * other.a11 + this.a21 * other.a12 + this.a31 * other.a13,\n this.a11 * other.a21 + this.a21 * other.a22 + this.a31 * other.a23,\n this.a11 * other.a31 + this.a21 * other.a32 + this.a31 * other.a33,\n this.a12 * other.a11 + this.a22 * other.a12 + this.a32 * other.a13,\n this.a12 * other.a21 + this.a22 * other.a22 + this.a32 * other.a23,\n this.a12 * other.a31 + this.a22 * other.a32 + this.a32 * other.a33,\n this.a13 * other.a11 + this.a23 * other.a12 + this.a33 * other.a13,\n this.a13 * other.a21 + this.a23 * other.a22 + this.a33 * other.a23,\n this.a13 * other.a31 + this.a23 * other.a32 + this.a33 * other.a33\n );\n }\n\n}\n","/*\n * Copyright 2008 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/*namespace com.google.zxing.oned {*/\n\nimport BarcodeFormat from '../BarcodeFormat';\nimport BitArray from '../common/BitArray';\nimport Code39Reader from './Code39Reader';\nimport Code128Reader from './Code128Reader';\nimport RSS14Reader from './rss/RSS14Reader';\nimport DecodeHintType from '../DecodeHintType';\nimport ITFReader from './ITFReader';\nimport MultiFormatUPCEANReader from './MultiFormatUPCEANReader';\nimport NotFoundException from '../NotFoundException';\nimport OneDReader from './OneDReader';\nimport Result from '../Result';\n\n/**\n * @author Daniel SwitkinThis provides an easy abstraction to read bits at a time from a sequence of bytes, where the\n * number of bits read is not often a multiple of 8.
\n *\n *This class is thread-safe but not reentrant -- unless the caller modifies the bytes array\n * it passed in, in which case all bets are off.
\n *\n * @author Sean Owen\n */\nexport default class BitSource {\n\n private byteOffset: number; /*int*/\n private bitOffset: number; /*int*/\n\n /**\n * @param bytes bytes from which this will read bits. Bits will be read from the first byte first.\n * Bits are read within a byte from most-significant to least-significant bit.\n */\n public constructor(private bytes: Uint8Array) {\n this.byteOffset = 0;\n this.bitOffset = 0;\n }\n\n /**\n * @return index of next bit in current byte which would be read by the next call to {@link #readBits(int)}.\n */\n public getBitOffset(): number /*int*/ {\n return this.bitOffset;\n }\n\n /**\n * @return index of next byte in input byte array which would be read by the next call to {@link #readBits(int)}.\n */\n public getByteOffset(): number /*int*/ {\n return this.byteOffset;\n }\n\n /**\n * @param numBits number of bits to read\n * @return int representing the bits read. The bits will appear as the least-significant\n * bits of the int\n * @throws IllegalArgumentException if numBits isn't in [1,32] or more than is available\n */\n public readBits(numBits: number /*int*/): number /*int*/ {\n if (numBits < 1 || numBits > 32 || numBits > this.available()) {\n throw new IllegalArgumentException('' + numBits);\n }\n\n let result = 0;\n\n let bitOffset = this.bitOffset;\n let byteOffset = this.byteOffset;\n\n const bytes = this.bytes;\n // First, read remainder from current byte\n if (bitOffset > 0) {\n const bitsLeft = 8 - bitOffset;\n const toRead = numBits < bitsLeft ? numBits : bitsLeft;\n const bitsToNotRead = bitsLeft - toRead;\n const mask = (0xFF >> (8 - toRead)) << bitsToNotRead;\n\n result = (bytes[byteOffset] & mask) >> bitsToNotRead;\n numBits -= toRead;\n bitOffset += toRead;\n\n if (bitOffset === 8) {\n bitOffset = 0;\n byteOffset++;\n }\n }\n\n // Next read whole bytes\n if (numBits > 0) {\n\n while (numBits >= 8) {\n result = (result << 8) | (bytes[byteOffset] & 0xFF);\n byteOffset++;\n numBits -= 8;\n }\n\n // Finally read a partial byte\n if (numBits > 0) {\n const bitsToNotRead = 8 - numBits;\n const mask = (0xFF >> bitsToNotRead) << bitsToNotRead;\n\n result = (result << numBits) | ((bytes[byteOffset] & mask) >> bitsToNotRead);\n bitOffset += numBits;\n }\n }\n\n this.bitOffset = bitOffset;\n this.byteOffset = byteOffset;\n\n return result;\n }\n\n /**\n * @return number of bits that can be read successfully\n */\n public available(): number /*int*/ {\n return 8 * (this.bytes.length - this.byteOffset) - this.bitOffset;\n }\n\n}\n","/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/*namespace com.google.zxing.qrcode {*/\n\nimport BarcodeFormat from '../BarcodeFormat';\nimport BinaryBitmap from '../BinaryBitmap';\nimport DecodeHintType from '../DecodeHintType';\nimport Reader from '../Reader';\nimport Result from '../Result';\nimport ResultMetadataType from '../ResultMetadataType';\nimport ResultPoint from '../ResultPoint';\nimport BitMatrix from '../common/BitMatrix';\nimport DecoderResult from '../common/DecoderResult';\nimport DetectorResult from '../common/DetectorResult';\nimport Decoder from './decoder/Decoder';\nimport QRCodeDecoderMetaData from './decoder/QRCodeDecoderMetaData';\nimport Detector from './detector/Detector';\n\nimport NotFoundException from '../NotFoundException';\n\n/*import java.util.List;*/\n/*import java.util.Map;*/\n\n/**\n * This implementation can detect and decode QR Codes in an image.\n *\n * @author Sean Owen\n */\nexport default class QRCodeReader implements Reader {\n\n private static NO_POINTS = new ArrayDeduces version information purely from QR Code dimensions.
\n *\n * @param dimension dimension in modules\n * @return Version for a QR Code of that dimension\n * @throws FormatException if dimension is not 1 mod 4\n */\n public static getProvisionalVersionForDimension(dimension: number /*int*/): Version /*throws FormatException */ {\n if (dimension % 4 !== 1) {\n throw new FormatException();\n }\n try {\n return this.getVersionForNumber((dimension - 17) / 4);\n } catch (ignored/*: IllegalArgumentException*/) {\n throw new FormatException();\n }\n }\n\n public static getVersionForNumber(versionNumber: number /*int*/): Version {\n if (versionNumber < 1 || versionNumber > 40) {\n throw new IllegalArgumentException();\n }\n return Version.VERSIONS[versionNumber - 1];\n }\n\n public static decodeVersionInformation(versionBits: number /*int*/): Version {\n let bestDifference = Number.MAX_SAFE_INTEGER;\n let bestVersion = 0;\n for (let i = 0; i < Version.VERSION_DECODE_INFO.length; i++) {\n const targetVersion = Version.VERSION_DECODE_INFO[i];\n // Do the version info bits match exactly? done.\n if (targetVersion === versionBits) {\n return Version.getVersionForNumber(i + 7);\n }\n // Otherwise see if this is the closest to a real version info bit string\n // we have seen so far\n const bitsDifference = FormatInformation.numBitsDiffering(versionBits, targetVersion);\n if (bitsDifference < bestDifference) {\n bestVersion = i + 7;\n bestDifference = bitsDifference;\n }\n }\n // We can tolerate up to 3 bits of error since no two version info codewords will\n // differ in less than 8 bits.\n if (bestDifference <= 3) {\n return Version.getVersionForNumber(bestVersion);\n }\n // If we didn't find a close enough match, fail\n return null;\n }\n\n /**\n * See ISO 18004:2006 Annex E\n */\n public buildFunctionPattern(): BitMatrix {\n const dimension = this.getDimensionForVersion();\n const bitMatrix = new BitMatrix(dimension);\n\n // Top left finder pattern + separator + format\n bitMatrix.setRegion(0, 0, 9, 9);\n // Top right finder pattern + separator + format\n bitMatrix.setRegion(dimension - 8, 0, 8, 9);\n // Bottom left finder pattern + separator + format\n bitMatrix.setRegion(0, dimension - 8, 9, 8);\n\n // Alignment patterns\n const max = this.alignmentPatternCenters.length;\n for (let x = 0; x < max; x++) {\n const i = this.alignmentPatternCenters[x] - 2;\n for (let y = 0; y < max; y++) {\n if ((x === 0 && (y === 0 || y === max - 1)) || (x === max - 1 && y === 0)) {\n // No alignment patterns near the three finder patterns\n continue;\n }\n bitMatrix.setRegion(this.alignmentPatternCenters[y] - 2, i, 5, 5);\n }\n }\n\n // Vertical timing pattern\n bitMatrix.setRegion(6, 9, 1, dimension - 17);\n // Horizontal timing pattern\n bitMatrix.setRegion(9, 6, dimension - 17, 1);\n\n if (this.versionNumber > 6) {\n // Version info, top right\n bitMatrix.setRegion(dimension - 11, 0, 3, 6);\n // Version info, bottom left\n bitMatrix.setRegion(0, dimension - 11, 6, 3);\n }\n\n return bitMatrix;\n }\n\n /*@Override*/\n public toString(): string {\n return '' + this.versionNumber;\n }\n}\n","/**\n * Java Formatter class polyfill that works in the JS way.\n */\nexport default class Formatter {\n\n /**\n * The internal formatted value.\n */\n buffer: string;\n\n constructor() {\n this.buffer = '';\n }\n\n /**\n *\n * @see https://stackoverflow.com/a/13439711/4367683\n *\n * @param str\n * @param arr\n */\n private static form(str: string, arr: any[]) {\n\n let i = -1;\n\n function callback(exp: string | number, p0: any, p1: any, p2: any, p3: any, p4: any) {\n\n if (exp === '%%') return '%';\n if (arr[++i] === undefined) return undefined;\n\n exp = p2 ? parseInt(p2.substr(1)) : undefined;\n\n let base = p3 ? parseInt(p3.substr(1)) : undefined;\n let val: string;\n\n switch (p4) {\n case 's': val = arr[i]; break;\n case 'c': val = arr[i][0]; break;\n case 'f': val = parseFloat(arr[i]).toFixed(exp); break;\n case 'p': val = parseFloat(arr[i]).toPrecision(exp); break;\n case 'e': val = parseFloat(arr[i]).toExponential(exp); break;\n case 'x': val = parseInt(arr[i]).toString(base ? base : 16); break;\n case 'd': val = parseFloat(parseInt(arr[i], base ? base : 10).toPrecision(exp)).toFixed(0); break;\n }\n\n val = typeof val === 'object' ? JSON.stringify(val) : (+val).toString(base);\n let size = parseInt(p1); /* padding size */\n let ch = p1 && (p1[0] + '') === '0' ? '0' : ' '; /* isnull? */\n\n while (val.length < size) val = p0 !== undefined ? val + ch : ch + val; /* isminus? */\n\n return val;\n }\n\n let regex = /%(-)?(0?[0-9]+)?([.][0-9]+)?([#][0-9]+)?([scfpexd%])/g;\n\n return str.replace(regex, callback);\n }\n\n /**\n *\n * @param append The new string to append.\n * @param args Argumets values to be formated.\n */\n format(append: string, ...args: any) {\n this.buffer += Formatter.form(append, args);\n }\n\n /**\n * Returns the Formatter string value.\n */\n toString(): string {\n return this.buffer;\n }\n}\n","/*\n * Copyright 2008 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/*namespace com.google.zxing.qrcode.encoder {*/\n\nimport EncodeHintType from '../../EncodeHintType';\nimport BitArray from '../../common/BitArray';\nimport CharacterSetECI from '../../common/CharacterSetECI';\nimport GenericGF from '../../common/reedsolomon/GenericGF';\nimport ReedSolomonEncoder from '../../common/reedsolomon/ReedSolomonEncoder';\nimport ErrorCorrectionLevel from '../decoder/ErrorCorrectionLevel';\nimport Mode from '../decoder/Mode';\nimport Version from '../decoder/Version';\nimport MaskUtil from './MaskUtil';\nimport ByteMatrix from './ByteMatrix';\nimport QRCode from './QRCode';\n\nimport ECBlocks from '../decoder/ECBlocks';\nimport MatrixUtil from './MatrixUtil';\nimport StringEncoding from '../../util/StringEncoding';\nimport BlockPair from './BlockPair';\nimport WriterException from '../../WriterException';\n\n/*import java.io.UnsupportedEncodingException;*/\n/*import java.util.ArrayList;*/\n/*import java.util.Collection;*/\n/*import java.util.Map;*/\n\n/**\n * @author satorux@google.com (Satoru Takabayashi) - creator\n * @author dswitkin@google.com (Daniel Switkin) - ported from C++\n */\nexport default class Encoder {\n\n // The original table is defined in the table 5 of JISX0510:2004 (p.19).\n private static ALPHANUMERIC_TABLE = Int32Array.from([\n -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 0x00-0x0f\n -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 0x10-0x1f\n 36, -1, -1, -1, 37, 38, -1, -1, -1, -1, 39, 40, -1, 41, 42, 43, // 0x20-0x2f\n 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 44, -1, -1, -1, -1, -1, // 0x30-0x3f\n -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, // 0x40-0x4f\n 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1, // 0x50-0x5f\n ]);\n\n public static DEFAULT_BYTE_MODE_ENCODING = CharacterSetECI.UTF8.getName(); // \"ISO-8859-1\"\n // TYPESCRIPTPORT: changed to UTF8, the default for js\n\n private constructor() { }\n\n // The mask penalty calculation is complicated. See Table 21 of JISX0510:2004 (p.45) for details.\n // Basically it applies four rules and summate all penalties.\n private static calculateMaskPenalty(matrix: ByteMatrix): number /*int*/ {\n return MaskUtil.applyMaskPenaltyRule1(matrix)\n + MaskUtil.applyMaskPenaltyRule2(matrix)\n + MaskUtil.applyMaskPenaltyRule3(matrix)\n + MaskUtil.applyMaskPenaltyRule4(matrix);\n }\n\n /**\n * @param content text to encode\n * @param ecLevel error correction level to use\n * @return {@link QRCode} representing the encoded QR code\n * @throws WriterException if encoding can't succeed, because of for example invalid content\n * or configuration\n */\n // public static encode(content: string, ecLevel: ErrorCorrectionLevel): QRCode /*throws WriterException*/ {\n // return encode(content, ecLevel, null)\n // }\n\n public static encode(content: string,\n ecLevel: ErrorCorrectionLevel,\n hints: MapThis class contains utility methods for performing mathematical operations over\n * the Galois Fields. Operations use a given primitive polynomial in calculations.
\n *\n *Throughout this package, elements of the GF are represented as an {@code int}\n * for convenience and speed (but at the cost of memory).\n *
\n *\n * @author Sean Owen\n * @author David Olivier\n */\nexport default abstract class AbstractGenericGF {\n protected expTable: Int32Array;\n protected logTable: Int32Array;\n\n public abstract getZero(): any; // GenericGFPoly\n public abstract buildMonomial(\n degree: number /*int*/,\n coefficient: number /*int*/\n ): any; // GenericGFPoly\n public abstract equals(o: Object): boolean;\n public abstract multiply(a: number /*int*/, b: number /*int*/): number;\n public abstract inverse(a: number /*int*/): number;\n\n /**\n * @return 2 to the power of a in GF(size)\n */\n public exp(a: number): number /*int*/ {\n return this.expTable[a];\n }\n\n /**\n * @return base 2 log of a in GF(size)\n */\n public log(a: number /*int*/): number /*int*/ {\n if (a === 0) {\n throw new IllegalArgumentException();\n }\n return this.logTable[a];\n }\n\n /**\n * Implements both addition and subtraction -- they are the same in GF(size).\n *\n * @return sum/difference of a and b\n */\n public static addOrSubtract(\n a: number /*int*/,\n b: number /*int*/\n ): number /*int*/ {\n return a ^ b;\n }\n}\n","import Exception from './Exception';\n\n/**\n * Custom Error class of type Exception.\n */\nexport default class ReedSolomonException extends Exception {}\n","/**\n * Ponyfill for Java's Float class.\n */\nexport default class Float {\n\n /**\n * The float max value in JS is the number max value.\n */\n static MAX_VALUE: number = Number.MAX_SAFE_INTEGER;\n\n /**\n * SincTS has no difference between int and float, there's all numbers,\n * this is used only to polyfill Java code.\n */\n public static floatToIntBits(f: number): number {\n return f;\n }\n}\n","/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/*namespace com.google.zxing.common {*/\n\nimport GridSampler from './GridSampler';\nimport BitMatrix from './BitMatrix';\nimport PerspectiveTransform from './PerspectiveTransform';\n\nimport NotFoundException from '../NotFoundException';\n\nimport { float } from '../../customTypings';\n\n/**\n * @author Sean Owen\n */\nexport default class DefaultGridSampler extends GridSampler {\n\n /*@Override*/\n public sampleGrid(image: BitMatrix,\n dimensionX: number /*int*/,\n dimensionY: number /*int*/,\n p1ToX: number/*float*/, p1ToY: number/*float*/,\n p2ToX: number/*float*/, p2ToY: number/*float*/,\n p3ToX: number/*float*/, p3ToY: number/*float*/,\n p4ToX: number/*float*/, p4ToY: number/*float*/,\n p1FromX: number/*float*/, p1FromY: number/*float*/,\n p2FromX: number/*float*/, p2FromY: number/*float*/,\n p3FromX: number/*float*/, p3FromY: number/*float*/,\n p4FromX: number/*float*/, p4FromY: number/*float*/): BitMatrix /*throws NotFoundException*/ {\n\n const transform = PerspectiveTransform.quadrilateralToQuadrilateral(\n p1ToX, p1ToY, p2ToX, p2ToY, p3ToX, p3ToY, p4ToX, p4ToY,\n p1FromX, p1FromY, p2FromX, p2FromY, p3FromX, p3FromY, p4FromX, p4FromY);\n\n return this.sampleGridWithTransform(image, dimensionX, dimensionY, transform);\n }\n\n /*@Override*/\n public sampleGridWithTransform(image: BitMatrix,\n dimensionX: number /*int*/,\n dimensionY: number /*int*/,\n transform: PerspectiveTransform): BitMatrix /*throws NotFoundException*/ {\n if (dimensionX <= 0 || dimensionY <= 0) {\n throw new NotFoundException();\n }\n const bits = new BitMatrix(dimensionX, dimensionY);\n const points = new Float32Array(2 * dimensionX);\n for (let y = 0; y < dimensionY; y++) {\n const max = points.length;\n const iValue: number /*float*/ = y + 0.5;\n for (let x = 0; x < max; x += 2) {\n points[x] =Checks a set of points that have been transformed to sample points on an image against\n * the image's dimensions to see if the point are even within the image.
\n *\n *This method will actually \"nudge\" the endpoints back onto the image if they are found to be\n * barely (less than 1 pixel) off the image. This accounts for imperfect detection of finder\n * patterns in an image where the QR Code runs all the way to the image border.
\n *\n *For efficiency, the method will check points from either end of the line until one is found\n * to be within the image. Because the set of points are assumed to be linear, this is valid.
\n *\n * @param image image into which the points should map\n * @param points actual points in x1,y1,...,xn,yn form\n * @throws NotFoundException if an endpoint is lies outside the image boundaries\n */\n protected static checkAndNudgePoints(\n image: BitMatrix,\n points: Float32Array\n ): void /*throws NotFoundException*/ {\n\n const width: number /*int*/ = image.getWidth();\n const height: number /*int*/ = image.getHeight();\n\n // Check and nudge points from start until we see some that are OK:\n let nudged: boolean = true;\n\n for (let offset = 0; offset < points.length && nudged; offset += 2) {\n\n const x = Math.floor(points[offset]);\n const y = Math.floor(points[offset + 1]);\n\n if (x < -1 || x > width || y < -1 || y > height) {\n throw new NotFoundException();\n }\n\n nudged = false;\n\n if (x === -1) {\n points[offset] = 0.0;\n nudged = true;\n } else if (x === width) {\n points[offset] = width - 1;\n nudged = true;\n }\n\n if (y === -1) {\n points[offset + 1] = 0.0;\n nudged = true;\n } else if (y === height) {\n points[offset + 1] = height - 1;\n nudged = true;\n }\n }\n\n // Check and nudge points from end:\n nudged = true;\n\n for (let offset = points.length - 2; offset >= 0 && nudged; offset -= 2) {\n\n const x = Math.floor(points[offset]);\n const y = Math.floor(points[offset + 1]);\n\n if (x < -1 || x > width || y < -1 || y > height) {\n throw new NotFoundException();\n }\n\n nudged = false;\n\n if (x === -1) {\n points[offset] = 0.0;\n nudged = true;\n } else if (x === width) {\n points[offset] = width - 1;\n nudged = true;\n }\n\n if (y === -1) {\n points[offset + 1] = 0.0;\n nudged = true;\n } else if (y === height) {\n points[offset + 1] = height - 1;\n nudged = true;\n }\n }\n }\n\n}\n\nexport default GridSampler;\n","/*\n * Copyright 2008 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/*namespace com.google.zxing.oned {*/\n\nimport BarcodeFormat from '../BarcodeFormat';\nimport BitArray from '../common/BitArray';\nimport ChecksumException from '../ChecksumException';\nimport DecodeHintType from '../DecodeHintType';\nimport FormatException from '../FormatException';\nimport NotFoundException from '../NotFoundException';\nimport OneDReader from './OneDReader';\nimport Result from '../Result';\nimport ResultPoint from '../ResultPoint';\n\n/**\n *Decodes Code 39 barcodes. Supports \"Full ASCII Code 39\" if USE_CODE_39_EXTENDED_MODE is set.
\n *\n * @author Sean Owen\n * @see Code93Reader\n */\nexport default class Code39Reader extends OneDReader {\n\n private static readonly ALPHABET_STRING = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%';\n\n /**\n * These represent the encodings of characters, as patterns of wide and narrow bars.\n * The 9 least-significant bits of each int correspond to the pattern of wide and narrow,\n * with 1s representing \"wide\" and 0s representing narrow.\n */\n private static readonly CHARACTER_ENCODINGS: number[] = [\n 0x034, 0x121, 0x061, 0x160, 0x031, 0x130, 0x070, 0x025, 0x124, 0x064, // 0-9\n 0x109, 0x049, 0x148, 0x019, 0x118, 0x058, 0x00D, 0x10C, 0x04C, 0x01C, // A-J\n 0x103, 0x043, 0x142, 0x013, 0x112, 0x052, 0x007, 0x106, 0x046, 0x016, // K-T\n 0x181, 0x0C1, 0x1C0, 0x091, 0x190, 0x0D0, 0x085, 0x184, 0x0C4, 0x0A8, // U-$\n 0x0A2, 0x08A, 0x02A // /-%\n ];\n\n private static readonly ASTERISK_ENCODING = 0x094;\n\n private usingCheckDigit: boolean;\n private extendedMode: boolean;\n private decodeRowResult: string;\n private counters: number[];\n\n /**\n * Creates a reader that assumes all encoded data is data, and does not treat the final\n * character as a check digit. It will not decoded \"extended Code 39\" sequences.\n */\n // public Code39Reader() {\n // this(false);\n // }\n\n /**\n * Creates a reader that can be configured to check the last character as a check digit.\n * It will not decoded \"extended Code 39\" sequences.\n *\n * @param usingCheckDigit if true, treat the last data character as a check digit, not\n * data, and verify that the checksum passes.\n */\n // public Code39Reader(boolean usingCheckDigit) {\n // this(usingCheckDigit, false);\n // }\n\n /**\n * Creates a reader that can be configured to check the last character as a check digit,\n * or optionally attempt to decode \"extended Code 39\" sequences that are used to encode\n * the full ASCII character set.\n *\n * @param usingCheckDigit if true, treat the last data character as a check digit, not\n * data, and verify that the checksum passes.\n * @param extendedMode if true, will attempt to decode extended Code 39 sequences in the\n * text.\n */\n public constructor(usingCheckDigit: boolean = false, extendedMode: boolean = false) {\n super();\n this.usingCheckDigit = usingCheckDigit;\n this.extendedMode = extendedMode;\n this.decodeRowResult = '';\n this.counters = new ArrayDecodes Code 128 barcodes.
\n *\n * @author Sean Owen\n */\nexport default class Code128Reader extends OneDReader {\n\n private static CODE_PATTERNS: number[][] = [\n [2, 1, 2, 2, 2, 2],\n [2, 2, 2, 1, 2, 2],\n [2, 2, 2, 2, 2, 1],\n [1, 2, 1, 2, 2, 3],\n [1, 2, 1, 3, 2, 2],\n [1, 3, 1, 2, 2, 2],\n [1, 2, 2, 2, 1, 3],\n [1, 2, 2, 3, 1, 2],\n [1, 3, 2, 2, 1, 2],\n [2, 2, 1, 2, 1, 3],\n [2, 2, 1, 3, 1, 2],\n [2, 3, 1, 2, 1, 2],\n [1, 1, 2, 2, 3, 2],\n [1, 2, 2, 1, 3, 2],\n [1, 2, 2, 2, 3, 1],\n [1, 1, 3, 2, 2, 2],\n [1, 2, 3, 1, 2, 2],\n [1, 2, 3, 2, 2, 1],\n [2, 2, 3, 2, 1, 1],\n [2, 2, 1, 1, 3, 2],\n [2, 2, 1, 2, 3, 1],\n [2, 1, 3, 2, 1, 2],\n [2, 2, 3, 1, 1, 2],\n [3, 1, 2, 1, 3, 1],\n [3, 1, 1, 2, 2, 2],\n [3, 2, 1, 1, 2, 2],\n [3, 2, 1, 2, 2, 1],\n [3, 1, 2, 2, 1, 2],\n [3, 2, 2, 1, 1, 2],\n [3, 2, 2, 2, 1, 1],\n [2, 1, 2, 1, 2, 3],\n [2, 1, 2, 3, 2, 1],\n [2, 3, 2, 1, 2, 1],\n [1, 1, 1, 3, 2, 3],\n [1, 3, 1, 1, 2, 3],\n [1, 3, 1, 3, 2, 1],\n [1, 1, 2, 3, 1, 3],\n [1, 3, 2, 1, 1, 3],\n [1, 3, 2, 3, 1, 1],\n [2, 1, 1, 3, 1, 3],\n [2, 3, 1, 1, 1, 3],\n [2, 3, 1, 3, 1, 1],\n [1, 1, 2, 1, 3, 3],\n [1, 1, 2, 3, 3, 1],\n [1, 3, 2, 1, 3, 1],\n [1, 1, 3, 1, 2, 3],\n [1, 1, 3, 3, 2, 1],\n [1, 3, 3, 1, 2, 1],\n [3, 1, 3, 1, 2, 1],\n [2, 1, 1, 3, 3, 1],\n [2, 3, 1, 1, 3, 1],\n [2, 1, 3, 1, 1, 3],\n [2, 1, 3, 3, 1, 1],\n [2, 1, 3, 1, 3, 1],\n [3, 1, 1, 1, 2, 3],\n [3, 1, 1, 3, 2, 1],\n [3, 3, 1, 1, 2, 1],\n [3, 1, 2, 1, 1, 3],\n [3, 1, 2, 3, 1, 1],\n [3, 3, 2, 1, 1, 1],\n [3, 1, 4, 1, 1, 1],\n [2, 2, 1, 4, 1, 1],\n [4, 3, 1, 1, 1, 1],\n [1, 1, 1, 2, 2, 4],\n [1, 1, 1, 4, 2, 2],\n [1, 2, 1, 1, 2, 4],\n [1, 2, 1, 4, 2, 1],\n [1, 4, 1, 1, 2, 2],\n [1, 4, 1, 2, 2, 1],\n [1, 1, 2, 2, 1, 4],\n [1, 1, 2, 4, 1, 2],\n [1, 2, 2, 1, 1, 4],\n [1, 2, 2, 4, 1, 1],\n [1, 4, 2, 1, 1, 2],\n [1, 4, 2, 2, 1, 1],\n [2, 4, 1, 2, 1, 1],\n [2, 2, 1, 1, 1, 4],\n [4, 1, 3, 1, 1, 1],\n [2, 4, 1, 1, 1, 2],\n [1, 3, 4, 1, 1, 1],\n [1, 1, 1, 2, 4, 2],\n [1, 2, 1, 1, 4, 2],\n [1, 2, 1, 2, 4, 1],\n [1, 1, 4, 2, 1, 2],\n [1, 2, 4, 1, 1, 2],\n [1, 2, 4, 2, 1, 1],\n [4, 1, 1, 2, 1, 2],\n [4, 2, 1, 1, 1, 2],\n [4, 2, 1, 2, 1, 1],\n [2, 1, 2, 1, 4, 1],\n [2, 1, 4, 1, 2, 1],\n [4, 1, 2, 1, 2, 1],\n [1, 1, 1, 1, 4, 3],\n [1, 1, 1, 3, 4, 1],\n [1, 3, 1, 1, 4, 1],\n [1, 1, 4, 1, 1, 3],\n [1, 1, 4, 3, 1, 1],\n [4, 1, 1, 1, 1, 3],\n [4, 1, 1, 3, 1, 1],\n [1, 1, 3, 1, 4, 1],\n [1, 1, 4, 1, 3, 1],\n [3, 1, 1, 1, 4, 1],\n [4, 1, 1, 1, 3, 1],\n [2, 1, 1, 4, 1, 2],\n [2, 1, 1, 2, 1, 4],\n [2, 1, 1, 2, 3, 2],\n [2, 3, 3, 1, 1, 1, 2]];\n\n private static MAX_AVG_VARIANCE = 0.25;\n private static MAX_INDIVIDUAL_VARIANCE = 0.7;\n\n private static CODE_SHIFT = 98;\n\n private static CODE_CODE_C = 99;\n private static CODE_CODE_B = 100;\n private static CODE_CODE_A = 101;\n\n private static CODE_FNC_1 = 102;\n private static CODE_FNC_2 = 97;\n private static CODE_FNC_3 = 96;\n private static CODE_FNC_4_A = 101;\n private static CODE_FNC_4_B = 100;\n\n private static CODE_START_A = 103;\n private static CODE_START_B = 104;\n private static CODE_START_C = 105;\n private static CODE_STOP = 106;\n\n private static findStartPattern(row: BitArray): number[] {\n const width = row.getSize();\n const rowOffset = row.getNextSet(0);\n\n let counterPosition = 0;\n const counters = [0, 0, 0, 0, 0, 0];\n let patternStart = rowOffset;\n let isWhite = false;\n const patternLength = 6;\n\n for (let i = rowOffset; i < width; i++) {\n if (row.get(i) !== isWhite) {\n counters[counterPosition]++;\n } else {\n if (counterPosition === (patternLength - 1)) {\n let bestVariance = Code128Reader.MAX_AVG_VARIANCE;\n let bestMatch = -1;\n for (let startCode = Code128Reader.CODE_START_A; startCode <= Code128Reader.CODE_START_C; startCode++) {\n const variance = OneDReader.patternMatchVariance(counters,\n Code128Reader.CODE_PATTERNS[startCode], Code128Reader.MAX_INDIVIDUAL_VARIANCE);\n if (variance < bestVariance) {\n bestVariance = variance;\n bestMatch = startCode;\n }\n }\n // Look for whitespace before start pattern, >= 50% of width of start pattern\n if (bestMatch >= 0 &&\n row.isRange(Math.max(0, patternStart - (i - patternStart) / 2), patternStart, false)) {\n return [patternStart, i, bestMatch];\n }\n patternStart += counters[0] + counters[1];\n\n counters.splice(0, 2);\n counters[counterPosition - 1] = 0;\n counters[counterPosition] = 0;\n counterPosition--;\n } else {\n counterPosition++;\n }\n counters[counterPosition] = 1;\n isWhite = !isWhite;\n }\n }\n throw new NotFoundException();\n }\n\n private static decodeCode(row: BitArray, counters: number[], rowOffset: number): number {\n OneDReader.recordPattern(row, rowOffset, counters);\n let bestVariance = Code128Reader.MAX_AVG_VARIANCE; // worst variance we'll accept\n let bestMatch = -1;\n for (let d = 0; d < Code128Reader.CODE_PATTERNS.length; d++) {\n const pattern = Code128Reader.CODE_PATTERNS[d];\n const variance = this.patternMatchVariance(counters, pattern, Code128Reader.MAX_INDIVIDUAL_VARIANCE);\n if (variance < bestVariance) {\n bestVariance = variance;\n bestMatch = d;\n }\n }\n // TODO We're overlooking the fact that the STOP pattern has 7 values, not 6.\n if (bestMatch >= 0) {\n return bestMatch;\n } else {\n throw new NotFoundException();\n }\n }\n\n public decodeRow(rowNumber: number, row: BitArray, hints?: MapDecodes ITF barcodes.
\n *\n * @author Tjieco\n */\nexport default class ITFReader extends OneDReader {\n\n private static W = 3; // Pixel width of a 3x wide line\n private static w = 2; // Pixel width of a 2x wide line\n private static N = 1; // Pixed width of a narrow line\n\n private static PATTERNS: number[][] = [\n [1, 1, 2, 2, 1], // 0\n [2, 1, 1, 1, 2], // 1\n [1, 2, 1, 1, 2], // 2\n [2, 2, 1, 1, 1], // 3\n [1, 1, 2, 1, 2], // 4\n [2, 1, 2, 1, 1], // 5\n [1, 2, 2, 1, 1], // 6\n [1, 1, 1, 2, 2], // 7\n [2, 1, 1, 2, 1], // 8\n [1, 2, 1, 2, 1], // 9\n [1, 1, 3, 3, 1], // 0\n [3, 1, 1, 1, 3], // 1\n [1, 3, 1, 1, 3], // 2\n [3, 3, 1, 1, 1], // 3\n [1, 1, 3, 1, 3], // 4\n [3, 1, 3, 1, 1], // 5\n [1, 3, 3, 1, 1], // 6\n [1, 1, 1, 3, 3], // 7\n [3, 1, 1, 3, 1], // 8\n [1, 3, 1, 3, 1] // 9\n ];\n\n private static MAX_AVG_VARIANCE = 0.38;\n private static MAX_INDIVIDUAL_VARIANCE = 0.5;\n\n\n\n /* /!** Valid ITF lengths. Anything longer than the largest value is also allowed. *!/*/\n private static DEFAULT_ALLOWED_LENGTHS: number[] = [6, 8, 10, 12, 14];\n\n // Stores the actual narrow line width of the image being decoded.\n private narrowLineWidth = -1;\n\n /*/!**\n * Start/end guard pattern.\n *\n * Note: The end pattern is reversed because the row is reversed before\n * searching for the END_PATTERN\n *!/*/\n private static START_PATTERN = [1, 1, 1, 1];\n private static END_PATTERN_REVERSED: number[][] = [\n [1, 1, 2], // 2x\n [1, 1, 3] // 3x\n ];\n\n // See ITFWriter.PATTERNS\n /*\n\n /!**\n * Patterns of Wide / Narrow lines to indicate each digit\n *!/\n */\n\n public decodeRow(rowNumber: number, row: BitArray, hints?: MapImplements decoding of the EAN-13 format.
\n *\n * @author dswitkin@google.com (Daniel Switkin)\n * @author Sean Owen\n * @author alasdair@google.com (Alasdair Mackintosh)\n */\nexport default class EAN13Reader extends UPCEANReader {\n private static FIRST_DIGIT_ENCODINGS: number[] = [0x00, 0x0B, 0x0D, 0xE, 0x13, 0x19, 0x1C, 0x15, 0x16, 0x1A];\n\n private decodeMiddleCounters: number[];\n\n public constructor() {\n super();\n this.decodeMiddleCounters = [0, 0, 0, 0];\n }\n\n public decodeMiddle(row: BitArray, startRange: number[], resultString: string) {\n let counters = this.decodeMiddleCounters;\n counters[0] = 0;\n counters[1] = 0;\n counters[2] = 0;\n counters[3] = 0;\n let end = row.getSize();\n let rowOffset = startRange[1];\n\n let lgPatternFound = 0;\n\n for (let x = 0; x < 6 && rowOffset < end; x++) {\n let bestMatch = UPCEANReader.decodeDigit(row, counters, rowOffset, UPCEANReader.L_AND_G_PATTERNS);\n resultString += String.fromCharCode(('0'.charCodeAt(0) + bestMatch % 10));\n for (let counter of counters) {\n rowOffset += counter;\n }\n if (bestMatch >= 10) {\n lgPatternFound |= 1 << (5 - x);\n }\n }\n\n resultString = EAN13Reader.determineFirstDigit(resultString, lgPatternFound);\n\n let middleRange = UPCEANReader.findGuardPattern(row, rowOffset, true, UPCEANReader.MIDDLE_PATTERN, new Array(UPCEANReader.MIDDLE_PATTERN.length).fill(0));\n rowOffset = middleRange[1];\n\n for (let x = 0; x < 6 && rowOffset < end; x++) {\n let bestMatch = UPCEANReader.decodeDigit(row, counters, rowOffset, UPCEANReader.L_PATTERNS);\n resultString += String.fromCharCode(('0'.charCodeAt(0) + bestMatch));\n for (let counter of counters) {\n rowOffset += counter;\n }\n }\n\n return {rowOffset, resultString};\n }\n\n public getBarcodeFormat(): BarcodeFormat {\n return BarcodeFormat.EAN_13;\n }\n\n static determineFirstDigit(resultString: string, lgPatternFound: number) {\n for (let d = 0; d < 10; d++) {\n if (lgPatternFound === this.FIRST_DIGIT_ENCODINGS[d]) {\n resultString = String.fromCharCode(('0'.charCodeAt(0) + d)) + resultString;\n return resultString;\n }\n }\n throw new NotFoundException();\n }\n}\n","/*\n * Copyright 2008 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport BarcodeFormat from '../BarcodeFormat';\nimport BitArray from '../common/BitArray';\nimport DecodeHintType from '../DecodeHintType';\n\nimport Result from '../Result';\nimport ResultMetadataType from '../ResultMetadataType';\nimport ResultPoint from '../ResultPoint';\nimport UPCEANExtensionSupport from './UPCEANExtensionSupport';\nimport AbstractUPCEANReader from './AbstractUPCEANReader';\nimport NotFoundException from '../NotFoundException';\nimport FormatException from '../FormatException';\nimport ChecksumException from '../ChecksumException';\n\n/**\n *Encapsulates functionality and implementation that is common to UPC and EAN families\n * of one-dimensional barcodes.
\n *\n * @author dswitkin@google.com (Daniel Switkin)\n * @author Sean Owen\n * @author alasdair@google.com (Alasdair Mackintosh)\n */\nexport default abstract class UPCEANReader extends AbstractUPCEANReader {\n\n public constructor() {\n super();\n this.decodeRowStringBuffer = '';\n\n UPCEANReader.L_AND_G_PATTERNS = UPCEANReader.L_PATTERNS.map(function(arr) {\n return arr.slice();\n });\n\n for (let i = 10; i < 20; i++) {\n let widths = UPCEANReader.L_PATTERNS[i - 10];\n let reversedWidths = new Array(widths.length);\n for (let j = 0; j < widths.length; j++) {\n reversedWidths[j] = widths[widths.length - j - 1];\n }\n UPCEANReader.L_AND_G_PATTERNS[i] = reversedWidths;\n }\n }\n\n public decodeRow(rowNumber: number, row: BitArray, hints?: MapEncapsulates a QR Code's format information, including the data mask used and\n * error correction level.
\n *\n * @author Sean Owen\n * @see DataMask\n * @see ErrorCorrectionLevel\n */\nexport default class FormatInformation {\n\n private static FORMAT_INFO_MASK_QR = 0x5412;\n\n /**\n * See ISO 18004:2006, Annex C, Table C.1\n */\n private static FORMAT_INFO_DECODE_LOOKUP = [\n Int32Array.from([0x5412, 0x00]),\n Int32Array.from([0x5125, 0x01]),\n Int32Array.from([0x5E7C, 0x02]),\n Int32Array.from([0x5B4B, 0x03]),\n Int32Array.from([0x45F9, 0x04]),\n Int32Array.from([0x40CE, 0x05]),\n Int32Array.from([0x4F97, 0x06]),\n Int32Array.from([0x4AA0, 0x07]),\n Int32Array.from([0x77C4, 0x08]),\n Int32Array.from([0x72F3, 0x09]),\n Int32Array.from([0x7DAA, 0x0A]),\n Int32Array.from([0x789D, 0x0B]),\n Int32Array.from([0x662F, 0x0C]),\n Int32Array.from([0x6318, 0x0D]),\n Int32Array.from([0x6C41, 0x0E]),\n Int32Array.from([0x6976, 0x0F]),\n Int32Array.from([0x1689, 0x10]),\n Int32Array.from([0x13BE, 0x11]),\n Int32Array.from([0x1CE7, 0x12]),\n Int32Array.from([0x19D0, 0x13]),\n Int32Array.from([0x0762, 0x14]),\n Int32Array.from([0x0255, 0x15]),\n Int32Array.from([0x0D0C, 0x16]),\n Int32Array.from([0x083B, 0x17]),\n Int32Array.from([0x355F, 0x18]),\n Int32Array.from([0x3068, 0x19]),\n Int32Array.from([0x3F31, 0x1A]),\n Int32Array.from([0x3A06, 0x1B]),\n Int32Array.from([0x24B4, 0x1C]),\n Int32Array.from([0x2183, 0x1D]),\n Int32Array.from([0x2EDA, 0x1E]),\n Int32Array.from([0x2BED, 0x1F]),\n ];\n\n private errorCorrectionLevel: ErrorCorrectionLevel;\n private dataMask: number; /*byte*/\n\n private constructor(formatInfo: number /*int*/) {\n // Bits 3,4\n this.errorCorrectionLevel = ErrorCorrectionLevel.forBits((formatInfo >> 3) & 0x03);\n // Bottom 3 bits\n this.dataMask = /*(byte) */(formatInfo & 0x07);\n }\n\n public static numBitsDiffering(a: number /*int*/, b: number /*int*/): number /*int*/ {\n return Integer.bitCount(a ^ b);\n }\n\n /**\n * @param maskedFormatInfo1 format info indicator, with mask still applied\n * @param maskedFormatInfo2 second copy of same info; both are checked at the same time\n * to establish best match\n * @return information about the format it specifies, or {@code null}\n * if doesn't seem to match any known pattern\n */\n public static decodeFormatInformation(maskedFormatInfo1: number /*int*/, maskedFormatInfo2: number /*int*/): FormatInformation {\n const formatInfo = FormatInformation.doDecodeFormatInformation(maskedFormatInfo1, maskedFormatInfo2);\n if (formatInfo !== null) {\n return formatInfo;\n }\n // Should return null, but, some QR codes apparently\n // do not mask this info. Try again by actually masking the pattern\n // first\n return FormatInformation.doDecodeFormatInformation(maskedFormatInfo1 ^ FormatInformation.FORMAT_INFO_MASK_QR,\n maskedFormatInfo2 ^ FormatInformation.FORMAT_INFO_MASK_QR);\n }\n\n private static doDecodeFormatInformation(maskedFormatInfo1: number /*int*/, maskedFormatInfo2: number /*int*/): FormatInformation {\n // Find the int in FORMAT_INFO_DECODE_LOOKUP with fewest bits differing\n let bestDifference = Number.MAX_SAFE_INTEGER;\n let bestFormatInfo = 0;\n for (const decodeInfo of FormatInformation.FORMAT_INFO_DECODE_LOOKUP) {\n const targetInfo = decodeInfo[0];\n if (targetInfo === maskedFormatInfo1 || targetInfo === maskedFormatInfo2) {\n // Found an exact match\n return new FormatInformation(decodeInfo[1]);\n }\n let bitsDifference = FormatInformation.numBitsDiffering(maskedFormatInfo1, targetInfo);\n if (bitsDifference < bestDifference) {\n bestFormatInfo = decodeInfo[1];\n bestDifference = bitsDifference;\n }\n if (maskedFormatInfo1 !== maskedFormatInfo2) {\n // also try the other option\n bitsDifference = FormatInformation.numBitsDiffering(maskedFormatInfo2, targetInfo);\n if (bitsDifference < bestDifference) {\n bestFormatInfo = decodeInfo[1];\n bestDifference = bitsDifference;\n }\n }\n }\n // Hamming distance of the 32 masked codes is 7, by construction, so <= 3 bits\n // differing means we found a match\n if (bestDifference <= 3) {\n return new FormatInformation(bestFormatInfo);\n }\n return null;\n }\n\n public getErrorCorrectionLevel(): ErrorCorrectionLevel {\n return this.errorCorrectionLevel;\n }\n\n public getDataMask(): number/*byte*/ {\n return this.dataMask;\n }\n\n /*@Override*/\n public hashCode(): number /*int*/ {\n return (this.errorCorrectionLevel.getBits() << 3) | this.dataMask;\n }\n\n /*@Override*/\n public equals(o: Object): boolean {\n if (!(o instanceof FormatInformation)) {\n return false;\n }\n const other =See ISO 18004:2006, 6.4.1, Tables 2 and 3. This enum encapsulates the various modes in which\n * data can be encoded to bits in the QR code standard.
\n *\n * @author Sean Owen\n */\nexport default class Mode {\n\n private static FOR_BITS = new MapImplements Reed-Solomon encoding, as the name implies.
\n *\n * @author Sean Owen\n * @author William Rucklidge\n */\nexport default class ReedSolomonEncoder {\n\n private field: GenericGF;\n private cachedGenerators: GenericGFPoly[];\n\n /**\n * A reed solomon error-correcting encoding constructor is created by\n * passing as Galois Field with of size equal to the number of code\n * words (symbols) in the alphabet (the number of values in each\n * element of arrays that are encoded/decoded).\n * @param field A galois field with a number of elements equal to the size\n * of the alphabet of symbols to encode.\n */\n public constructor(field: GenericGF) {\n this.field = field;\n this.cachedGenerators = [];\n this.cachedGenerators.push(new GenericGFPoly(field, Int32Array.from([1])));\n }\n\n private buildGenerator(degree: number /*int*/): GenericGFPoly {\n const cachedGenerators = this.cachedGenerators;\n if (degree >= cachedGenerators.length) {\n let lastGenerator = cachedGenerators[cachedGenerators.length - 1];\n const field = this.field;\n for (let d = cachedGenerators.length; d <= degree; d++) {\n const nextGenerator = lastGenerator.multiply(\n new GenericGFPoly(field, Int32Array.from([1, field.exp(d - 1 + field.getGeneratorBase())])));\n cachedGenerators.push(nextGenerator);\n lastGenerator = nextGenerator;\n }\n }\n return cachedGenerators[degree];\n }\n\n /**\n *Encode a sequence of code words (symbols) using Reed-Solomon to allow decoders\n * to detect and correct errors that may have been introduced when the resulting\n * data is stored or transmitted.
\n *\n * @param toEncode array used for both and output. Caller initializes the array with\n * the code words (symbols) to be encoded followed by empty elements allocated to make\n * space for error-correction code words in the encoded output. The array contains\n * the encdoded output when encode returns. Code words are encoded as numbers from\n * 0 to n-1, where n is the number of possible code words (symbols), as determined\n * by the size of the Galois Field passed in the constructor of this object.\n * @param ecBytes the number of elements reserved in the array (first parameter)\n * to store error-correction code words. Thus, the number of code words (symbols)\n * to encode in the first parameter is thus toEncode.length - ecBytes.\n * Note, the use of \"bytes\" in the name of this parameter is misleading, as there may\n * be more or fewer than 256 symbols being encoded, as determined by the number of\n * elements in the Galois Field passed as a constructor to this object.\n * @throws IllegalArgumentException thrown in response to validation errros.\n */\n public encode(toEncode: Int32Array, ecBytes: number /*int*/): void {\n if (ecBytes === 0) {\n throw new IllegalArgumentException('No error correction bytes');\n }\n const dataBytes = toEncode.length - ecBytes;\n if (dataBytes <= 0) {\n throw new IllegalArgumentException('No data bytes provided');\n }\n const generator = this.buildGenerator(ecBytes);\n const infoCoefficients: Int32Array = new Int32Array(dataBytes);\n System.arraycopy(toEncode, 0, infoCoefficients, 0, dataBytes);\n let info = new GenericGFPoly(this.field, infoCoefficients);\n info = info.multiplyByMonomial(ecBytes, 1);\n const remainder = info.divide(generator)[1];\n const coefficients = remainder.getCoefficients();\n const numZeroCoefficients = ecBytes - coefficients.length;\n for (let i = 0; i < numZeroCoefficients; i++) {\n toEncode[dataBytes + i] = 0;\n }\n System.arraycopy(coefficients, 0, toEncode, dataBytes + numZeroCoefficients, coefficients.length);\n }\n\n}\n","/*\n * Copyright 2008 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/*namespace com.google.zxing.qrcode.encoder {*/\n\nimport ByteMatrix from './ByteMatrix';\n\nimport IllegalArgumentException from '../../IllegalArgumentException';\n\n/**\n * @author Satoru Takabayashi\n * @author Daniel Switkin\n * @author Sean Owen\n */\nexport default class MaskUtil {\n\n // Penalty weights from section 6.8.2.1\n private static N1 = 3;\n private static N2 = 3;\n private static N3 = 40;\n private static N4 = 10;\n\n private constructor() {\n // do nothing\n }\n\n /**\n * Apply mask penalty rule 1 and return the penalty. Find repetitive cells with the same color and\n * give penalty to them. Example: 00000 or 11111.\n */\n public static applyMaskPenaltyRule1(matrix: ByteMatrix): number /*int*/ {\n return MaskUtil.applyMaskPenaltyRule1Internal(matrix, true) + MaskUtil.applyMaskPenaltyRule1Internal(matrix, false);\n }\n\n /**\n * Apply mask penalty rule 2 and return the penalty. Find 2x2 blocks with the same color and give\n * penalty to them. This is actually equivalent to the spec's rule, which is to find MxN blocks and give a\n * penalty proportional to (M-1)x(N-1), because this is the number of 2x2 blocks inside such a block.\n */\n public static applyMaskPenaltyRule2(matrix: ByteMatrix): number /*int*/ {\n let penalty = 0;\n const array: ArrayThe main class which implements Aztec Code decoding -- as opposed to locating and extracting\n * the Aztec Code from an image.
\n *\n * @author David Olivier\n */\nexport default class Decoder {\n\n private static UPPER_TABLE: string[] = [\n 'CTRL_PS', ' ', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',\n 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'CTRL_LL', 'CTRL_ML', 'CTRL_DL', 'CTRL_BS'\n ];\n\n private static LOWER_TABLE: string[] = [\n 'CTRL_PS', ' ', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p',\n 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'CTRL_US', 'CTRL_ML', 'CTRL_DL', 'CTRL_BS'\n ];\n\n private static MIXED_TABLE: string[] = [\n // Module parse failed: Octal literal in strict mode (50:29)\n // so number string were scaped\n 'CTRL_PS', ' ', '\\\\1', '\\\\2', '\\\\3', '\\\\4', '\\\\5', '\\\\6', '\\\\7', '\\b', '\\t', '\\n',\n '\\\\13', '\\f', '\\r', '\\\\33', '\\\\34', '\\\\35', '\\\\36', '\\\\37', '@', '\\\\', '^', '_',\n '`', '|', '~', '\\\\177', 'CTRL_LL', 'CTRL_UL', 'CTRL_PL', 'CTRL_BS'\n ];\n\n private static PUNCT_TABLE: string[] = [\n '', '\\r', '\\r\\n', '. ', ', ', ': ', '!', '\"', '#', '$', '%', '&', '\\'', '(', ')',\n '*', '+', ',', '-', '.', '/', ':', ';', '<', '=', '>', '?', '[', ']', '{', '}', 'CTRL_UL'\n ];\n\n private static DIGIT_TABLE: string[] = [\n 'CTRL_PS', ' ', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ',', '.', 'CTRL_UL', 'CTRL_US'\n ];\n\n private ddata: AztecDetectorResult;\n\n public decode(detectorResult: AztecDetectorResult): DecoderResult {\n this.ddata = detectorResult;\n let matrix = detectorResult.getBits();\n let rawbits = this.extractBits(matrix);\n let correctedBits = this.correctBits(rawbits);\n let rawBytes = Decoder.convertBoolArrayToByteArray(correctedBits);\n let result = Decoder.getEncodedData(correctedBits);\n let decoderResult = new DecoderResult(rawBytes, result, null, null);\n decoderResult.setNumBits(correctedBits.length);\n return decoderResult;\n }\n\n // This method is used for testing the high-level encoder\n public static highLevelDecode(correctedBits: boolean[]): string {\n return this.getEncodedData(correctedBits);\n }\n\n /**\n * Gets the string encoded in the aztec code bits\n *\n * @return the decoded string\n */\n private static getEncodedData(correctedBits: boolean[]): string {\n let endIndex: number = correctedBits.length;\n let latchTable = Table.UPPER; // table most recently latched to\n let shiftTable = Table.UPPER; // table to use for the next read\n let result: string = '';\n let index = 0;\n while (index < endIndex) {\n if (shiftTable === Table.BINARY) {\n if (endIndex - index < 5) {\n break;\n }\n let length = Decoder.readCode(correctedBits, index, 5);\n index += 5;\n if (length === 0) {\n if (endIndex - index < 11) {\n break;\n }\n length = Decoder.readCode(correctedBits, index, 11) + 31;\n index += 11;\n }\n for (let charCount = 0; charCount < length; charCount++) {\n if (endIndex - index < 8) {\n index = endIndex; // Force outer loop to exit\n break;\n }\n const code: int = Decoder.readCode(correctedBits, index, 8);\n result += /*(char)*/ StringUtils.castAsNonUtf8Char(code);\n index += 8;\n }\n // Go back to whatever mode we had been in\n shiftTable = latchTable;\n } else {\n let size = shiftTable === Table.DIGIT ? 4 : 5;\n if (endIndex - index < size) {\n break;\n }\n let code = Decoder.readCode(correctedBits, index, size);\n index += size;\n let str = Decoder.getCharacter(shiftTable, code);\n if (str.startsWith('CTRL_')) {\n // Table changes\n // ISO/IEC 24778:2008 prescribes ending a shift sequence in the mode from which it was invoked.\n // That's including when that mode is a shift.\n // Our test case dlusbs.png for issue #642 exercises that.\n latchTable = shiftTable; // Latch the current mode, so as to return to Upper after U/S B/S\n shiftTable = Decoder.getTable(str.charAt(5));\n if (str.charAt(6) === 'L') {\n latchTable = shiftTable;\n }\n } else {\n result += str;\n // Go back to whatever mode we had been in\n shiftTable = latchTable;\n }\n }\n }\n return result;\n }\n\n /**\n * gets the table corresponding to the char passed\n */\n private static getTable(t: string): Table {\n switch (t) {\n case 'L':\n return Table.LOWER;\n case 'P':\n return Table.PUNCT;\n case 'M':\n return Table.MIXED;\n case 'D':\n return Table.DIGIT;\n case 'B':\n return Table.BINARY;\n case 'U':\n default:\n return Table.UPPER;\n }\n }\n\n /**\n * Gets the character (or string) corresponding to the passed code in the given table\n *\n * @param table the table used\n * @param code the code of the character\n */\n private static getCharacter(table: Table, code: number): string {\n switch (table) {\n case Table.UPPER:\n return Decoder.UPPER_TABLE[code];\n case Table.LOWER:\n return Decoder.LOWER_TABLE[code];\n case Table.MIXED:\n return Decoder.MIXED_TABLE[code];\n case Table.PUNCT:\n return Decoder.PUNCT_TABLE[code];\n case Table.DIGIT:\n return Decoder.DIGIT_TABLE[code];\n default:\n // Should not reach here.\n throw new IllegalStateException('Bad table');\n }\n }\n\n /**\n *Performs RS error correction on an array of bits.
\n *\n * @return the corrected array\n * @throws FormatException if the input contains too many errors\n */\n private correctBits(rawbits: boolean[]): boolean[] {\n let gf: GenericGF;\n let codewordSize: number;\n\n if (this.ddata.getNbLayers() <= 2) {\n codewordSize = 6;\n gf = GenericGF.AZTEC_DATA_6;\n } else if (this.ddata.getNbLayers() <= 8) {\n codewordSize = 8;\n gf = GenericGF.AZTEC_DATA_8;\n } else if (this.ddata.getNbLayers() <= 22) {\n codewordSize = 10;\n gf = GenericGF.AZTEC_DATA_10;\n } else {\n codewordSize = 12;\n gf = GenericGF.AZTEC_DATA_12;\n }\n\n let numDataCodewords = this.ddata.getNbDatablocks();\n let numCodewords = rawbits.length / codewordSize;\n if (numCodewords < numDataCodewords) {\n throw new FormatException();\n }\n let offset = rawbits.length % codewordSize;\n\n let dataWords: Int32Array = new Int32Array(numCodewords);\n for (let i = 0; i < numCodewords; i++ , offset += codewordSize) {\n dataWords[i] = Decoder.readCode(rawbits, offset, codewordSize);\n }\n\n try {\n let rsDecoder = new ReedSolomonDecoder(gf);\n rsDecoder.decode(dataWords, numCodewords - numDataCodewords);\n } catch (ex) {\n throw new FormatException(ex);\n }\n\n // Now perform the unstuffing operation.\n // First, count how many bits are going to be thrown out as stuffing\n let mask = (1 << codewordSize) - 1;\n let stuffedBits = 0;\n for (let i = 0; i < numDataCodewords; i++) {\n let dataWord = dataWords[i];\n if (dataWord === 0 || dataWord === mask) {\n throw new FormatException();\n } else if (dataWord === 1 || dataWord === mask - 1) {\n stuffedBits++;\n }\n }\n // Now, actually unpack the bits and remove the stuffing\n let correctedBits: boolean[] = new Array(numDataCodewords * codewordSize - stuffedBits);\n let index = 0;\n for (let i = 0; i < numDataCodewords; i++) {\n let dataWord = dataWords[i];\n if (dataWord === 1 || dataWord === mask - 1) {\n // next codewordSize-1 bits are all zeros or all ones\n correctedBits.fill(dataWord > 1, index, index + codewordSize - 1);\n // Arrays.fill(correctedBits, index, index + codewordSize - 1, dataWord > 1);\n index += codewordSize - 1;\n } else {\n for (let bit = codewordSize - 1; bit >= 0; --bit) {\n correctedBits[index++] = (dataWord & (1 << bit)) !== 0;\n }\n }\n }\n return correctedBits;\n }\n\n /**\n * Gets the array of bits from an Aztec Code matrix\n *\n * @return the array of bits\n */\n private extractBits(matrix: BitMatrix): boolean[] {\n let compact = this.ddata.isCompact();\n let layers = this.ddata.getNbLayers();\n let baseMatrixSize = (compact ? 11 : 14) + layers * 4; // not including alignment lines\n let alignmentMap = new Int32Array(baseMatrixSize);\n let rawbits: boolean[] = new Array(this.totalBitsInLayer(layers, compact));\n\n if (compact) {\n for (let i = 0; i < alignmentMap.length; i++) {\n alignmentMap[i] = i;\n }\n } else {\n let matrixSize = baseMatrixSize + 1 + 2 * Integer.truncDivision((Integer.truncDivision(baseMatrixSize, 2) - 1), 15);\n let origCenter = baseMatrixSize / 2;\n let center = Integer.truncDivision(matrixSize, 2);\n for (let i = 0; i < origCenter; i++) {\n let newOffset = i + Integer.truncDivision(i, 15);\n alignmentMap[origCenter - i - 1] = center - newOffset - 1;\n alignmentMap[origCenter + i] = center + newOffset + 1;\n }\n }\n for (let i = 0, rowOffset = 0; i < layers; i++) {\n let rowSize = (layers - i) * 4 + (compact ? 9 : 12);\n // The top-left most point of this layer isExtends {@link DetectorResult} with more information specific to the Aztec format,\n * like the number of layers and whether it's compact.
\n *\n * @author Sean Owen\n */\nexport default class AztecDetectorResult extends DetectorResult {\n\n private compact: boolean;\n private nbDatablocks: number;\n private nbLayers: number;\n\n public constructor(bits: BitMatrix,\n points: ResultPoint[],\n compact: boolean,\n nbDatablocks: number,\n nbLayers: number) {\n super(bits, points);\n this.compact = compact;\n this.nbDatablocks = nbDatablocks;\n this.nbLayers = nbLayers;\n }\n\n public getNbLayers(): number {\n return this.nbLayers;\n }\n\n public getNbDatablocks(): number {\n return this.nbDatablocks;\n }\n\n public isCompact(): boolean {\n return this.compact;\n }\n}\n","import { BrowserCodeReader } from './BrowserCodeReader';\nimport MultiFormatOneDReader from '../core/oned/MultiFormatOneDReader';\nimport DecodeHintType from '../core/DecodeHintType';\n\n/**\n * @deprecated Moving to @zxing/browser\n *\n * Barcode reader reader to use from browser.\n */\nexport class BrowserBarcodeReader extends BrowserCodeReader {\n /**\n * Creates an instance of BrowserBarcodeReader.\n * @param {number} [timeBetweenScansMillis=500] the time delay between subsequent decode tries\n * @param {MapA reader that can read all available UPC/EAN formats. If a caller wants to try to\n * read all such formats, it is most efficient to use this implementation rather than invoke\n * individual readers.
\n *\n * @author Sean Owen\n */\nexport default class MultiFormatUPCEANReader extends OneDReader {\n private readers: UPCEANReader[];\n\n public constructor(hints?: MapImplements decoding of the EAN-8 format.
\n *\n * @author Sean Owen\n */\nexport default class EAN8Reader extends UPCEANReader {\n private decodeMiddleCounters: number[];\n\n public constructor() {\n super();\n this.decodeMiddleCounters = [0, 0, 0, 0];\n }\n\n public decodeMiddle(row: BitArray, startRange: number[], resultString: string) {\n let counters = this.decodeMiddleCounters;\n counters[0] = 0;\n counters[1] = 0;\n counters[2] = 0;\n counters[3] = 0;\n let end = row.getSize();\n let rowOffset = startRange[1];\n\n for (let x = 0; x < 4 && rowOffset < end; x++) {\n let bestMatch = UPCEANReader.decodeDigit(row, counters, rowOffset, UPCEANReader.L_PATTERNS);\n resultString += String.fromCharCode(('0'.charCodeAt(0) + bestMatch));\n\n for (let counter of counters) {\n rowOffset += counter;\n }\n }\n\n let middleRange = UPCEANReader.findGuardPattern(row, rowOffset, true, UPCEANReader.MIDDLE_PATTERN, new Array(UPCEANReader.MIDDLE_PATTERN.length).fill(0));\n rowOffset = middleRange[1];\n\n for (let x = 0; x < 4 && rowOffset < end; x++) {\n let bestMatch = UPCEANReader.decodeDigit(row, counters, rowOffset, UPCEANReader.L_PATTERNS);\n resultString += String.fromCharCode(('0'.charCodeAt(0) + bestMatch));\n\n for (let counter of counters) {\n rowOffset += counter;\n }\n }\n\n return {rowOffset, resultString};\n }\n\n public getBarcodeFormat(): BarcodeFormat {\n return BarcodeFormat.EAN_8;\n }\n}\n","import { BrowserCodeReader } from './BrowserCodeReader';\nimport DataMatrixReader from '../core/datamatrix/DataMatrixReader';\n\n/**\n * @deprecated Moving to @zxing/browser\n *\n * QR Code reader to use from browser.\n */\nexport class BrowserDatamatrixCodeReader extends BrowserCodeReader {\n /**\n * Creates an instance of BrowserQRCodeReader.\n * @param {number} [timeBetweenScansMillis=500] the time delay between subsequent decode tries\n */\n public constructor(timeBetweenScansMillis: number = 500) {\n super(new DataMatrixReader(), timeBetweenScansMillis);\n }\n}\n","import ReedSolomonDecoder from '../../common/reedsolomon/ReedSolomonDecoder';\nimport GenericGF from '../../common/reedsolomon/GenericGF';\nimport DecoderResult from '../../common/DecoderResult';\nimport BitMatrix from '../../common/BitMatrix';\nimport BitMatrixParser from './BitMatrixParser';\nimport DataBlock from './DataBlock';\nimport DecodedBitStreamParser from './DecodedBitStreamParser';\nimport ChecksumException from '../../ChecksumException';\n\n/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n *The main class which implements Data Matrix Code decoding -- as opposed to locating and extracting\n * the Data Matrix Code from an image.
\n *\n * @author bbrown@google.com (Brian Brown)\n */\nexport default class Decoder {\n\n private rsDecoder: ReedSolomonDecoder;\n\n constructor() {\n this.rsDecoder = new ReedSolomonDecoder(GenericGF.DATA_MATRIX_FIELD_256);\n }\n\n /**\n *Decodes a Data Matrix Code represented as a {@link BitMatrix}. A 1 or \"true\" is taken\n * to mean a black module.
\n *\n * @param bits booleans representing white/black Data Matrix Code modules\n * @return text and bytes encoded within the Data Matrix Code\n * @throws FormatException if the Data Matrix Code cannot be decoded\n * @throws ChecksumException if error correction fails\n */\n public decode(bits: BitMatrix): DecoderResult {\n // Construct a parser and read version, error-correction level\n const parser = new BitMatrixParser(bits);\n const version = parser.getVersion();\n\n // Read codewords\n const codewords = parser.readCodewords();\n // Separate into data blocks\n const dataBlocks = DataBlock.getDataBlocks(codewords, version);\n\n // Count total number of data bytes\n let totalBytes = 0;\n for (let db of dataBlocks) {\n totalBytes += db.getNumDataCodewords();\n }\n const resultBytes = new Uint8Array(totalBytes);\n\n const dataBlocksCount = dataBlocks.length;\n // Error-correct and copy data blocks together into a stream of bytes\n for (let j = 0; j < dataBlocksCount; j++) {\n const dataBlock = dataBlocks[j];\n const codewordBytes = dataBlock.getCodewords();\n const numDataCodewords = dataBlock.getNumDataCodewords();\n this.correctErrors(codewordBytes, numDataCodewords);\n for (let i = 0; i < numDataCodewords; i++) {\n // De-interlace data blocks.\n resultBytes[i * dataBlocksCount + j] = codewordBytes[i];\n }\n }\n\n // Decode the contents of that stream of bytes\n return DecodedBitStreamParser.decode(resultBytes);\n }\n\n /**\n *Given data and error-correction codewords received, possibly corrupted by errors, attempts to\n * correct the errors in-place using Reed-Solomon error correction.
\n *\n * @param codewordBytes data and error correction codewords\n * @param numDataCodewords number of codewords that are data bytes\n * @throws ChecksumException if error correction fails\n */\n private correctErrors(codewordBytes: Uint8Array, numDataCodewords: number): void {\n const numCodewords = codewordBytes.length;\n // First read into an array of ints\n const codewordsInts = new Int32Array(codewordBytes);\n // for (let i = 0; i < numCodewords; i++) {\n // codewordsInts[i] = codewordBytes[i] & 0xFF;\n // }\n try {\n this.rsDecoder.decode(codewordsInts, codewordBytes.length - numDataCodewords);\n } catch (ignored /* ReedSolomonException */) {\n throw new ChecksumException();\n }\n // Copy back into array of bytes -- only need to worry about the bytes that were data\n // We don't care about errors in the error-correction codewords\n for (let i = 0; i < numDataCodewords; i++) {\n codewordBytes[i] = codewordsInts[i];\n }\n }\n\n}\n","import BitMatrix from '../../common/BitMatrix';\nimport Version from './Version';\n\nimport FormatException from '../../FormatException';\nimport IllegalArgumentException from '../../IllegalArgumentException';\n\n/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * @author bbrown@google.com (Brian Brown)\n */\nexport default class BitMatrixParser {\n\n private mappingBitMatrix: BitMatrix;\n private readMappingMatrix: BitMatrix;\n private version: Version;\n\n /**\n * @param bitMatrix {@link BitMatrix} to parse\n * @throws FormatException if dimension is < 8 or > 144 or not 0 mod 2\n */\n constructor(bitMatrix: BitMatrix) {\n const dimension = bitMatrix.getHeight();\n if (dimension < 8 || dimension > 144 || (dimension & 0x01) !== 0) {\n throw new FormatException();\n }\n\n this.version = BitMatrixParser.readVersion(bitMatrix);\n this.mappingBitMatrix = this.extractDataRegion(bitMatrix);\n this.readMappingMatrix = new BitMatrix(this.mappingBitMatrix.getWidth(), this.mappingBitMatrix.getHeight());\n }\n\n getVersion(): Version {\n return this.version;\n }\n\n /**\n *Creates the version object based on the dimension of the original bit matrix from\n * the datamatrix code.
\n *\n *See ISO 16022:2006 Table 7 - ECC 200 symbol attributes
\n *\n * @param bitMatrix Original {@link BitMatrix} including alignment patterns\n * @return {@link Version} encapsulating the Data Matrix Code's \"version\"\n * @throws FormatException if the dimensions of the mapping matrix are not valid\n * Data Matrix dimensions.\n */\n public static readVersion(bitMatrix: BitMatrix): Version {\n const numRows = bitMatrix.getHeight();\n const numColumns = bitMatrix.getWidth();\n return Version.getVersionForDimensions(numRows, numColumns);\n }\n\n /**\n *Reads the bits in the {@link BitMatrix} representing the mapping matrix (No alignment patterns)\n * in the correct order in order to reconstitute the codewords bytes contained within the\n * Data Matrix Code.
\n *\n * @return bytes encoded within the Data Matrix Code\n * @throws FormatException if the exact number of bytes expected is not read\n */\n readCodewords(): Int8Array {\n\n const result = new Int8Array(this.version.getTotalCodewords());\n let resultOffset = 0;\n\n let row = 4;\n let column = 0;\n\n const numRows = this.mappingBitMatrix.getHeight();\n const numColumns = this.mappingBitMatrix.getWidth();\n\n let corner1Read = false;\n let corner2Read = false;\n let corner3Read = false;\n let corner4Read = false;\n\n // Read all of the codewords\n do {\n // Check the four corner cases\n if ((row === numRows) && (column === 0) && !corner1Read) {\n result[resultOffset++] = this.readCorner1(numRows, numColumns) & 0xff;\n row -= 2;\n column += 2;\n corner1Read = true;\n } else if ((row === numRows - 2) && (column === 0) && ((numColumns & 0x03) !== 0) && !corner2Read) {\n result[resultOffset++] = this.readCorner2(numRows, numColumns) & 0xff;\n row -= 2;\n column += 2;\n corner2Read = true;\n } else if ((row === numRows + 4) && (column === 2) && ((numColumns & 0x07) === 0) && !corner3Read) {\n result[resultOffset++] = this.readCorner3(numRows, numColumns) & 0xff;\n row -= 2;\n column += 2;\n corner3Read = true;\n } else if ((row === numRows - 2) && (column === 0) && ((numColumns & 0x07) === 4) && !corner4Read) {\n result[resultOffset++] = this.readCorner4(numRows, numColumns) & 0xff;\n row -= 2;\n column += 2;\n corner4Read = true;\n } else {\n // Sweep upward diagonally to the right\n do {\n if ((row < numRows) && (column >= 0) && !this.readMappingMatrix.get(column, row)) {\n result[resultOffset++] = this.readUtah(row, column, numRows, numColumns) & 0xff;\n }\n row -= 2;\n column += 2;\n } while ((row >= 0) && (column < numColumns));\n row += 1;\n column += 3;\n\n // Sweep downward diagonally to the left\n do {\n if ((row >= 0) && (column < numColumns) && !this.readMappingMatrix.get(column, row)) {\n result[resultOffset++] = this.readUtah(row, column, numRows, numColumns) & 0xff;\n }\n row += 2;\n column -= 2;\n } while ((row < numRows) && (column >= 0));\n row += 3;\n column += 1;\n }\n } while ((row < numRows) || (column < numColumns));\n\n if (resultOffset !== this.version.getTotalCodewords()) {\n throw new FormatException();\n }\n return result;\n }\n\n /**\n *Reads a bit of the mapping matrix accounting for boundary wrapping.
\n *\n * @param row Row to read in the mapping matrix\n * @param column Column to read in the mapping matrix\n * @param numRows Number of rows in the mapping matrix\n * @param numColumns Number of columns in the mapping matrix\n * @return value of the given bit in the mapping matrix\n */\n private readModule(row: number, column: number, numRows: number, numColumns: number): boolean {\n // Adjust the row and column indices based on boundary wrapping\n if (row < 0) {\n row += numRows;\n column += 4 - ((numRows + 4) & 0x07);\n }\n if (column < 0) {\n column += numColumns;\n row += 4 - ((numColumns + 4) & 0x07);\n }\n this.readMappingMatrix.set(column, row);\n return this.mappingBitMatrix.get(column, row);\n }\n\n /**\n *Reads the 8 bits of the standard Utah-shaped pattern.
\n *\n *See ISO 16022:2006, 5.8.1 Figure 6
\n *\n * @param row Current row in the mapping matrix, anchored at the 8th bit (LSB) of the pattern\n * @param column Current column in the mapping matrix, anchored at the 8th bit (LSB) of the pattern\n * @param numRows Number of rows in the mapping matrix\n * @param numColumns Number of columns in the mapping matrix\n * @return byte from the utah shape\n */\n private readUtah(row: number, column: number, numRows: number, numColumns: number): number {\n let currentByte = 0;\n if (this.readModule(row - 2, column - 2, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (this.readModule(row - 2, column - 1, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (this.readModule(row - 1, column - 2, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (this.readModule(row - 1, column - 1, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (this.readModule(row - 1, column, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (this.readModule(row, column - 2, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (this.readModule(row, column - 1, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (this.readModule(row, column, numRows, numColumns)) {\n currentByte |= 1;\n }\n return currentByte;\n }\n\n /**\n *Reads the 8 bits of the special corner condition 1.
\n *\n *See ISO 16022:2006, Figure F.3
\n *\n * @param numRows Number of rows in the mapping matrix\n * @param numColumns Number of columns in the mapping matrix\n * @return byte from the Corner condition 1\n */\n private readCorner1(numRows: number, numColumns: number): number {\n let currentByte = 0;\n if (this.readModule(numRows - 1, 0, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (this.readModule(numRows - 1, 1, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (this.readModule(numRows - 1, 2, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (this.readModule(0, numColumns - 2, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (this.readModule(0, numColumns - 1, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (this.readModule(1, numColumns - 1, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (this.readModule(2, numColumns - 1, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (this.readModule(3, numColumns - 1, numRows, numColumns)) {\n currentByte |= 1;\n }\n return currentByte;\n }\n\n /**\n *Reads the 8 bits of the special corner condition 2.
\n *\n *See ISO 16022:2006, Figure F.4
\n *\n * @param numRows Number of rows in the mapping matrix\n * @param numColumns Number of columns in the mapping matrix\n * @return byte from the Corner condition 2\n */\n private readCorner2(numRows: number, numColumns: number): number {\n let currentByte = 0;\n if (this.readModule(numRows - 3, 0, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (this.readModule(numRows - 2, 0, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (this.readModule(numRows - 1, 0, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (this.readModule(0, numColumns - 4, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (this.readModule(0, numColumns - 3, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (this.readModule(0, numColumns - 2, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (this.readModule(0, numColumns - 1, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (this.readModule(1, numColumns - 1, numRows, numColumns)) {\n currentByte |= 1;\n }\n return currentByte;\n }\n\n /**\n *Reads the 8 bits of the special corner condition 3.
\n *\n *See ISO 16022:2006, Figure F.5
\n *\n * @param numRows Number of rows in the mapping matrix\n * @param numColumns Number of columns in the mapping matrix\n * @return byte from the Corner condition 3\n */\n private readCorner3(numRows: number, numColumns: number): number {\n let currentByte = 0;\n if (this.readModule(numRows - 1, 0, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (this.readModule(numRows - 1, numColumns - 1, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (this.readModule(0, numColumns - 3, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (this.readModule(0, numColumns - 2, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (this.readModule(0, numColumns - 1, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (this.readModule(1, numColumns - 3, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (this.readModule(1, numColumns - 2, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (this.readModule(1, numColumns - 1, numRows, numColumns)) {\n currentByte |= 1;\n }\n return currentByte;\n }\n\n /**\n *Reads the 8 bits of the special corner condition 4.
\n *\n *See ISO 16022:2006, Figure F.6
\n *\n * @param numRows Number of rows in the mapping matrix\n * @param numColumns Number of columns in the mapping matrix\n * @return byte from the Corner condition 4\n */\n private readCorner4(numRows: number, numColumns: number): number {\n let currentByte = 0;\n if (this.readModule(numRows - 3, 0, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (this.readModule(numRows - 2, 0, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (this.readModule(numRows - 1, 0, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (this.readModule(0, numColumns - 2, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (this.readModule(0, numColumns - 1, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (this.readModule(1, numColumns - 1, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (this.readModule(2, numColumns - 1, numRows, numColumns)) {\n currentByte |= 1;\n }\n currentByte <<= 1;\n if (this.readModule(3, numColumns - 1, numRows, numColumns)) {\n currentByte |= 1;\n }\n return currentByte;\n }\n\n /**\n *Extracts the data region from a {@link BitMatrix} that contains\n * alignment patterns.
\n *\n * @param bitMatrix Original {@link BitMatrix} with alignment patterns\n * @return BitMatrix that has the alignment patterns removed\n */\n private extractDataRegion(bitMatrix: BitMatrix): BitMatrix {\n const symbolSizeRows = this.version.getSymbolSizeRows();\n const symbolSizeColumns = this.version.getSymbolSizeColumns();\n\n if (bitMatrix.getHeight() !== symbolSizeRows) {\n throw new IllegalArgumentException('Dimension of bitMatrix must match the version size');\n }\n\n const dataRegionSizeRows = this.version.getDataRegionSizeRows();\n const dataRegionSizeColumns = this.version.getDataRegionSizeColumns();\n\n const numDataRegionsRow = symbolSizeRows / dataRegionSizeRows | 0;\n const numDataRegionsColumn = symbolSizeColumns / dataRegionSizeColumns | 0;\n\n const sizeDataRegionRow = numDataRegionsRow * dataRegionSizeRows;\n const sizeDataRegionColumn = numDataRegionsColumn * dataRegionSizeColumns;\n\n const bitMatrixWithoutAlignment = new BitMatrix(sizeDataRegionColumn, sizeDataRegionRow);\n for (let dataRegionRow = 0; dataRegionRow < numDataRegionsRow; ++dataRegionRow) {\n const dataRegionRowOffset = dataRegionRow * dataRegionSizeRows;\n for (let dataRegionColumn = 0; dataRegionColumn < numDataRegionsColumn; ++dataRegionColumn) {\n const dataRegionColumnOffset = dataRegionColumn * dataRegionSizeColumns;\n for (let i = 0; i < dataRegionSizeRows; ++i) {\n const readRowOffset = dataRegionRow * (dataRegionSizeRows + 2) + 1 + i;\n const writeRowOffset = dataRegionRowOffset + i;\n for (let j = 0; j < dataRegionSizeColumns; ++j) {\n const readColumnOffset = dataRegionColumn * (dataRegionSizeColumns + 2) + 1 + j;\n if (bitMatrix.get(readColumnOffset, readRowOffset)) {\n const writeColumnOffset = dataRegionColumnOffset + j;\n bitMatrixWithoutAlignment.set(writeColumnOffset, writeRowOffset);\n }\n }\n }\n }\n }\n return bitMatrixWithoutAlignment;\n }\n\n}\n","\nimport FormatException from '../../FormatException';\n\n/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n /**\n *Encapsulates a set of error-correction blocks in one symbol version. Most versions will\n * use blocks of differing sizes within one version, so, this encapsulates the parameters for\n * each set of blocks. It also holds the number of error-correction codewords per block since it\n * will be the same across all blocks within one version.
\n */\n export class ECBlocks {\n private ecCodewords: number;\n private ecBlocks: ECB[];\n\n constructor(ecCodewords: number, ecBlocks1: ECB, ecBlocks2?: ECB) {\n this.ecCodewords = ecCodewords;\n this.ecBlocks = [ ecBlocks1 ];\n ecBlocks2 && this.ecBlocks.push(ecBlocks2);\n }\n\n getECCodewords(): number {\n return this.ecCodewords;\n }\n\n getECBlocks(): ECB[] {\n return this.ecBlocks;\n }\n }\n\n /**\n *Encapsulates the parameters for one error-correction block in one symbol version.\n * This includes the number of data codewords, and the number of times a block with these\n * parameters is used consecutively in the Data Matrix code version's format.
\n */\nexport class ECB {\n private count: number;\n private dataCodewords: number;\n\n constructor(count: number, dataCodewords: number) {\n this.count = count;\n this.dataCodewords = dataCodewords;\n }\n\n getCount(): number {\n return this.count;\n }\n\n getDataCodewords(): number {\n return this.dataCodewords;\n }\n }\n\n/**\n * The Version object encapsulates attributes about a particular\n * size Data Matrix Code.\n *\n * @author bbrown@google.com (Brian Brown)\n */\nexport default class Version {\n\n private static VERSIONS: Version[] = Version.buildVersions();\n\n private versionNumber: number;\n private symbolSizeRows: number;\n private symbolSizeColumns: number;\n private dataRegionSizeRows: number;\n private dataRegionSizeColumns: number;\n private ecBlocks: ECBlocks;\n private totalCodewords: number;\n\n constructor(versionNumber,\n symbolSizeRows,\n symbolSizeColumns,\n dataRegionSizeRows,\n dataRegionSizeColumns,\n ecBlocks: ECBlocks) {\n this.versionNumber = versionNumber;\n this.symbolSizeRows = symbolSizeRows;\n this.symbolSizeColumns = symbolSizeColumns;\n this.dataRegionSizeRows = dataRegionSizeRows;\n this.dataRegionSizeColumns = dataRegionSizeColumns;\n this.ecBlocks = ecBlocks;\n\n // Calculate the total number of codewords\n let total = 0;\n const ecCodewords = ecBlocks.getECCodewords();\n const ecbArray = ecBlocks.getECBlocks();\n for (let ecBlock of ecbArray) {\n total += ecBlock.getCount() * (ecBlock.getDataCodewords() + ecCodewords);\n }\n this.totalCodewords = total;\n }\n\n public getVersionNumber(): number {\n return this.versionNumber;\n }\n\n public getSymbolSizeRows(): number {\n return this.symbolSizeRows;\n }\n\n public getSymbolSizeColumns(): number {\n return this.symbolSizeColumns;\n }\n\n public getDataRegionSizeRows(): number {\n return this.dataRegionSizeRows;\n }\n\n public getDataRegionSizeColumns(): number {\n return this.dataRegionSizeColumns;\n }\n\n public getTotalCodewords(): number {\n return this.totalCodewords;\n }\n\n public getECBlocks(): ECBlocks {\n return this.ecBlocks;\n }\n\n /**\n *Deduces version information from Data Matrix dimensions.
\n *\n * @param numRows Number of rows in modules\n * @param numColumns Number of columns in modules\n * @return Version for a Data Matrix Code of those dimensions\n * @throws FormatException if dimensions do correspond to a valid Data Matrix size\n */\n public static getVersionForDimensions(numRows: number, numColumns: number): Version {\n if ((numRows & 0x01) !== 0 || (numColumns & 0x01) !== 0) {\n throw new FormatException();\n }\n\n for (let version of Version.VERSIONS) {\n if (version.symbolSizeRows === numRows && version.symbolSizeColumns === numColumns) {\n return version;\n }\n }\n\n throw new FormatException();\n }\n\n// @Override\n public toString(): string {\n return '' + this.versionNumber;\n }\n\n /**\n * See ISO 16022:2006 5.5.1 Table 7\n */\n private static buildVersions(): Version[] {\n return [\n new Version(1, 10, 10, 8, 8,\n new ECBlocks(5, new ECB(1, 3))),\n new Version(2, 12, 12, 10, 10,\n new ECBlocks(7, new ECB(1, 5))),\n new Version(3, 14, 14, 12, 12,\n new ECBlocks(10, new ECB(1, 8))),\n new Version(4, 16, 16, 14, 14,\n new ECBlocks(12, new ECB(1, 12))),\n new Version(5, 18, 18, 16, 16,\n new ECBlocks(14, new ECB(1, 18))),\n new Version(6, 20, 20, 18, 18,\n new ECBlocks(18, new ECB(1, 22))),\n new Version(7, 22, 22, 20, 20,\n new ECBlocks(20, new ECB(1, 30))),\n new Version(8, 24, 24, 22, 22,\n new ECBlocks(24, new ECB(1, 36))),\n new Version(9, 26, 26, 24, 24,\n new ECBlocks(28, new ECB(1, 44))),\n new Version(10, 32, 32, 14, 14,\n new ECBlocks(36, new ECB(1, 62))),\n new Version(11, 36, 36, 16, 16,\n new ECBlocks(42, new ECB(1, 86))),\n new Version(12, 40, 40, 18, 18,\n new ECBlocks(48, new ECB(1, 114))),\n new Version(13, 44, 44, 20, 20,\n new ECBlocks(56, new ECB(1, 144))),\n new Version(14, 48, 48, 22, 22,\n new ECBlocks(68, new ECB(1, 174))),\n new Version(15, 52, 52, 24, 24,\n new ECBlocks(42, new ECB(2, 102))),\n new Version(16, 64, 64, 14, 14,\n new ECBlocks(56, new ECB(2, 140))),\n new Version(17, 72, 72, 16, 16,\n new ECBlocks(36, new ECB(4, 92))),\n new Version(18, 80, 80, 18, 18,\n new ECBlocks(48, new ECB(4, 114))),\n new Version(19, 88, 88, 20, 20,\n new ECBlocks(56, new ECB(4, 144))),\n new Version(20, 96, 96, 22, 22,\n new ECBlocks(68, new ECB(4, 174))),\n new Version(21, 104, 104, 24, 24,\n new ECBlocks(56, new ECB(6, 136))),\n new Version(22, 120, 120, 18, 18,\n new ECBlocks(68, new ECB(6, 175))),\n new Version(23, 132, 132, 20, 20,\n new ECBlocks(62, new ECB(8, 163))),\n new Version(24, 144, 144, 22, 22,\n new ECBlocks(62, new ECB(8, 156), new ECB(2, 155))),\n new Version(25, 8, 18, 6, 16,\n new ECBlocks(7, new ECB(1, 5))),\n new Version(26, 8, 32, 6, 14,\n new ECBlocks(11, new ECB(1, 10))),\n new Version(27, 12, 26, 10, 24,\n new ECBlocks(14, new ECB(1, 16))),\n new Version(28, 12, 36, 10, 16,\n new ECBlocks(18, new ECB(1, 22))),\n new Version(29, 16, 36, 14, 16,\n new ECBlocks(24, new ECB(1, 32))),\n new Version(30, 16, 48, 14, 22,\n new ECBlocks(28, new ECB(1, 49)))\n ];\n }\n\n}\n","import Version from './Version';\n\nimport IllegalArgumentException from '../../IllegalArgumentException';\n\n/*\n * Copyright 2008 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n *Encapsulates a block of data within a Data Matrix Code. Data Matrix Codes may split their data into\n * multiple blocks, each of which is a unit of data and error-correction codewords. Each\n * is represented by an instance of this class.
\n *\n * @author bbrown@google.com (Brian Brown)\n */\nexport default class DataBlock {\n\n private numDataCodewords: number;\n private codewords: Uint8Array;\n\n constructor(numDataCodewords: number, codewords: Uint8Array) {\n this.numDataCodewords = numDataCodewords;\n this.codewords = codewords;\n }\n\n /**\n *When Data Matrix Codes use multiple data blocks, they actually interleave the bytes of each of them.\n * That is, the first byte of data block 1 to n is written, then the second bytes, and so on. This\n * method will separate the data into original blocks.
\n *\n * @param rawCodewords bytes as read directly from the Data Matrix Code\n * @param version version of the Data Matrix Code\n * @return DataBlocks containing original bytes, \"de-interleaved\" from representation in the\n * Data Matrix Code\n */\n static getDataBlocks(rawCodewords: Int8Array,\n version: Version): DataBlock[] {\n // Figure out the number and size of data blocks used by this version\n const ecBlocks = version.getECBlocks();\n\n // First count the total number of data blocks\n let totalBlocks = 0;\n const ecBlockArray = ecBlocks.getECBlocks();\n for (let ecBlock of ecBlockArray) {\n totalBlocks += ecBlock.getCount();\n }\n\n // Now establish DataBlocks of the appropriate size and number of data codewords\n const result: DataBlock[] = new Array(totalBlocks);\n let numResultBlocks = 0;\n for (let ecBlock of ecBlockArray) {\n for (let i = 0; i < ecBlock.getCount(); i++) {\n const numDataCodewords = ecBlock.getDataCodewords();\n const numBlockCodewords = ecBlocks.getECCodewords() + numDataCodewords;\n result[numResultBlocks++] = new DataBlock(numDataCodewords, new Uint8Array(numBlockCodewords));\n }\n }\n\n // All blocks have the same amount of data, except that the last n\n // (where n may be 0) have 1 less byte. Figure out where these start.\n // TODO(bbrown): There is only one case where there is a difference for Data Matrix for size 144\n const longerBlocksTotalCodewords = result[0].codewords.length;\n // int shorterBlocksTotalCodewords = longerBlocksTotalCodewords - 1;\n\n const longerBlocksNumDataCodewords = longerBlocksTotalCodewords - ecBlocks.getECCodewords();\n const shorterBlocksNumDataCodewords = longerBlocksNumDataCodewords - 1;\n // The last elements of result may be 1 element shorter for 144 matrix\n // first fill out as many elements as all of them have minus 1\n let rawCodewordsOffset = 0;\n for (let i = 0; i < shorterBlocksNumDataCodewords; i++) {\n for (let j = 0; j < numResultBlocks; j++) {\n result[j].codewords[i] = rawCodewords[rawCodewordsOffset++];\n }\n }\n\n // Fill out the last data block in the longer ones\n const specialVersion = version.getVersionNumber() === 24;\n const numLongerBlocks = specialVersion ? 8 : numResultBlocks;\n for (let j = 0; j < numLongerBlocks; j++) {\n result[j].codewords[longerBlocksNumDataCodewords - 1] = rawCodewords[rawCodewordsOffset++];\n }\n\n // Now add in error correction blocks\n const max = result[0].codewords.length;\n for (let i = longerBlocksNumDataCodewords; i < max; i++) {\n for (let j = 0; j < numResultBlocks; j++) {\n const jOffset = specialVersion ? (j + 8) % numResultBlocks : j;\n const iOffset = specialVersion && jOffset > 7 ? i - 1 : i;\n result[jOffset].codewords[iOffset] = rawCodewords[rawCodewordsOffset++];\n }\n }\n\n if (rawCodewordsOffset !== rawCodewords.length) {\n throw new IllegalArgumentException();\n }\n\n return result;\n }\n\n getNumDataCodewords(): number {\n return this.numDataCodewords;\n }\n\n getCodewords(): Uint8Array {\n return this.codewords;\n }\n\n}\n","import DecoderResult from '../../common/DecoderResult';\nimport BitSource from '../../common/BitSource';\nimport StringBuilder from '../../util/StringBuilder';\n\nimport StringEncoding from '../../util/StringEncoding';\nimport StringUtils from '../../common/StringUtils';\nimport FormatException from '../../FormatException';\nimport IllegalStateException from '../../IllegalStateException';\n\n/*\n * Copyright 2008 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nenum Mode {\n PAD_ENCODE, // Not really a mode\n ASCII_ENCODE,\n C40_ENCODE,\n TEXT_ENCODE,\n ANSIX12_ENCODE,\n EDIFACT_ENCODE,\n BASE256_ENCODE\n}\n\n/**\n *Data Matrix Codes can encode text as bits in one of several modes, and can use multiple modes\n * in one Data Matrix Code. This class decodes the bits back into text.
\n *\n *See ISO 16022:2006, 5.2.1 - 5.2.9.2
\n *\n * @author bbrown@google.com (Brian Brown)\n * @author Sean Owen\n */\nexport default class DecodedBitStreamParser {\n\n /**\n * See ISO 16022:2006, Annex C Table C.1\n * The C40 Basic Character Set (*'s used for placeholders for the shift values)\n */\n private static C40_BASIC_SET_CHARS: string[] = [\n '*', '*', '*', ' ', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',\n 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',\n 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'\n ];\n\n private static C40_SHIFT2_SET_CHARS: string[] = [\n '!', '\"', '#', '$', '%', '&', '\\'', '(', ')', '*', '+', ',', '-', '.',\n '/', ':', ';', '<', '=', '>', '?', '@', '[', '\\\\', ']', '^', '_'\n ];\n\n /**\n * See ISO 16022:2006, Annex C Table C.2\n * The Text Basic Character Set (*'s used for placeholders for the shift values)\n */\n private static TEXT_BASIC_SET_CHARS: string[] = [\n '*', '*', '*', ' ', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',\n 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',\n 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'\n ];\n\n // Shift 2 for Text is the same encoding as C40\n private static TEXT_SHIFT2_SET_CHARS = DecodedBitStreamParser.C40_SHIFT2_SET_CHARS;\n\n private static TEXT_SHIFT3_SET_CHARS: string[] = [\n '`', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',\n 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '{', '|', '}', '~', String.fromCharCode(127)\n ];\n\n static decode(bytes: Uint8Array): DecoderResult {\n const bits = new BitSource(bytes);\n const result = new StringBuilder();\n const resultTrailer = new StringBuilder();\n const byteSegments = new ArrayEncapsulates logic that can detect a Data Matrix Code in an image, even if the Data Matrix Code\n * is rotated or skewed, or partially obscured.
\n *\n * @author Sean Owen\n */\nexport default class Detector {\n\n private image: BitMatrix;\n private rectangleDetector: WhiteRectangleDetector;\n\n constructor(image: BitMatrix) {\n this.image = image;\n this.rectangleDetector = new WhiteRectangleDetector(this.image);\n }\n\n /**\n *Detects a Data Matrix Code in an image.
\n *\n * @return {@link DetectorResult} encapsulating results of detecting a Data Matrix Code\n * @throws NotFoundException if no Data Matrix Code can be found\n */\n public detect(): DetectorResult {\n\n\n const cornerPoints = this.rectangleDetector.detect();\n\n let points = this.detectSolid1(cornerPoints);\n points = this.detectSolid2(points);\n points[3] = this.correctTopRight(points);\n if (!points[3]) {\n throw new NotFoundException();\n }\n points = this.shiftToModuleCenter(points);\n\n const topLeft = points[0];\n const bottomLeft = points[1];\n const bottomRight = points[2];\n const topRight = points[3];\n\n let dimensionTop = this.transitionsBetween(topLeft, topRight) + 1;\n let dimensionRight = this.transitionsBetween(bottomRight, topRight) + 1;\n if ((dimensionTop & 0x01) === 1) {\n dimensionTop += 1;\n }\n if ((dimensionRight & 0x01) === 1) {\n dimensionRight += 1;\n }\n\n if (4 * dimensionTop < 7 * dimensionRight && 4 * dimensionRight < 7 * dimensionTop) {\n // The matrix is square\n dimensionTop = dimensionRight = Math.max(dimensionTop, dimensionRight);\n }\n\n let bits = Detector.sampleGrid(this.image,\n topLeft,\n bottomLeft,\n bottomRight,\n topRight,\n dimensionTop,\n dimensionRight);\n\n return new DetectorResult(bits, [topLeft, bottomLeft, bottomRight, topRight]);\n }\n\n private static shiftPoint(point: ResultPoint, to: ResultPoint, div: float): ResultPoint {\n let x = (to.getX() - point.getX()) / (div + 1);\n let y = (to.getY() - point.getY()) / (div + 1);\n return new ResultPoint(point.getX() + x, point.getY() + y);\n }\n\n private static moveAway(point: ResultPoint, fromX: float, fromY: float): ResultPoint {\n let x = point.getX();\n let y = point.getY();\n\n if (x < fromX) {\n x -= 1;\n } else {\n x += 1;\n }\n\n if (y < fromY) {\n y -= 1;\n } else {\n y += 1;\n }\n\n return new ResultPoint(x, y);\n }\n\n /**\n * Detect a solid side which has minimum transition.\n */\n private detectSolid1(cornerPoints: ResultPoint[]): ResultPoint[] {\n // 0 2\n // 1 3\n let pointA = cornerPoints[0];\n let pointB = cornerPoints[1];\n let pointC = cornerPoints[3];\n let pointD = cornerPoints[2];\n\n let trAB = this.transitionsBetween(pointA, pointB);\n let trBC = this.transitionsBetween(pointB, pointC);\n let trCD = this.transitionsBetween(pointC, pointD);\n let trDA = this.transitionsBetween(pointD, pointA);\n\n // 0..3\n // : :\n // 1--2\n let min = trAB;\n let points = [pointD, pointA, pointB, pointC];\n if (min > trBC) {\n min = trBC;\n points[0] = pointA;\n points[1] = pointB;\n points[2] = pointC;\n points[3] = pointD;\n }\n if (min > trCD) {\n min = trCD;\n points[0] = pointB;\n points[1] = pointC;\n points[2] = pointD;\n points[3] = pointA;\n }\n if (min > trDA) {\n points[0] = pointC;\n points[1] = pointD;\n points[2] = pointA;\n points[3] = pointB;\n }\n\n return points;\n }\n\n /**\n * Detect a second solid side next to first solid side.\n */\n private detectSolid2(points: ResultPoint[]): ResultPoint[] {\n // A..D\n // : :\n // B--C\n let pointA = points[0];\n let pointB = points[1];\n let pointC = points[2];\n let pointD = points[3];\n\n // Transition detection on the edge is not stable.\n // To safely detect, shift the points to the module center.\n let tr = this.transitionsBetween(pointA, pointD);\n let pointBs = Detector.shiftPoint(pointB, pointC, (tr + 1) * 4);\n let pointCs = Detector.shiftPoint(pointC, pointB, (tr + 1) * 4);\n let trBA = this.transitionsBetween(pointBs, pointA);\n let trCD = this.transitionsBetween(pointCs, pointD);\n\n // 0..3\n // | :\n // 1--2\n if (trBA < trCD) {\n // solid sides: A-B-C\n points[0] = pointA;\n points[1] = pointB;\n points[2] = pointC;\n points[3] = pointD;\n } else {\n // solid sides: B-C-D\n points[0] = pointB;\n points[1] = pointC;\n points[2] = pointD;\n points[3] = pointA;\n }\n\n return points;\n }\n\n /**\n * Calculates the corner position of the white top right module.\n */\n private correctTopRight(points: ResultPoint[]): ResultPoint {\n // A..D\n // | :\n // B--C\n let pointA = points[0];\n let pointB = points[1];\n let pointC = points[2];\n let pointD = points[3];\n\n // shift points for safe transition detection.\n let trTop = this.transitionsBetween(pointA, pointD);\n let trRight = this.transitionsBetween(pointB, pointD);\n let pointAs = Detector.shiftPoint(pointA, pointB, (trRight + 1) * 4);\n let pointCs = Detector.shiftPoint(pointC, pointB, (trTop + 1) * 4);\n\n trTop = this.transitionsBetween(pointAs, pointD);\n trRight = this.transitionsBetween(pointCs, pointD);\n\n let candidate1 = new ResultPoint(\n pointD.getX() + (pointC.getX() - pointB.getX()) / (trTop + 1),\n pointD.getY() + (pointC.getY() - pointB.getY()) / (trTop + 1));\n let candidate2 = new ResultPoint(\n pointD.getX() + (pointA.getX() - pointB.getX()) / (trRight + 1),\n pointD.getY() + (pointA.getY() - pointB.getY()) / (trRight + 1));\n\n if (!this.isValid(candidate1)) {\n if (this.isValid(candidate2)) {\n return candidate2;\n }\n return null;\n }\n if (!this.isValid(candidate2)) {\n return candidate1;\n }\n\n let sumc1 = this.transitionsBetween(pointAs, candidate1) + this.transitionsBetween(pointCs, candidate1);\n let sumc2 = this.transitionsBetween(pointAs, candidate2) + this.transitionsBetween(pointCs, candidate2);\n\n if (sumc1 > sumc2) {\n return candidate1;\n } else {\n return candidate2;\n }\n }\n\n /**\n * Shift the edge points to the module center.\n */\n private shiftToModuleCenter(points: ResultPoint[]): ResultPoint[] {\n // A..D\n // | :\n // B--C\n let pointA = points[0];\n let pointB = points[1];\n let pointC = points[2];\n let pointD = points[3];\n\n // calculate pseudo dimensions\n let dimH = this.transitionsBetween(pointA, pointD) + 1;\n let dimV = this.transitionsBetween(pointC, pointD) + 1;\n\n // shift points for safe dimension detection\n let pointAs = Detector.shiftPoint(pointA, pointB, dimV * 4);\n let pointCs = Detector.shiftPoint(pointC, pointB, dimH * 4);\n\n // calculate more precise dimensions\n dimH = this.transitionsBetween(pointAs, pointD) + 1;\n dimV = this.transitionsBetween(pointCs, pointD) + 1;\n if ((dimH & 0x01) === 1) {\n dimH += 1;\n }\n if ((dimV & 0x01) === 1) {\n dimV += 1;\n }\n\n // WhiteRectangleDetector returns points inside of the rectangle.\n // I want points on the edges.\n let centerX = (pointA.getX() + pointB.getX() + pointC.getX() + pointD.getX()) / 4;\n let centerY = (pointA.getY() + pointB.getY() + pointC.getY() + pointD.getY()) / 4;\n pointA = Detector.moveAway(pointA, centerX, centerY);\n pointB = Detector.moveAway(pointB, centerX, centerY);\n pointC = Detector.moveAway(pointC, centerX, centerY);\n pointD = Detector.moveAway(pointD, centerX, centerY);\n\n let pointBs: ResultPoint;\n let pointDs: ResultPoint;\n\n // shift points to the center of each modules\n pointAs = Detector.shiftPoint(pointA, pointB, dimV * 4);\n pointAs = Detector.shiftPoint(pointAs, pointD, dimH * 4);\n pointBs = Detector.shiftPoint(pointB, pointA, dimV * 4);\n pointBs = Detector.shiftPoint(pointBs, pointC, dimH * 4);\n pointCs = Detector.shiftPoint(pointC, pointD, dimV * 4);\n pointCs = Detector.shiftPoint(pointCs, pointB, dimH * 4);\n pointDs = Detector.shiftPoint(pointD, pointC, dimV * 4);\n pointDs = Detector.shiftPoint(pointDs, pointA, dimH * 4);\n\n return [pointAs, pointBs, pointCs, pointDs];\n }\n\n private isValid(p: ResultPoint): boolean {\n return p.getX() >= 0 && p.getX() < this.image.getWidth() && p.getY() > 0 && p.getY() < this.image.getHeight();\n }\n\n private static sampleGrid(image: BitMatrix,\n topLeft: ResultPoint,\n bottomLeft: ResultPoint,\n bottomRight: ResultPoint,\n topRight: ResultPoint,\n dimensionX: int,\n dimensionY: int): BitMatrix {\n\n const sampler = GridSamplerInstance.getInstance();\n\n return sampler.sampleGrid(image,\n dimensionX,\n dimensionY,\n 0.5,\n 0.5,\n dimensionX - 0.5,\n 0.5,\n dimensionX - 0.5,\n dimensionY - 0.5,\n 0.5,\n dimensionY - 0.5,\n topLeft.getX(),\n topLeft.getY(),\n topRight.getX(),\n topRight.getY(),\n bottomRight.getX(),\n bottomRight.getY(),\n bottomLeft.getX(),\n bottomLeft.getY());\n }\n\n /**\n * Counts the number of black/white transitions between two points, using something like Bresenham's algorithm.\n */\n private transitionsBetween(from: ResultPoint, to: ResultPoint): int {\n // See QR Code Detector, sizeOfBlackWhiteBlackRun()\n let fromX = Math.trunc(from.getX());\n let fromY = Math.trunc(from.getY());\n let toX = Math.trunc(to.getX());\n let toY = Math.trunc(to.getY());\n let steep: boolean = Math.abs(toY - fromY) > Math.abs(toX - fromX);\n if (steep) {\n let temp = fromX;\n fromX = fromY;\n fromY = temp;\n temp = toX;\n toX = toY;\n toY = temp;\n }\n\n let dx = Math.abs(toX - fromX);\n let dy = Math.abs(toY - fromY);\n let error = -dx / 2;\n let ystep = fromY < toY ? 1 : -1;\n let xstep = fromX < toX ? 1 : -1;\n let transitions = 0;\n let inBlack: boolean = this.image.get(steep ? fromY : fromX, steep ? fromX : fromY);\n for (let x: int = fromX, y = fromY; x !== toX; x += xstep) {\n let isBlack: boolean = this.image.get(steep ? y : x, steep ? x : y);\n if (isBlack !== inBlack) {\n transitions++;\n inBlack = isBlack;\n }\n error += dy;\n if (error > 0) {\n if (y === toY) {\n break;\n }\n y += ystep;\n error -= dx;\n }\n }\n return transitions;\n }\n}\n","import { BrowserCodeReader } from './BrowserCodeReader';\nimport MultiFormatReader from '../core/MultiFormatReader';\nimport BinaryBitmap from '../core/BinaryBitmap';\nimport Result from '../core/Result';\nimport DecodeHintType from '../core/DecodeHintType';\n\nexport class BrowserMultiFormatReader extends BrowserCodeReader {\n\n protected readonly reader: MultiFormatReader;\n\n public constructor(\n hints: MapThe main class which implements QR Code decoding -- as opposed to locating and extracting\n * the QR Code from an image.
\n *\n * @author Sean Owen\n */\nexport default class Decoder {\n\n private rsDecoder: ReedSolomonDecoder;\n\n public constructor() {\n this.rsDecoder = new ReedSolomonDecoder(GenericGF.QR_CODE_FIELD_256);\n }\n\n // public decode(image: boolean[][]): DecoderResult /*throws ChecksumException, FormatException*/ {\n // return decode(image, null)\n // }\n\n /**\n *Convenience method that can decode a QR Code represented as a 2D array of booleans.\n * \"true\" is taken to mean a black module.
\n *\n * @param image booleans representing white/black QR Code modules\n * @param hints decoding hints that should be used to influence decoding\n * @return text and bytes encoded within the QR Code\n * @throws FormatException if the QR Code cannot be decoded\n * @throws ChecksumException if error correction fails\n */\n public decodeBooleanArray(image: boolean[][], hints?: MapDecodes a QR Code represented as a {@link BitMatrix}. A 1 or \"true\" is taken to mean a black module.
\n *\n * @param bits booleans representing white/black QR Code modules\n * @param hints decoding hints that should be used to influence decoding\n * @return text and bytes encoded within the QR Code\n * @throws FormatException if the QR Code cannot be decoded\n * @throws ChecksumException if error correction fails\n */\n public decodeBitMatrix(bits: BitMatrix, hints?: MapGiven data and error-correction codewords received, possibly corrupted by errors, attempts to\n * correct the errors in-place using Reed-Solomon error correction.
\n *\n * @param codewordBytes data and error correction codewords\n * @param numDataCodewords number of codewords that are data bytes\n * @throws ChecksumException if error correction fails\n */\n private correctErrors(codewordBytes: Uint8Array, numDataCodewords: number /*int*/): void /*throws ChecksumException*/ {\n const numCodewords = codewordBytes.length;\n // First read into an array of ints\n const codewordsInts = new Int32Array(codewordBytes);\n // TYPESCRIPTPORT: not realy necessary to transform to ints? could redesign everything to work with unsigned bytes?\n // const codewordsInts = new Int32Array(numCodewords)\n // for (let i = 0; i < numCodewords; i++) {\n // codewordsInts[i] = codewordBytes[i] & 0xFF\n // }\n try {\n this.rsDecoder.decode(codewordsInts, codewordBytes.length - numDataCodewords);\n } catch (ignored/*: ReedSolomonException*/) {\n throw new ChecksumException();\n }\n // Copy back into array of bytes -- only need to worry about the bytes that were data\n // We don't care about errors in the error-correction codewords\n for (let i = 0; i < numDataCodewords; i++) {\n codewordBytes[i] = /*(byte) */codewordsInts[i];\n }\n }\n\n}\n","/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/*namespace com.google.zxing.qrcode.decoder {*/\n\nimport BitMatrix from '../../common/BitMatrix';\nimport Version from './Version';\nimport FormatInformation from './FormatInformation';\n\nimport DataMask from './DataMask';\nimport FormatException from '../../FormatException';\n/**\n * @author Sean Owen\n */\nexport default class BitMatrixParser {\n\n private bitMatrix: BitMatrix;\n private parsedVersion: Version;\n private parsedFormatInfo: FormatInformation;\n private isMirror: boolean;\n\n /**\n * @param bitMatrix {@link BitMatrix} to parse\n * @throws FormatException if dimension is not >= 21 and 1 mod 4\n */\n public constructor(bitMatrix: BitMatrix) /*throws FormatException*/ {\n const dimension = bitMatrix.getHeight();\n if (dimension < 21 || (dimension & 0x03) !== 1) {\n throw new FormatException();\n }\n this.bitMatrix = bitMatrix;\n }\n\n /**\n *Reads format information from one of its two locations within the QR Code.
\n *\n * @return {@link FormatInformation} encapsulating the QR Code's format info\n * @throws FormatException if both format information locations cannot be parsed as\n * the valid encoding of format information\n */\n public readFormatInformation(): FormatInformation /*throws FormatException*/ {\n\n if (this.parsedFormatInfo !== null && this.parsedFormatInfo !== undefined) {\n return this.parsedFormatInfo;\n }\n\n // Read top-left format info bits\n let formatInfoBits1 = 0;\n for (let i = 0; i < 6; i++) {\n formatInfoBits1 = this.copyBit(i, 8, formatInfoBits1);\n }\n // .. and skip a bit in the timing pattern ...\n formatInfoBits1 = this.copyBit(7, 8, formatInfoBits1);\n formatInfoBits1 = this.copyBit(8, 8, formatInfoBits1);\n formatInfoBits1 = this.copyBit(8, 7, formatInfoBits1);\n // .. and skip a bit in the timing pattern ...\n for (let j = 5; j >= 0; j--) {\n formatInfoBits1 = this.copyBit(8, j, formatInfoBits1);\n }\n\n // Read the top-right/bottom-left pattern too\n const dimension = this.bitMatrix.getHeight();\n let formatInfoBits2 = 0;\n const jMin = dimension - 7;\n for (let j = dimension - 1; j >= jMin; j--) {\n formatInfoBits2 = this.copyBit(8, j, formatInfoBits2);\n }\n for (let i = dimension - 8; i < dimension; i++) {\n formatInfoBits2 = this.copyBit(i, 8, formatInfoBits2);\n }\n\n this.parsedFormatInfo = FormatInformation.decodeFormatInformation(formatInfoBits1, formatInfoBits2);\n if (this.parsedFormatInfo !== null) {\n return this.parsedFormatInfo;\n }\n throw new FormatException();\n }\n\n /**\n *Reads version information from one of its two locations within the QR Code.
\n *\n * @return {@link Version} encapsulating the QR Code's version\n * @throws FormatException if both version information locations cannot be parsed as\n * the valid encoding of version information\n */\n public readVersion(): Version /*throws FormatException*/ {\n\n if (this.parsedVersion !== null && this.parsedVersion !== undefined) {\n return this.parsedVersion;\n }\n\n const dimension = this.bitMatrix.getHeight();\n\n const provisionalVersion = Math.floor((dimension - 17) / 4);\n if (provisionalVersion <= 6) {\n return Version.getVersionForNumber(provisionalVersion);\n }\n\n // Read top-right version info: 3 wide by 6 tall\n let versionBits = 0;\n const ijMin = dimension - 11;\n for (let j = 5; j >= 0; j--) {\n for (let i = dimension - 9; i >= ijMin; i--) {\n versionBits = this.copyBit(i, j, versionBits);\n }\n }\n\n let theParsedVersion = Version.decodeVersionInformation(versionBits);\n if (theParsedVersion !== null && theParsedVersion.getDimensionForVersion() === dimension) {\n this.parsedVersion = theParsedVersion;\n return theParsedVersion;\n }\n\n // Hmm, failed. Try bottom left: 6 wide by 3 tall\n versionBits = 0;\n for (let i = 5; i >= 0; i--) {\n for (let j = dimension - 9; j >= ijMin; j--) {\n versionBits = this.copyBit(i, j, versionBits);\n }\n }\n\n theParsedVersion = Version.decodeVersionInformation(versionBits);\n if (theParsedVersion !== null && theParsedVersion.getDimensionForVersion() === dimension) {\n this.parsedVersion = theParsedVersion;\n return theParsedVersion;\n }\n throw new FormatException();\n }\n\n private copyBit(i: number /*int*/, j: number /*int*/, versionBits: number /*int*/): number /*int*/ {\n const bit: boolean = this.isMirror ? this.bitMatrix.get(j, i) : this.bitMatrix.get(i, j);\n return bit ? (versionBits << 1) | 0x1 : versionBits << 1;\n }\n\n /**\n *Reads the bits in the {@link BitMatrix} representing the finder pattern in the\n * correct order in order to reconstruct the codewords bytes contained within the\n * QR Code.
\n *\n * @return bytes encoded within the QR Code\n * @throws FormatException if the exact number of bytes expected is not read\n */\n public readCodewords(): Uint8Array /*throws FormatException*/ {\n\n const formatInfo = this.readFormatInformation();\n const version = this.readVersion();\n\n // Get the data mask for the format used in this QR Code. This will exclude\n // some bits from reading as we wind through the bit matrix.\n const dataMask = DataMask.values.get(formatInfo.getDataMask());\n const dimension = this.bitMatrix.getHeight();\n dataMask.unmaskBitMatrix(this.bitMatrix, dimension);\n\n const functionPattern = version.buildFunctionPattern();\n\n let readingUp: boolean = true;\n const result = new Uint8Array(version.getTotalCodewords());\n let resultOffset = 0;\n let currentByte = 0;\n let bitsRead = 0;\n // Read columns in pairs, from right to left\n for (let j = dimension - 1; j > 0; j -= 2) {\n if (j === 6) {\n // Skip whole column with vertical alignment pattern\n // saves time and makes the other code proceed more cleanly\n j--;\n }\n // Read alternatingly from bottom to top then top to bottom\n for (let count = 0; count < dimension; count++) {\n const i = readingUp ? dimension - 1 - count : count;\n for (let col = 0; col < 2; col++) {\n // Ignore bits covered by the function pattern\n if (!functionPattern.get(j - col, i)) {\n // Read a bit\n bitsRead++;\n currentByte <<= 1;\n if (this.bitMatrix.get(j - col, i)) {\n currentByte |= 1;\n }\n // If we've made a whole byte, save it off\n if (bitsRead === 8) {\n result[resultOffset++] = /*(byte) */currentByte;\n bitsRead = 0;\n currentByte = 0;\n }\n }\n }\n }\n readingUp = !readingUp; // readingUp ^= true; // readingUp = !readingUp; // switch directions\n }\n if (resultOffset !== version.getTotalCodewords()) {\n throw new FormatException();\n }\n return result;\n }\n\n /**\n * Revert the mask removal done while reading the code words. The bit matrix should revert to its original state.\n */\n public remask(): void {\n if (this.parsedFormatInfo === null) {\n return; // We have no format information, and have no data mask\n }\n const dataMask = DataMask.values[this.parsedFormatInfo.getDataMask()];\n const dimension = this.bitMatrix.getHeight();\n dataMask.unmaskBitMatrix(this.bitMatrix, dimension);\n }\n\n /**\n * Prepare the parser for a mirrored operation.\n * This flag has effect only on the {@link #readFormatInformation()} and the\n * {@link #readVersion()}. Before proceeding with {@link #readCodewords()} the\n * {@link #mirror()} method should be called.\n *\n * @param mirror Whether to read version and format information mirrored.\n */\n public setMirror(isMirror: boolean): void {\n this.parsedVersion = null;\n this.parsedFormatInfo = null;\n this.isMirror = isMirror;\n }\n\n /** Mirror the bit matrix in order to attempt a second reading. */\n public mirror(): void {\n const bitMatrix = this.bitMatrix;\n for (let x = 0, width = bitMatrix.getWidth(); x < width; x++) {\n for (let y = x + 1, height = bitMatrix.getHeight(); y < height; y++) {\n if (bitMatrix.get(x, y) !== bitMatrix.get(y, x)) {\n bitMatrix.flip(y, x);\n bitMatrix.flip(x, y);\n }\n }\n }\n }\n\n}\n","import ECB from './ECB';\n\n/**\n *Encapsulates a set of error-correction blocks in one symbol version. Most versions will\n * use blocks of differing sizes within one version, so, this encapsulates the parameters for\n * each set of blocks. It also holds the number of error-correction codewords per block since it\n * will be the same across all blocks within one version.
\n */\nexport default class ECBlocks {\n private ecBlocks: ECB[];\n\n public constructor(private ecCodewordsPerBlock: number /*int*/, ...ecBlocks: ECB[]) {\n this.ecBlocks = ecBlocks;\n }\n\n public getECCodewordsPerBlock(): number /*int*/ {\n return this.ecCodewordsPerBlock;\n }\n\n public getNumBlocks(): number /*int*/ {\n let total = 0;\n const ecBlocks = this.ecBlocks;\n for (const ecBlock of ecBlocks) {\n total += ecBlock.getCount();\n }\n return total;\n }\n\n public getTotalECCodewords(): number /*int*/ {\n return this.ecCodewordsPerBlock * this.getNumBlocks();\n }\n\n public getECBlocks(): ECB[] {\n return this.ecBlocks;\n }\n}\n","/**\n *Encapsulates the parameters for one error-correction block in one symbol version.\n * This includes the number of data codewords, and the number of times a block with these\n * parameters is used consecutively in the QR code version's format.
\n */\nexport default class ECB {\n private count: number; /*int*/\n private dataCodewords: number; /*int*/\n\n public constructor(count: number /*int*/, dataCodewords: number /*int*/) {\n this.count = count;\n this.dataCodewords = dataCodewords;\n }\n\n public getCount(): number /*int*/ {\n return this.count;\n }\n\n public getDataCodewords(): number /*int*/ {\n return this.dataCodewords;\n }\n}\n","/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/*namespace com.google.zxing.qrcode.decoder {*/\n\nimport BitMatrix from '../../common/BitMatrix';\n\nexport enum DataMaskValues {\n DATA_MASK_000,\n DATA_MASK_001,\n DATA_MASK_010,\n DATA_MASK_011,\n DATA_MASK_100,\n DATA_MASK_101,\n DATA_MASK_110,\n DATA_MASK_111\n}\n\n/**\n *Encapsulates data masks for the data bits in a QR code, per ISO 18004:2006 6.8. Implementations\n * of this class can un-mask a raw BitMatrix. For simplicity, they will unmask the entire BitMatrix,\n * including areas used for finder patterns, timing patterns, etc. These areas should be unused\n * after the point they are unmasked anyway.
\n *\n *Note that the diagram in section 6.8.1 is misleading since it indicates that i is column position\n * and j is row position. In fact, as the text says, i is row position and j is column position.
\n *\n * @author Sean Owen\n */\nexport default class DataMask {\n\n // See ISO 18004:2006 6.8.1\n\n public constructor(private value: DataMaskValues, private isMasked: (i: number, j: number) => boolean) {\n }\n\n public static values = new MapImplementations of this method reverse the data masking process applied to a QR Code and\n * make its bits ready to read.
\n *\n * @param bits representation of QR Code bits\n * @param dimension dimension of QR Code, represented by bits, being unmasked\n */\n public unmaskBitMatrix(bits: BitMatrix, dimension: number /*int*/): void {\n for (let i = 0; i < dimension; i++) {\n for (let j = 0; j < dimension; j++) {\n if (this.isMasked(i, j)) {\n bits.flip(j, i);\n }\n }\n }\n }\n\n // abstract boolean isMasked(i: number /*int*/, j: number /*int*/);\n\n}\n","/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/*namespace com.google.zxing.qrcode.decoder {*/\n\nimport Version from './Version';\nimport ECBlocks from './ECBlocks';\nimport ECB from './ECB';\nimport ErrorCorrectionLevel from './ErrorCorrectionLevel';\n\nimport IllegalArgumentException from '../../IllegalArgumentException';\n\n/**\n *Encapsulates a block of data within a QR Code. QR Codes may split their data into\n * multiple blocks, each of which is a unit of data and error-correction codewords. Each\n * is represented by an instance of this class.
\n *\n * @author Sean Owen\n */\nexport default class DataBlock {\n\n private constructor(private numDataCodewords: number /*int*/, private codewords: Uint8Array) { }\n\n /**\n *When QR Codes use multiple data blocks, they are actually interleaved.\n * That is, the first byte of data block 1 to n is written, then the second bytes, and so on. This\n * method will separate the data into original blocks.
\n *\n * @param rawCodewords bytes as read directly from the QR Code\n * @param version version of the QR Code\n * @param ecLevel error-correction level of the QR Code\n * @return DataBlocks containing original bytes, \"de-interleaved\" from representation in the\n * QR Code\n */\n public static getDataBlocks(rawCodewords: Uint8Array,\n version: Version,\n ecLevel: ErrorCorrectionLevel): DataBlock[] {\n\n if (rawCodewords.length !== version.getTotalCodewords()) {\n throw new IllegalArgumentException();\n }\n\n // Figure out the number and size of data blocks used by this version and\n // error correction level\n const ecBlocks: ECBlocks = version.getECBlocksForLevel(ecLevel);\n\n // First count the total number of data blocks\n let totalBlocks = 0;\n const ecBlockArray: ECB[] = ecBlocks.getECBlocks();\n for (const ecBlock of ecBlockArray) {\n totalBlocks += ecBlock.getCount();\n }\n\n // Now establish DataBlocks of the appropriate size and number of data codewords\n const result = new ArrayQR Codes can encode text as bits in one of several modes, and can use multiple modes\n * in one QR Code. This class decodes the bits back into text.
\n *\n *See ISO 18004:2006, 6.4.3 - 6.4.7
\n *\n * @author Sean Owen\n */\nexport default class DecodedBitStreamParser {\n\n /**\n * See ISO 18004:2006, 6.4.4 Table 5\n */\n private static ALPHANUMERIC_CHARS =\n '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:';\n private static GB2312_SUBSET = 1;\n\n public static decode(bytes: Uint8Array,\n version: Version,\n ecLevel: ErrorCorrectionLevel,\n hints: MapEncapsulates logic that can detect a QR Code in an image, even if the QR Code\n * is rotated or skewed, or partially obscured.
\n *\n * @author Sean Owen\n */\nexport default class Detector {\n\n private resultPointCallback: ResultPointCallback;\n\n public constructor(private image: BitMatrix) { }\n\n protected getImage(): BitMatrix {\n return this.image;\n }\n\n protected getResultPointCallback(): ResultPointCallback {\n return this.resultPointCallback;\n }\n\n /**\n *Detects a QR Code in an image.
\n *\n * @return {@link DetectorResult} encapsulating results of detecting a QR Code\n * @throws NotFoundException if QR Code cannot be found\n * @throws FormatException if a QR Code cannot be decoded\n */\n // public detect(): DetectorResult /*throws NotFoundException, FormatException*/ {\n // return detect(null)\n // }\n\n /**\n *Detects a QR Code in an image.
\n *\n * @param hints optional hints to detector\n * @return {@link DetectorResult} encapsulating results of detecting a QR Code\n * @throws NotFoundException if QR Code cannot be found\n * @throws FormatException if a QR Code cannot be decoded\n */\n public detect(hints: MapComputes the dimension (number of modules on a size) of the QR Code based on the position\n * of the finder patterns and estimated module size.
\n */\n private static computeDimension(topLeft: ResultPoint,\n topRight: ResultPoint,\n bottomLeft: ResultPoint,\n moduleSize: number/*float*/): number /*int*/ /*throws NotFoundException*/ {\n const tltrCentersDimension = MathUtils.round(ResultPoint.distance(topLeft, topRight) / moduleSize);\n const tlblCentersDimension = MathUtils.round(ResultPoint.distance(topLeft, bottomLeft) / moduleSize);\n let dimension = Math.floor((tltrCentersDimension + tlblCentersDimension) / 2) + 7;\n switch (dimension & 0x03) { // mod 4\n case 0:\n dimension++;\n break;\n // 1? do nothing\n case 2:\n dimension--;\n break;\n case 3:\n throw new NotFoundException('Dimensions could be not found.');\n }\n return dimension;\n }\n\n /**\n *Computes an average estimated module size based on estimated derived from the positions\n * of the three finder patterns.
\n *\n * @param topLeft detected top-left finder pattern center\n * @param topRight detected top-right finder pattern center\n * @param bottomLeft detected bottom-left finder pattern center\n * @return estimated module size\n */\n protected calculateModuleSize(topLeft: ResultPoint,\n topRight: ResultPoint,\n bottomLeft: ResultPoint): number/*float*/ {\n // Take the average\n return (this.calculateModuleSizeOneWay(topLeft, topRight) +\n this.calculateModuleSizeOneWay(topLeft, bottomLeft)) / 2.0;\n }\n\n /**\n *Estimates module size based on two finder patterns -- it uses\n * {@link #sizeOfBlackWhiteBlackRunBothWays(int, int, int, int)} to figure the\n * width of each, measuring along the axis between their centers.
\n */\n private calculateModuleSizeOneWay(pattern: ResultPoint, otherPattern: ResultPoint): number/*float*/ {\n const moduleSizeEst1: number /*float*/ = this.sizeOfBlackWhiteBlackRunBothWays(/*(int) */Math.floor(pattern.getX()),\n /*(int) */Math.floor(pattern.getY()),\n /*(int) */Math.floor(otherPattern.getX()),\n /*(int) */Math.floor(otherPattern.getY()));\n const moduleSizeEst2: number /*float*/ = this.sizeOfBlackWhiteBlackRunBothWays(/*(int) */Math.floor(otherPattern.getX()),\n /*(int) */Math.floor(otherPattern.getY()),\n /*(int) */Math.floor(pattern.getX()),\n /*(int) */Math.floor(pattern.getY()));\n if (isNaN(moduleSizeEst1)) {\n return moduleSizeEst2 / 7.0;\n }\n if (isNaN(moduleSizeEst2)) {\n return moduleSizeEst1 / 7.0;\n }\n // Average them, and divide by 7 since we've counted the width of 3 black modules,\n // and 1 white and 1 black module on either side. Ergo, divide sum by 14.\n return (moduleSizeEst1 + moduleSizeEst2) / 14.0;\n }\n\n /**\n * See {@link #sizeOfBlackWhiteBlackRun(int, int, int, int)}; computes the total width of\n * a finder pattern by looking for a black-white-black run from the center in the direction\n * of another point (another finder pattern center), and in the opposite direction too.\n */\n private sizeOfBlackWhiteBlackRunBothWays(fromX: number /*int*/, fromY: number /*int*/, toX: number /*int*/, toY: number /*int*/): number/*float*/ {\n\n let result: number /*float*/ = this.sizeOfBlackWhiteBlackRun(fromX, fromY, toX, toY);\n\n // Now count other way -- don't run off image though of course\n let scale: number /*float*/ = 1.0;\n let otherToX = fromX - (toX - fromX);\n if (otherToX < 0) {\n scale = fromX / /*(float) */(fromX - otherToX);\n otherToX = 0;\n } else if (otherToX >= this.image.getWidth()) {\n scale = (this.image.getWidth() - 1 - fromX) / /*(float) */(otherToX - fromX);\n otherToX = this.image.getWidth() - 1;\n }\n let otherToY = /*(int) */Math.floor(fromY - (toY - fromY) * scale);\n\n scale = 1.0;\n if (otherToY < 0) {\n scale = fromY / /*(float) */(fromY - otherToY);\n otherToY = 0;\n } else if (otherToY >= this.image.getHeight()) {\n scale = (this.image.getHeight() - 1 - fromY) / /*(float) */(otherToY - fromY);\n otherToY = this.image.getHeight() - 1;\n }\n otherToX = /*(int) */Math.floor(fromX + (otherToX - fromX) * scale);\n\n result += this.sizeOfBlackWhiteBlackRun(fromX, fromY, otherToX, otherToY);\n\n // Middle pixel is double-counted this way; subtract 1\n return result - 1.0;\n }\n\n /**\n *This method traces a line from a point in the image, in the direction towards another point.\n * It begins in a black region, and keeps going until it finds white, then black, then white again.\n * It reports the distance from the start to this point.
\n *\n *This is used when figuring out how wide a finder pattern is, when the finder pattern\n * may be skewed or rotated.
\n */\n private sizeOfBlackWhiteBlackRun(fromX: number /*int*/, fromY: number /*int*/, toX: number /*int*/, toY: number /*int*/): number/*float*/ {\n // Mild variant of Bresenham's algorithm\n // see http://en.wikipedia.org/wiki/Bresenham's_line_algorithm\n const steep: boolean = Math.abs(toY - fromY) > Math.abs(toX - fromX);\n if (steep) {\n let temp = fromX;\n fromX = fromY;\n fromY = temp;\n temp = toX;\n toX = toY;\n toY = temp;\n }\n\n const dx = Math.abs(toX - fromX);\n const dy = Math.abs(toY - fromY);\n let error = -dx / 2;\n const xstep = fromX < toX ? 1 : -1;\n const ystep = fromY < toY ? 1 : -1;\n\n // In black pixels, looking for white, first or second time.\n let state = 0;\n // Loop up until x == toX, but not beyond\n const xLimit = toX + xstep;\n for (let x = fromX, y = fromY; x !== xLimit; x += xstep) {\n const realX = steep ? y : x;\n const realY = steep ? x : y;\n\n // Does current pixel mean we have moved white to black or vice versa?\n // Scanning black in state 0,2 and white in state 1, so if we find the wrong\n // color, advance to next state or end if we are in state 2 already\n if ((state === 1) === this.image.get(realX, realY)) {\n if (state === 2) {\n return MathUtils.distance(x, y, fromX, fromY);\n }\n state++;\n }\n\n error += dy;\n if (error > 0) {\n if (y === toY) {\n break;\n }\n y += ystep;\n error -= dx;\n }\n }\n // Found black-white-black; give the benefit of the doubt that the next pixel outside the image\n // is \"white\" so this last point at (toX+xStep,toY) is the right ending. This is really a\n // small approximation; (toX+xStep,toY+yStep) might be really correct. Ignore this.\n if (state === 2) {\n return MathUtils.distance(toX + xstep, toY, fromX, fromY);\n }\n // else we didn't find even black-white-black; no estimate is really possible\n return NaN;\n }\n\n /**\n *Attempts to locate an alignment pattern in a limited region of the image, which is\n * guessed to contain it. This method uses {@link AlignmentPattern}.
\n *\n * @param overallEstModuleSize estimated module size so far\n * @param estAlignmentX x coordinate of center of area probably containing alignment pattern\n * @param estAlignmentY y coordinate of above\n * @param allowanceFactor number of pixels in all directions to search from the center\n * @return {@link AlignmentPattern} if found, or null otherwise\n * @throws NotFoundException if an unexpected error occurs during detection\n */\n protected findAlignmentInRegion(overallEstModuleSize: number/*float*/,\n estAlignmentX: number /*int*/,\n estAlignmentY: number /*int*/,\n allowanceFactor: number/*float*/): AlignmentPattern {\n // Look for an alignment pattern (3 modules in size) around where it\n // should be\n const allowance = /*(int) */Math.floor(allowanceFactor * overallEstModuleSize);\n const alignmentAreaLeftX = Math.max(0, estAlignmentX - allowance);\n const alignmentAreaRightX = Math.min(this.image.getWidth() - 1, estAlignmentX + allowance);\n if (alignmentAreaRightX - alignmentAreaLeftX < overallEstModuleSize * 3) {\n throw new NotFoundException('Alignment top exceeds estimated module size.');\n }\n\n const alignmentAreaTopY = Math.max(0, estAlignmentY - allowance);\n const alignmentAreaBottomY = Math.min(this.image.getHeight() - 1, estAlignmentY + allowance);\n if (alignmentAreaBottomY - alignmentAreaTopY < overallEstModuleSize * 3) {\n throw new NotFoundException('Alignment bottom exceeds estimated module size.');\n }\n\n const alignmentFinder = new AlignmentPatternFinder(\n this.image,\n alignmentAreaLeftX,\n alignmentAreaTopY,\n alignmentAreaRightX - alignmentAreaLeftX,\n alignmentAreaBottomY - alignmentAreaTopY,\n overallEstModuleSize,\n this.resultPointCallback\n );\n\n return alignmentFinder.find();\n }\n\n}\n","/*\n * Copyright 2007 ZXing authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/*namespace com.google.zxing.qrcode.detector {*/\n\nimport DecodeHintType from '../../DecodeHintType';\nimport ResultPoint from '../../ResultPoint';\nimport ResultPointCallback from '../../ResultPointCallback';\nimport BitMatrix from '../../common/BitMatrix';\nimport FinderPattern from './FinderPattern';\nimport FinderPatternInfo from './FinderPatternInfo';\n\nimport NotFoundException from '../../NotFoundException';\n\nimport { float } from '../../../customTypings';\n\n/*import java.io.Serializable;*/\n/*import java.util.ArrayList;*/\n/*import java.util.Collections;*/\n/*import java.util.Comparator;*/\n/*import java.util.List;*/\n/*import java.util.Map;*/\n\n/**\n *This class attempts to find finder patterns in a QR Code. Finder patterns are the square\n * markers at three corners of a QR Code.
\n *\n *This class is thread-safe but not reentrant. Each thread must allocate its own object.\n *\n * @author Sean Owen\n */\nexport default class FinderPatternFinder {\n\n private static CENTER_QUORUM = 2;\n protected static MIN_SKIP = 3; // 1 pixel/module times 3 modules/center\n protected static MAX_MODULES = 57; // support up to version 10 for mobile clients\n\n private possibleCenters: FinderPattern[];\n private hasSkipped: boolean;\n private crossCheckStateCount: Int32Array;\n\n /**\n *
Creates a finder that will search the image for three finder patterns.
\n *\n * @param image image to search\n */\n // public constructor(image: BitMatrix) {\n // this(image, null)\n // }\n\n public constructor(private image: BitMatrix, private resultPointCallback: ResultPointCallback) {\n this.possibleCenters = [];\n this.crossCheckStateCount = new Int32Array(5);\n this.resultPointCallback = resultPointCallback;\n }\n\n protected getImage(): BitMatrix {\n return this.image;\n }\n\n protected getPossibleCenters(): FinderPattern[] {\n return this.possibleCenters;\n }\n\n public find(hints: MapAfter a horizontal scan finds a potential finder pattern, this method\n * \"cross-checks\" by scanning down vertically through the center of the possible\n * finder pattern to see if the same proportion is detected.
\n *\n * @param startI row where a finder pattern was detected\n * @param centerJ center of the section that appears to cross a finder pattern\n * @param maxCount maximum reasonable number of modules that should be\n * observed in any reading state, based on the results of the horizontal scan\n * @return vertical center of finder pattern, or {@link Float#NaN} if not found\n */\n private crossCheckVertical(startI: number /*int*/, centerJ: number /*int*/, maxCount: number /*int*/,\n originalStateCountTotal: number /*int*/): number/*float*/ {\n const image: BitMatrix = this.image;\n\n const maxI = image.getHeight();\n const stateCount: Int32Array = this.getCrossCheckStateCount();\n\n // Start counting up from center\n let i = startI;\n while (i >= 0 && image.get(centerJ, i)) {\n stateCount[2]++;\n i--;\n }\n if (i < 0) {\n return NaN;\n }\n while (i >= 0 && !image.get(centerJ, i) && stateCount[1] <= maxCount) {\n stateCount[1]++;\n i--;\n }\n // If already too many modules in this state or ran off the edge:\n if (i < 0 || stateCount[1] > maxCount) {\n return NaN;\n }\n while (i >= 0 && image.get(centerJ, i) && stateCount[0] <= maxCount) {\n stateCount[0]++;\n i--;\n }\n if (stateCount[0] > maxCount) {\n return NaN;\n }\n\n // Now also count down from center\n i = startI + 1;\n while (i < maxI && image.get(centerJ, i)) {\n stateCount[2]++;\n i++;\n }\n if (i === maxI) {\n return NaN;\n }\n while (i < maxI && !image.get(centerJ, i) && stateCount[3] < maxCount) {\n stateCount[3]++;\n i++;\n }\n if (i === maxI || stateCount[3] >= maxCount) {\n return NaN;\n }\n while (i < maxI && image.get(centerJ, i) && stateCount[4] < maxCount) {\n stateCount[4]++;\n i++;\n }\n if (stateCount[4] >= maxCount) {\n return NaN;\n }\n\n // If we found a finder-pattern-like section, but its size is more than 40% different than\n // the original, assume it's a false positive\n const stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2] + stateCount[3] +\n stateCount[4];\n if (5 * Math.abs(stateCountTotal - originalStateCountTotal) >= 2 * originalStateCountTotal) {\n return NaN;\n }\n\n return FinderPatternFinder.foundPatternCross(stateCount) ? FinderPatternFinder.centerFromEnd(stateCount, i) : NaN;\n }\n\n /**\n *Like {@link #crossCheckVertical(int, int, int, int)}, and in fact is basically identical,\n * except it reads horizontally instead of vertically. This is used to cross-cross\n * check a vertical cross check and locate the real center of the alignment pattern.
\n */\n private crossCheckHorizontal(startJ: number /*int*/, centerI: number /*int*/, maxCount: number /*int*/,\n originalStateCountTotal: number /*int*/): number/*float*/ {\n const image: BitMatrix = this.image;\n\n const maxJ = image.getWidth();\n const stateCount: Int32Array = this.getCrossCheckStateCount();\n\n let j = startJ;\n while (j >= 0 && image.get(j, centerI)) {\n stateCount[2]++;\n j--;\n }\n if (j < 0) {\n return NaN;\n }\n while (j >= 0 && !image.get(j, centerI) && stateCount[1] <= maxCount) {\n stateCount[1]++;\n j--;\n }\n if (j < 0 || stateCount[1] > maxCount) {\n return NaN;\n }\n while (j >= 0 && image.get(j, centerI) && stateCount[0] <= maxCount) {\n stateCount[0]++;\n j--;\n }\n if (stateCount[0] > maxCount) {\n return NaN;\n }\n\n j = startJ + 1;\n while (j < maxJ && image.get(j, centerI)) {\n stateCount[2]++;\n j++;\n }\n if (j === maxJ) {\n return NaN;\n }\n while (j < maxJ && !image.get(j, centerI) && stateCount[3] < maxCount) {\n stateCount[3]++;\n j++;\n }\n if (j === maxJ || stateCount[3] >= maxCount) {\n return NaN;\n }\n while (j < maxJ && image.get(j, centerI) && stateCount[4] < maxCount) {\n stateCount[4]++;\n j++;\n }\n if (stateCount[4] >= maxCount) {\n return NaN;\n }\n\n // If we found a finder-pattern-like section, but its size is significantly different than\n // the original, assume it's a false positive\n const stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2] + stateCount[3] +\n stateCount[4];\n if (5 * Math.abs(stateCountTotal - originalStateCountTotal) >= originalStateCountTotal) {\n return NaN;\n }\n\n return FinderPatternFinder.foundPatternCross(stateCount) ? FinderPatternFinder.centerFromEnd(stateCount, j) : NaN;\n }\n\n /**\n *This is called when a horizontal scan finds a possible alignment pattern. It will\n * cross check with a vertical scan, and if successful, will, ah, cross-cross-check\n * with another horizontal scan. This is needed primarily to locate the real horizontal\n * center of the pattern in cases of extreme skew.\n * And then we cross-cross-cross check with another diagonal scan.
\n *\n *If that succeeds the finder pattern location is added to a list that tracks\n * the number of times each location has been nearly-matched as a finder pattern.\n * Each additional find is more evidence that the location is in fact a finder\n * pattern center\n *\n * @param stateCount reading state module counts from horizontal scan\n * @param i row where finder pattern may be found\n * @param j end of possible finder pattern in row\n * @param pureBarcode true if in \"pure barcode\" mode\n * @return true if a finder pattern candidate was found this time\n */\n protected handlePossibleCenter(stateCount: Int32Array, i: number /*int*/, j: number /*int*/, pureBarcode: boolean): boolean {\n const stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2] + stateCount[3] +\n stateCount[4];\n let centerJ: number /*float*/ = FinderPatternFinder.centerFromEnd(stateCount, j);\n let centerI: number /*float*/ = this.crossCheckVertical(i, /*(int) */Math.floor(centerJ), stateCount[2], stateCountTotal);\n if (!isNaN(centerI)) {\n // Re-cross check\n centerJ = this.crossCheckHorizontal(/*(int) */Math.floor(centerJ), /*(int) */Math.floor(centerI), stateCount[2], stateCountTotal);\n if (!isNaN(centerJ) &&\n (!pureBarcode || this.crossCheckDiagonal(/*(int) */Math.floor(centerI), /*(int) */Math.floor(centerJ), stateCount[2], stateCountTotal))) {\n const estimatedModuleSize: number /*float*/ = stateCountTotal / 7.0;\n let found: boolean = false;\n const possibleCenters = this.possibleCenters;\n for (let index = 0, length = possibleCenters.length; index < length; index++) {\n const center: FinderPattern = possibleCenters[index];\n // Look for about the same center and module size:\n if (center.aboutEquals(estimatedModuleSize, centerI, centerJ)) {\n possibleCenters[index] = center.combineEstimate(centerI, centerJ, estimatedModuleSize);\n found = true;\n break;\n }\n }\n if (!found) {\n const point: FinderPattern = new FinderPattern(centerJ, centerI, estimatedModuleSize);\n possibleCenters.push(point);\n if (this.resultPointCallback !== null && this.resultPointCallback !== undefined) {\n this.resultPointCallback.foundPossibleResultPoint(point);\n }\n }\n return true;\n }\n }\n return false;\n }\n\n /**\n * @return number of rows we could safely skip during scanning, based on the first\n * two finder patterns that have been located. In some cases their position will\n * allow us to infer that the third pattern must lie below a certain point farther\n * down in the image.\n */\n private findRowSkip(): number /*int*/ {\n const max = this.possibleCenters.length;\n if (max <= 1) {\n return 0;\n }\n let firstConfirmedCenter: ResultPoint = null;\n for (const center of this.possibleCenters) {\n if (center.getCount() >= FinderPatternFinder.CENTER_QUORUM) {\n if (firstConfirmedCenter == null) {\n firstConfirmedCenter = center;\n } else {\n // We have two confirmed centers\n // How far down can we skip before resuming looking for the next\n // pattern? In the worst case, only the difference between the\n // difference in the x / y coordinates of the two centers.\n // This is the case where you find top left last.\n this.hasSkipped = true;\n return /*(int) */Math.floor((Math.abs(firstConfirmedCenter.getX() - center.getX()) -\n Math.abs(firstConfirmedCenter.getY() - center.getY())) / 2);\n }\n }\n }\n return 0;\n }\n\n /**\n * @return true iff we have found at least 3 finder patterns that have been detected\n * at least {@link #CENTER_QUORUM} times each, and, the estimated module size of the\n * candidates is \"pretty similar\"\n */\n private haveMultiplyConfirmedCenters(): boolean {\n let confirmedCount = 0;\n let totalModuleSize: number /*float*/ = 0.0;\n const max = this.possibleCenters.length;\n for (const pattern of this.possibleCenters) {\n if (pattern.getCount() >= FinderPatternFinder.CENTER_QUORUM) {\n confirmedCount++;\n totalModuleSize += pattern.getEstimatedModuleSize();\n }\n }\n if (confirmedCount < 3) {\n return false;\n }\n // OK, we have at least 3 confirmed centers, but, it's possible that one is a \"false positive\"\n // and that we need to keep looking. We detect this by asking if the estimated module sizes\n // vary too much. We arbitrarily say that when the total deviation from average exceeds\n // 5% of the total module size estimates, it's too much.\n const average: number /*float*/ = totalModuleSize / max;\n let totalDeviation: number /*float*/ = 0.0;\n for (const pattern of this.possibleCenters) {\n totalDeviation += Math.abs(pattern.getEstimatedModuleSize() - average);\n }\n return totalDeviation <= 0.05 * totalModuleSize;\n }\n\n /**\n * @return the 3 best {@link FinderPattern}s from our list of candidates. The \"best\" are\n * those that have been detected at least {@link #CENTER_QUORUM} times, and whose module\n * size differs from the average among those patterns the least\n * @throws NotFoundException if 3 such finder patterns do not exist\n */\n private selectBestPatterns(): FinderPattern[] /*throws NotFoundException */ {\n\n const startSize = this.possibleCenters.length;\n if (startSize < 3) {\n // Couldn't find enough finder patterns\n throw new NotFoundException();\n }\n\n const possibleCenters = this.possibleCenters;\n\n let average: float;\n // Filter outlier possibilities whose module size is too different\n if (startSize > 3) {\n // But we can only afford to do so if we have at least 4 possibilities to choose from\n let totalModuleSize: float = 0.0;\n let square: float = 0.0;\n for (const center of this.possibleCenters) {\n const size: float = center.getEstimatedModuleSize();\n totalModuleSize += size;\n square += size * size;\n }\n average = totalModuleSize / startSize;\n let stdDev: float = Orders by furthest from average Orders by {@link FinderPattern#getCount()}, descending. Encapsulates a finder pattern, which are the three square patterns found in\n * the corners of QR Codes. It also encapsulates a count of similar finder patterns,\n * as a convenience to the finder's bookkeeping. Determines if this finder pattern \"about equals\" a finder pattern at the stated\n * position and size -- meaning, it is at nearly the same center with nearly the same size. Encapsulates information about finder patterns in an image, including the location of\n * the three finder patterns, and their estimated module size. This class attempts to find alignment patterns in a QR Code. Alignment patterns look like finder\n * patterns but are smaller and appear at regular intervals throughout the image. At the moment this only looks for the bottom-right alignment pattern. This is mostly a simplified copy of {@link FinderPatternFinder}. It is copied,\n * pasted and stripped down here for maximum performance but does unfortunately duplicate\n * some code. This class is thread-safe but not reentrant. Each thread must allocate its own object. Creates a finder that will look in a portion of the whole image. This method attempts to find the bottom-right alignment pattern in the image. It is a bit messy since\n * it's pretty performance-critical and so is written to be fast foremost. After a horizontal scan finds a potential alignment pattern, this method\n * \"cross-checks\" by scanning down vertically through the center of the possible\n * alignment pattern to see if the same proportion is detected. This is called when a horizontal scan finds a possible alignment pattern. It will\n * cross check with a vertical scan, and if successful, will see if this pattern had been\n * found on a previous horizontal scan. If so, we consider it confirmed and conclude we have\n * found the alignment pattern. Encapsulates an alignment pattern, which are the smaller square patterns found in\n * all but the simplest QR Codes. Determines if this alignment pattern \"about equals\" an alignment pattern at the stated\n * position and size -- meaning, it is at nearly the same center with nearly the same size. Encapsulates logic that can detect a PDF417 Code in an image, even if the\n * PDF417 Code is rotated or skewed, or partially obscured. Detects a PDF417 Code in an image. Only checks 0 and 180 degree rotations. Given data and error-correction codewords received, possibly corrupted by errors, attempts to\n * correct the errors in-place. PDF417 error correction implementation. This example\n * is quite useful in understanding the algorithm. A field based on powers of a generator integer, modulo some modulus. This class contains the methods for decoding the PDF417 codewords. \n * Closing a ByteArrayOutputStream has no effect. The methods in\n * this class can be called after the stream has been closed without\n * generating an IOException.\n *\n * @author Arthur van Hoff\n * @since JDK1.0\n */\n\nexport default /*public*/ class ByteArrayOutputStream extends OutputStream {\n\n /**\n * The buffer where data is stored.\n */\n protected buf: Uint8Array;\n\n /**\n * The number of valid bytes in the buffer.\n */\n protected count: int = 0;\n\n /**\n * Creates a new byte array output stream. The buffer capacity is\n * initially 32 bytes, though its size increases if necessary.\n */\n // public constructor() {\n // this(32);\n // }\n\n /**\n * Creates a new byte array output stream, with a buffer capacity of\n * the specified size, in bytes.\n *\n * @param size the initial size.\n * @exception IllegalArgumentException if size is negative.\n */\n public constructor(size: int = 32) {\n super();\n if (size < 0) {\n throw new IllegalArgumentException('Negative initial size: '\n + size);\n }\n this.buf = new Uint8Array(size);\n }\n\n /**\n * Increases the capacity if necessary to ensure that it can hold\n * at least the number of elements specified by the minimum\n * capacity argument.\n *\n * @param minCapacity the desired minimum capacity\n * @throws OutOfMemoryError if {@code minCapacity < 0}. This is\n * interpreted as a request for the unsatisfiably large capacity\n * {@code (long) Integer.MAX_VALUE + (minCapacity - Integer.MAX_VALUE)}.\n */\n private ensureCapacity(minCapacity: int): void {\n // overflow-conscious code\n if (minCapacity - this.buf.length > 0)\n this.grow(minCapacity);\n }\n\n /**\n * Increases the capacity to ensure that it can hold at least the\n * number of elements specified by the minimum capacity argument.\n *\n * @param minCapacity the desired minimum capacity\n */\n private grow(minCapacity: int): void {\n // overflow-conscious code\n let oldCapacity: int = this.buf.length;\n let newCapacity: int = oldCapacity << 1;\n if (newCapacity - minCapacity < 0)\n newCapacity = minCapacity;\n if (newCapacity < 0) {\n if (minCapacity < 0) // overflow\n throw new OutOfMemoryError();\n newCapacity = Integer.MAX_VALUE;\n }\n this.buf = Arrays.copyOfUint8Array(this.buf, newCapacity);\n }\n\n /**\n * Writes the specified byte to this byte array output stream.\n *\n * @param b the byte to be written.\n */\n public /*synchronized*/ write(b: int): void {\n this.ensureCapacity(this.count + 1);\n this.buf[this.count] = /*(byte)*/ b;\n this.count += 1;\n }\n\n /**\n * Writes This method always replaces malformed-input and unmappable-character\n * sequences with the default replacement string for the platform's\n * default character set. The {@linkplain java.nio.charset.CharsetDecoder}\n * class should be used when more control over the decoding process is\n * required.\n *\n * @return String decoded from the buffer's contents.\n * @since JDK1.1\n */\n public /*synchronized*/ toString_void(): string {\n return new String(this.buf/*, 0, this.count*/).toString();\n }\n\n /**\n * Converts the buffer's contents into a string by decoding the bytes using\n * the specified {@link java.nio.charset.Charset charsetName}. The length of\n * the new String is a function of the charset, and hence may not be\n * equal to the length of the byte array.\n *\n * This method always replaces malformed-input and unmappable-character\n * sequences with this charset's default replacement string. The {@link\n * java.nio.charset.CharsetDecoder} class should be used when more control\n * over the decoding process is required.\n *\n * @param charsetName the name of a supported\n * {@linkplain java.nio.charset.Charset charset \n *\n * @throws IOException\n */\n public close(): void {\n }\n\n}\n","import IndexOutOfBoundsException from '../IndexOutOfBoundsException';\nimport NullPointerException from '../NullPointerException';\n\n/*\n * Copyright (c) 1994, 2004, Oracle and/or its affiliates. All rights reserved.\n * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.\n *\n * This code is free software; you can redistribute it and/or modify it\n * under the terms of the GNU General Public License version 2 only, as\n * published by the Free Software Foundation. Oracle designates this\n * particular file as subject to the \"Classpath\" exception as provided\n * by Oracle in the LICENSE file that accompanied this code.\n *\n * This code is distributed in the hope that it will be useful, but WITHOUT\n * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or\n * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License\n * version 2 for more details (a copy is included in the LICENSE file that\n * accompanied this code).\n *\n * You should have received a copy of the GNU General Public License version\n * 2 along with this work; if not, write to the Free Software Foundation,\n * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.\n *\n * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA\n * or visit www.oracle.com if you need additional information or have any\n * questions.\n */\n\n// package java.io;\n\n/**\n * This abstract class is the superclass of all classes representing\n * an output stream of bytes. An output stream accepts output bytes\n * and sends them to some sink.\n * \n * Applications that need to define a subclass of\n * \n * Subclasses of \n * The \n * If \n * If \n * If the intended destination of this stream is an abstraction provided by\n * the underlying operating system, for example a file, then flushing the\n * stream guarantees only that bytes previously written to the stream are\n * passed to the operating system for writing; it does not guarantee that\n * they are actually written to a physical device such as a disk drive.\n * \n * The \n * The toByteArray() and\n * toString().\n * len bytes from the specified byte array\n * starting at offset off to this byte array output stream.\n *\n * @param b the data.\n * @param off the start offset in the data.\n * @param len the number of bytes to write.\n */\n public /*synchronized*/ writeBytesOffset(b: Uint8Array, off: int, len: int): void {\n if ((off < 0) || (off > b.length) || (len < 0) ||\n ((off + len) - b.length > 0)) {\n throw new IndexOutOfBoundsException();\n }\n this.ensureCapacity(this.count + len);\n System.arraycopy(b, off, this.buf, this.count, len);\n this.count += len;\n }\n\n /**\n * Writes the complete contents of this byte array output stream to\n * the specified output stream argument, as if by calling the output\n * stream's write method using out.write(buf, 0, count).\n *\n * @param out the output stream to which to write the data.\n * @exception IOException if an I/O error occurs.\n */\n public /*synchronized*/ writeTo(out: OutputStream): void {\n out.writeBytesOffset(this.buf, 0, this.count);\n }\n\n /**\n * Resets the count field of this byte array output\n * stream to zero, so that all currently accumulated output in the\n * output stream is discarded. The output stream can be used again,\n * reusing the already allocated buffer space.\n *\n * @see java.io.ByteArrayInputStream#count\n */\n public /*synchronized*/ reset(): void {\n this.count = 0;\n }\n\n /**\n * Creates a newly allocated byte array. Its size is the current\n * size of this output stream and the valid contents of the buffer\n * have been copied into it.\n *\n * @return the current contents of this output stream, as a byte array.\n * @see java.io.ByteArrayOutputStream#size()\n */\n public /*synchronized*/ toByteArray(): Uint8Array {\n return Arrays.copyOfUint8Array(this.buf, this.count);\n }\n\n /**\n * Returns the current size of the buffer.\n *\n * @return the value of the count field, which is the number\n * of valid bytes in this output stream.\n * @see java.io.ByteArrayOutputStream#count\n */\n public /*synchronized*/ size(): int {\n return this.count;\n }\n\n toString(param?: number | string) {\n if (!param) {\n return this.toString_void();\n }\n if (typeof param === 'string') {\n return this.toString_string(param);\n }\n return this.toString_number(param);\n }\n\n /**\n * Converts the buffer's contents into a string decoding bytes using the\n * platform's default character set. The length of the new String\n * is a function of the character set, and hence may not be equal to the\n * size of the buffer.\n *\n * }\n * @return String decoded from the buffer's contents.\n * @exception UnsupportedEncodingException\n * If the named charset is not supported\n * @since JDK1.1\n */\n public /*synchronized*/ toString_string(charsetName: string): string {\n return new String(this.buf/*, 0, this.count, charsetName*/).toString();\n }\n\n /**\n * Creates a newly allocated string. Its size is the current size of\n * the output stream and the valid contents of the buffer have been\n * copied into it. Each character c in the resulting string is\n * constructed from the corresponding element b in the byte\n * array such that:\n *
\n *\n * @deprecated This method does not properly convert bytes into characters.\n * As of JDK 1.1, the preferred way to do this is via the\n * \n * c == (char)(((hibyte & 0xff) << 8) | (b & 0xff))\n *
toString(String enc) method, which takes an encoding-name\n * argument, or the toString() method, which uses the\n * platform's default character encoding.\n *\n * @param hibyte the high byte of each resulting Unicode character.\n * @return the current contents of the output stream, as a string.\n * @see java.io.ByteArrayOutputStream#size()\n * @see java.io.ByteArrayOutputStream#toString(String)\n * @see java.io.ByteArrayOutputStream#toString()\n */\n // @Deprecated\n public /*synchronized*/ toString_number(hibyte: int): string {\n return new String(this.buf/*, hibyte, 0, this.count*/).toString();\n }\n\n /**\n * Closing a ByteArrayOutputStream has no effect. The methods in\n * this class can be called after the stream has been closed without\n * generating an IOException.\n * OutputStream must always provide at least a method\n * that writes one byte of output.\n *\n * @author Arthur van Hoff\n * @see java.io.BufferedOutputStream\n * @see java.io.ByteArrayOutputStream\n * @see java.io.DataOutputStream\n * @see java.io.FilterOutputStream\n * @see java.io.InputStream\n * @see java.io.OutputStream#write(int)\n * @since JDK1.0\n */\nexport default /*public*/ abstract class OutputStream /*implements Closeable, Flushable*/ {\n /**\n * Writes the specified byte to this output stream. The general\n * contract for write is that one byte is written\n * to the output stream. The byte to be written is the eight\n * low-order bits of the argument b. The 24\n * high-order bits of b are ignored.\n * OutputStream must provide an\n * implementation for this method.\n *\n * @param b the byte.\n * @exception IOException if an I/O error occurs. In particular,\n * an IOException may be thrown if the\n * output stream has been closed.\n */\n public abstract write(b: /*int*/ number): void;\n\n /**\n * Writes b.length bytes from the specified byte array\n * to this output stream. The general contract for write(b)\n * is that it should have exactly the same effect as the call\n * write(b, 0, b.length).\n *\n * @param b the data.\n * @exception IOException if an I/O error occurs.\n * @see java.io.OutputStream#write(byte[], int, int)\n */\n public writeBytes(b: Uint8Array): void {\n this.writeBytesOffset(b, 0, b.length);\n }\n\n /**\n * Writes len bytes from the specified byte array\n * starting at offset off to this output stream.\n * The general contract for write(b, off, len) is that\n * some of the bytes in the array b are written to the\n * output stream in order; element b[off] is the first\n * byte written and b[off+len-1] is the last byte written\n * by this operation.\n * write method of OutputStream calls\n * the write method of one argument on each of the bytes to be\n * written out. Subclasses are encouraged to override this method and\n * provide a more efficient implementation.\n * b is null, a\n * NullPointerException is thrown.\n * off is negative, or len is negative, or\n * off+len is greater than the length of the array\n * b, then an IndexOutOfBoundsException is thrown.\n *\n * @param b the data.\n * @param off the start offset in the data.\n * @param len the number of bytes to write.\n * @exception IOException if an I/O error occurs. In particular,\n * an IOException is thrown if the output\n * stream is closed.\n */\n public writeBytesOffset(b: Uint8Array, off: /*int*/ number, len: /*int*/ number): void {\n if (b == null) {\n throw new NullPointerException();\n } else if ((off < 0) || (off > b.length) || (len < 0) ||\n ((off + len) > b.length) || ((off + len) < 0)) {\n throw new IndexOutOfBoundsException();\n } else if (len === 0) {\n return;\n }\n for (let i = 0; i < len; i++) {\n this.write(b[off + i]);\n }\n }\n\n /**\n * Flushes this output stream and forces any buffered output bytes\n * to be written out. The general contract of flush is\n * that calling it is an indication that, if any bytes previously\n * written have been buffered by the implementation of the output\n * stream, such bytes should immediately be written to their\n * intended destination.\n * flush method of OutputStream does nothing.\n *\n * @exception IOException if an I/O error occurs.\n */\n public flush(): void {\n }\n\n /**\n * Closes this output stream and releases any system resources\n * associated with this stream. The general contract of close\n * is that it closes the output stream. A closed stream cannot perform\n * output operations and cannot be reopened.\n * close method of OutputStream does nothing.\n *\n * @exception IOException if an I/O error occurs.\n */\n public close(): void {\n }\n\n}\n","import Exception from './Exception';\n\n/**\n * Custom Error class of type Exception.\n */\nexport default class NullPointerException extends Exception {}\n","import Exception from './Exception';\n\n/**\n * Custom Error class of type Exception.\n */\nexport default class OutOfMemoryError extends Exception {}\n","import { BrowserCodeReader } from './BrowserCodeReader';\nimport PDF417Reader from '../core/pdf417/PDF417Reader';\n\n/**\n * @deprecated Moving to @zxing/browser\n *\n * QR Code reader to use from browser.\n */\nexport class BrowserPDF417Reader extends BrowserCodeReader {\n /**\n * Creates an instance of BrowserPDF417Reader.\n * @param {number} [timeBetweenScansMillis=500] the time delay between subsequent decode tries\n */\n public constructor(timeBetweenScansMillis: number = 500) {\n super(new PDF417Reader(), timeBetweenScansMillis);\n }\n}\n","import { BrowserCodeReader } from './BrowserCodeReader';\nimport QRCodeReader from '../core/qrcode/QRCodeReader';\n\n/**\n * @deprecated Moving to @zxing/browser\n *\n * QR Code reader to use from browser.\n */\nexport class BrowserQRCodeReader extends BrowserCodeReader {\n /**\n * Creates an instance of BrowserQRCodeReader.\n * @param {number} [timeBetweenScansMillis=500] the time delay between subsequent decode tries\n */\n public constructor(timeBetweenScansMillis: number = 500) {\n super(new QRCodeReader(), timeBetweenScansMillis);\n }\n}\n","import EncodeHintType from '../core/EncodeHintType';\nimport Encoder from '../core/qrcode/encoder/Encoder';\nimport QRCode from '../core/qrcode/encoder/QRCode';\nimport ErrorCorrectionLevel from '../core/qrcode/decoder/ErrorCorrectionLevel';\nimport IllegalArgumentException from '../core/IllegalArgumentException';\nimport IllegalStateException from '../core/IllegalStateException';\n\n/**\n * @deprecated Moving to @zxing/browser\n */\nclass BrowserQRCodeSvgWriter {\n\n private static readonly QUIET_ZONE_SIZE = 4;\n\n /**\n * SVG markup NameSpace\n */\n private static readonly SVG_NS = 'http://www.w3.org/2000/svg';\n\n /**\n * Writes and renders a QRCode SVG element.\n *\n * @param contents\n * @param width\n * @param height\n * @param hints\n */\n public write(\n contents: string,\n width: number,\n height: number,\n hints: Map