A simple, fast array of bits, represented compactly by an array of ints internally.
\n *\n * @author Sean Owen\n */\nvar BitArray /*implements Cloneable*/ = /** @class */ (function () {\n // public constructor() {\n // this.size = 0\n // this.bits = new Int32Array(1)\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 // For testing only\n function BitArray(size /*int*/, bits) {\n if (undefined === size) {\n this.size = 0;\n this.bits = new Int32Array(1);\n }\n else {\n this.size = size;\n if (undefined === bits || null === bits) {\n this.bits = BitArray.makeArray(size);\n }\n else {\n this.bits = bits;\n }\n }\n }\n BitArray.prototype.getSize = function () {\n return this.size;\n };\n BitArray.prototype.getSizeInBytes = function () {\n return Math.floor((this.size + 7) / 8);\n };\n BitArray.prototype.ensureCapacity = function (size /*int*/) {\n if (size > this.bits.length * 32) {\n var newBits = BitArray.makeArray(size);\n System_1.default.arraycopy(this.bits, 0, newBits, 0, this.bits.length);\n this.bits = newBits;\n }\n };\n /**\n * @param i bit to get\n * @return true iff bit i is set\n */\n BitArray.prototype.get = function (i /*int*/) {\n return (this.bits[Math.floor(i / 32)] & (1 << (i & 0x1F))) !== 0;\n };\n /**\n * Sets bit i.\n *\n * @param i bit to set\n */\n BitArray.prototype.set = function (i /*int*/) {\n this.bits[Math.floor(i / 32)] |= 1 << (i & 0x1F);\n };\n /**\n * Flips bit i.\n *\n * @param i bit to set\n */\n BitArray.prototype.flip = function (i /*int*/) {\n this.bits[Math.floor(i / 32)] ^= 1 << (i & 0x1F);\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 BitArray.prototype.getNextSet = function (from /*int*/) {\n var size = this.size;\n if (from >= size) {\n return size;\n }\n var bits = this.bits;\n var bitsOffset = Math.floor(from / 32);\n var currentBits = bits[bitsOffset];\n // mask off lesser bits first\n currentBits &= ~((1 << (from & 0x1F)) - 1);\n var length = bits.length;\n while (currentBits === 0) {\n if (++bitsOffset === length) {\n return size;\n }\n currentBits = bits[bitsOffset];\n }\n var result = (bitsOffset * 32) + Integer_1.default.numberOfTrailingZeros(currentBits);\n return result > size ? size : result;\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 BitArray.prototype.getNextUnset = function (from /*int*/) {\n var size = this.size;\n if (from >= size) {\n return size;\n }\n var bits = this.bits;\n var bitsOffset = Math.floor(from / 32);\n var currentBits = ~bits[bitsOffset];\n // mask off lesser bits first\n currentBits &= ~((1 << (from & 0x1F)) - 1);\n var length = bits.length;\n while (currentBits === 0) {\n if (++bitsOffset === length) {\n return size;\n }\n currentBits = ~bits[bitsOffset];\n }\n var result = (bitsOffset * 32) + Integer_1.default.numberOfTrailingZeros(currentBits);\n return result > size ? size : result;\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 BitArray.prototype.setBulk = function (i /*int*/, newBits /*int*/) {\n this.bits[Math.floor(i / 32)] = newBits;\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 BitArray.prototype.setRange = function (start /*int*/, end /*int*/) {\n if (end < start || start < 0 || end > this.size) {\n throw new IllegalArgumentException_1.default();\n }\n if (end === start) {\n return;\n }\n end--; // will be easier to treat this as the last actually set bit -- inclusive\n var firstInt = Math.floor(start / 32);\n var lastInt = Math.floor(end / 32);\n var bits = this.bits;\n for (var i = firstInt; i <= lastInt; i++) {\n var firstBit = i > firstInt ? 0 : start & 0x1F;\n var lastBit = i < lastInt ? 31 : end & 0x1F;\n // Ones from firstBit to lastBit, inclusive\n var mask = (2 << lastBit) - (1 << firstBit);\n bits[i] |= mask;\n }\n };\n /**\n * Clears all bits (sets to false).\n */\n BitArray.prototype.clear = function () {\n var max = this.bits.length;\n var bits = this.bits;\n for (var i = 0; i < max; i++) {\n bits[i] = 0;\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 BitArray.prototype.isRange = function (start /*int*/, end /*int*/, value) {\n if (end < start || start < 0 || end > this.size) {\n throw new IllegalArgumentException_1.default();\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 var firstInt = Math.floor(start / 32);\n var lastInt = Math.floor(end / 32);\n var bits = this.bits;\n for (var i = firstInt; i <= lastInt; i++) {\n var firstBit = i > firstInt ? 0 : start & 0x1F;\n var lastBit = i < lastInt ? 31 : end & 0x1F;\n // Ones from firstBit to lastBit, inclusive\n var 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 BitArray.prototype.appendBit = function (bit) {\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 * 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 BitArray.prototype.appendBits = function (value /*int*/, numBits /*int*/) {\n if (numBits < 0 || numBits > 32) {\n throw new IllegalArgumentException_1.default('Num bits must be between 0 and 32');\n }\n this.ensureCapacity(this.size + numBits);\n var appendBit = this.appendBit;\n for (var numBitsLeft = numBits; numBitsLeft > 0; numBitsLeft--) {\n this.appendBit(((value >> (numBitsLeft - 1)) & 0x01) === 1);\n }\n };\n BitArray.prototype.appendBitArray = function (other) {\n var otherSize = other.size;\n this.ensureCapacity(this.size + otherSize);\n var appendBit = this.appendBit;\n for (var i = 0; i < otherSize; i++) {\n this.appendBit(other.get(i));\n }\n };\n BitArray.prototype.xor = function (other) {\n if (this.size !== other.size) {\n throw new IllegalArgumentException_1.default('Sizes don\\'t match');\n }\n var bits = this.bits;\n for (var i = 0, length_1 = bits.length; i < length_1; 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 * @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 BitArray.prototype.toBytes = function (bitOffset /*int*/, array, offset /*int*/, numBytes /*int*/) {\n for (var i = 0; i < numBytes; i++) {\n var theByte = 0;\n for (var 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 * @return underlying array of ints. The first element holds the first 32 bits, and the least\n * significant bit is bit 0.\n */\n BitArray.prototype.getBitArray = function () {\n return this.bits;\n };\n /**\n * Reverses all bits in the array.\n */\n BitArray.prototype.reverse = function () {\n var newBits = new Int32Array(this.bits.length);\n // reverse all int's first\n var len = Math.floor((this.size - 1) / 32);\n var oldBitsLen = len + 1;\n var bits = this.bits;\n for (var i = 0; i < oldBitsLen; i++) {\n var 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 var leftOffset = oldBitsLen * 32 - this.size;\n var currentInt = newBits[0] >>> leftOffset;\n for (var i = 1; i < oldBitsLen; i++) {\n var 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 BitArray.makeArray = function (size /*int*/) {\n return new Int32Array(Math.floor((size + 31) / 32));\n };\n /*@Override*/\n BitArray.prototype.equals = function (o) {\n if (!(o instanceof BitArray)) {\n return false;\n }\n var other = o;\n return this.size === other.size && Arrays_1.default.equals(this.bits, other.bits);\n };\n /*@Override*/\n BitArray.prototype.hashCode = function () {\n return 31 * this.size + Arrays_1.default.hashCode(this.bits);\n };\n /*@Override*/\n BitArray.prototype.toString = function () {\n var result = '';\n for (var i = 0, size = this.size; i < size; i++) {\n if ((i & 0x07) === 0) {\n result += ' ';\n }\n result += this.get(i) ? 'X' : '.';\n }\n return result;\n };\n /*@Override*/\n BitArray.prototype.clone = function () {\n return new BitArray(this.size, this.bits.slice());\n };\n return BitArray;\n}());\nexports.default = BitArray;\n//# sourceMappingURL=BitArray.js.map","\"use strict\";\n/*\n * Copyright 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 */\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/*namespace com.google.zxing.common.detector {*/\nvar ResultPoint_1 = require(\"../../ResultPoint\");\nvar MathUtils_1 = require(\"./MathUtils\");\nvar NotFoundException_1 = require(\"../../NotFoundException\");\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. 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 */\nvar WhiteRectangleDetector = /** @class */ (function () {\n // public constructor(private image: BitMatrix) /*throws NotFoundException*/ {\n // this(image, INIT_SIZE, image.getWidth() / 2, image.getHeight() / 2)\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 function WhiteRectangleDetector(image, initSize /*int*/, x /*int*/, y /*int*/) {\n this.image = image;\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 var 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_1.default();\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 WhiteRectangleDetector.prototype.detect = function () {\n var left = this.leftInit;\n var right = this.rightInit;\n var up = this.upInit;\n var down = this.downInit;\n var sizeExceeded = false;\n var aBlackPointFoundOnBorder = true;\n var atLeastOneBlackPointFoundOnBorder = false;\n var atLeastOneBlackPointFoundOnRight = false;\n var atLeastOneBlackPointFoundOnBottom = false;\n var atLeastOneBlackPointFoundOnLeft = false;\n var atLeastOneBlackPointFoundOnTop = false;\n var width = this.width;\n var height = this.height;\n while (aBlackPointFoundOnBorder) {\n aBlackPointFoundOnBorder = false;\n // .....\n // . |\n // .....\n var rightBorderNotWhite = true;\n while ((rightBorderNotWhite || !atLeastOneBlackPointFoundOnRight) && right < width) {\n rightBorderNotWhite = this.containsBlackPoint(up, down, right, false);\n if (rightBorderNotWhite) {\n right++;\n aBlackPointFoundOnBorder = true;\n atLeastOneBlackPointFoundOnRight = true;\n }\n else if (!atLeastOneBlackPointFoundOnRight) {\n right++;\n }\n }\n if (right >= width) {\n sizeExceeded = true;\n break;\n }\n // .....\n // . .\n // .___.\n var bottomBorderNotWhite = true;\n while ((bottomBorderNotWhite || !atLeastOneBlackPointFoundOnBottom) && down < height) {\n bottomBorderNotWhite = this.containsBlackPoint(left, right, down, true);\n if (bottomBorderNotWhite) {\n down++;\n aBlackPointFoundOnBorder = true;\n atLeastOneBlackPointFoundOnBottom = true;\n }\n else if (!atLeastOneBlackPointFoundOnBottom) {\n down++;\n }\n }\n if (down >= height) {\n sizeExceeded = true;\n break;\n }\n // .....\n // | .\n // .....\n var leftBorderNotWhite = true;\n while ((leftBorderNotWhite || !atLeastOneBlackPointFoundOnLeft) && left >= 0) {\n leftBorderNotWhite = this.containsBlackPoint(up, down, left, false);\n if (leftBorderNotWhite) {\n left--;\n aBlackPointFoundOnBorder = true;\n atLeastOneBlackPointFoundOnLeft = true;\n }\n else if (!atLeastOneBlackPointFoundOnLeft) {\n left--;\n }\n }\n if (left < 0) {\n sizeExceeded = true;\n break;\n }\n // .___.\n // . .\n // .....\n var topBorderNotWhite = true;\n while ((topBorderNotWhite || !atLeastOneBlackPointFoundOnTop) && up >= 0) {\n topBorderNotWhite = this.containsBlackPoint(left, right, up, true);\n if (topBorderNotWhite) {\n up--;\n aBlackPointFoundOnBorder = true;\n atLeastOneBlackPointFoundOnTop = true;\n }\n else if (!atLeastOneBlackPointFoundOnTop) {\n up--;\n }\n }\n if (up < 0) {\n sizeExceeded = true;\n break;\n }\n if (aBlackPointFoundOnBorder) {\n atLeastOneBlackPointFoundOnBorder = true;\n }\n }\n if (!sizeExceeded && atLeastOneBlackPointFoundOnBorder) {\n var maxSize = right - left;\n var z = null;\n for (var i = 1; z === null && i < maxSize; i++) {\n z = this.getBlackPointOnSegment(left, down - i, left + i, down);\n }\n if (z == null) {\n throw new NotFoundException_1.default();\n }\n var t = null;\n // go down right\n for (var i = 1; t === null && i < maxSize; i++) {\n t = this.getBlackPointOnSegment(left, up + i, left + i, up);\n }\n if (t == null) {\n throw new NotFoundException_1.default();\n }\n var x = null;\n // go down left\n for (var i = 1; x === null && i < maxSize; i++) {\n x = this.getBlackPointOnSegment(right, up + i, right - i, up);\n }\n if (x == null) {\n throw new NotFoundException_1.default();\n }\n var y = null;\n // go up left\n for (var i = 1; y === null && i < maxSize; i++) {\n y = this.getBlackPointOnSegment(right, down - i, right - i, down);\n }\n if (y == null) {\n throw new NotFoundException_1.default();\n }\n return this.centerEdges(y, z, x, t);\n }\n else {\n throw new NotFoundException_1.default();\n }\n };\n WhiteRectangleDetector.prototype.getBlackPointOnSegment = function (aX /*float*/, aY /*float*/, bX /*float*/, bY /*float*/) {\n var dist = MathUtils_1.default.round(MathUtils_1.default.distance(aX, aY, bX, bY));\n var xStep = (bX - aX) / dist;\n var yStep = (bY - aY) / dist;\n var image = this.image;\n for (var i = 0; i < dist; i++) {\n var x = MathUtils_1.default.round(aX + i * xStep);\n var y = MathUtils_1.default.round(aY + i * yStep);\n if (image.get(x, y)) {\n return new ResultPoint_1.default(x, y);\n }\n }\n return null;\n };\n /**\n * recenters the points of a constant distance towards the center\n *\n * @param y bottom most point\n * @param z left most point\n * @param x right most point\n * @param t top most point\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 */\n WhiteRectangleDetector.prototype.centerEdges = function (y, z, x, t) {\n //\n // t t\n // z x\n // x OR z\n // y y\n //\n var yi = y.getX();\n var yj = y.getY();\n var zi = z.getX();\n var zj = z.getY();\n var xi = x.getX();\n var xj = x.getY();\n var ti = t.getX();\n var tj = t.getY();\n var CORR = WhiteRectangleDetector.CORR;\n if (yi < this.width / 2.0) {\n return [\n new ResultPoint_1.default(ti - CORR, tj + CORR),\n new ResultPoint_1.default(zi + CORR, zj + CORR),\n new ResultPoint_1.default(xi - CORR, xj - CORR),\n new ResultPoint_1.default(yi + CORR, yj - CORR)\n ];\n }\n else {\n return [\n new ResultPoint_1.default(ti + CORR, tj + CORR),\n new ResultPoint_1.default(zi + CORR, zj - CORR),\n new ResultPoint_1.default(xi - CORR, xj + CORR),\n new ResultPoint_1.default(yi - CORR, yj - CORR)\n ];\n }\n };\n /**\n * Determines whether a segment contains a black point\n *\n * @param a min value of the scanned coordinate\n * @param b max value of the scanned coordinate\n * @param fixed value of fixed coordinate\n * @param horizontal set to true if scan must be horizontal, false if vertical\n * @return true if a black point has been found, else false.\n */\n WhiteRectangleDetector.prototype.containsBlackPoint = function (a /*int*/, b /*int*/, fixed /*int*/, horizontal) {\n var image = this.image;\n if (horizontal) {\n for (var x = a; x <= b; x++) {\n if (image.get(x, fixed)) {\n return true;\n }\n }\n }\n else {\n for (var y = a; y <= b; y++) {\n if (image.get(fixed, y)) {\n return true;\n }\n }\n }\n return false;\n };\n WhiteRectangleDetector.INIT_SIZE = 10;\n WhiteRectangleDetector.CORR = 1;\n return WhiteRectangleDetector;\n}());\nexports.default = WhiteRectangleDetector;\n//# sourceMappingURL=WhiteRectangleDetector.js.map","'use strict';\nvar LIBRARY = require('./_library');\nvar $export = require('./_export');\nvar redefine = require('./_redefine');\nvar hide = require('./_hide');\nvar Iterators = require('./_iterators');\nvar $iterCreate = require('./_iter-create');\nvar setToStringTag = require('./_set-to-string-tag');\nvar getPrototypeOf = require('./_object-gpo');\nvar ITERATOR = require('./_wks')('iterator');\nvar BUGGY = !([].keys && 'next' in [].keys()); // Safari has buggy iterators w/o `next`\nvar FF_ITERATOR = '@@iterator';\nvar KEYS = 'keys';\nvar VALUES = 'values';\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED) {\n $iterCreate(Constructor, NAME, next);\n var getMethod = function (kind) {\n if (!BUGGY && kind in proto) return proto[kind];\n switch (kind) {\n case KEYS: return function keys() { return new Constructor(this, kind); };\n case VALUES: return function values() { return new Constructor(this, kind); };\n } return function entries() { return new Constructor(this, kind); };\n };\n var TAG = NAME + ' Iterator';\n var DEF_VALUES = DEFAULT == VALUES;\n var VALUES_BUG = false;\n var proto = Base.prototype;\n var $native = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT];\n var $default = $native || getMethod(DEFAULT);\n var $entries = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined;\n var $anyNative = NAME == 'Array' ? proto.entries || $native : $native;\n var methods, key, IteratorPrototype;\n // Fix native\n if ($anyNative) {\n IteratorPrototype = getPrototypeOf($anyNative.call(new Base()));\n if (IteratorPrototype !== Object.prototype && IteratorPrototype.next) {\n // Set @@toStringTag to native iterators\n setToStringTag(IteratorPrototype, TAG, true);\n // fix for some old engines\n if (!LIBRARY && typeof IteratorPrototype[ITERATOR] != 'function') hide(IteratorPrototype, ITERATOR, returnThis);\n }\n }\n // fix Array#{values, @@iterator}.name in V8 / FF\n if (DEF_VALUES && $native && $native.name !== VALUES) {\n VALUES_BUG = true;\n $default = function values() { return $native.call(this); };\n }\n // Define iterator\n if ((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])) {\n hide(proto, ITERATOR, $default);\n }\n // Plug for library\n Iterators[NAME] = $default;\n Iterators[TAG] = returnThis;\n if (DEFAULT) {\n methods = {\n values: DEF_VALUES ? $default : getMethod(VALUES),\n keys: IS_SET ? $default : getMethod(KEYS),\n entries: $entries\n };\n if (FORCED) for (key in methods) {\n if (!(key in proto)) redefine(proto, key, methods[key]);\n } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods);\n }\n return methods;\n};\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.pushParams = pushParams;\nexports.popParams = popParams;\nexports.withParams = withParams;\nexports._setTarget = exports.target = void 0;\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _typeof(obj) { if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nvar stack = [];\nvar target = null;\nexports.target = target;\n\nvar _setTarget = function _setTarget(x) {\n exports.target = target = x;\n};\n\nexports._setTarget = _setTarget;\n\nfunction pushParams() {\n if (target !== null) {\n stack.push(target);\n }\n\n exports.target = target = {};\n}\n\nfunction popParams() {\n var lastTarget = target;\n var newTarget = exports.target = target = stack.pop() || null;\n\n if (newTarget) {\n if (!Array.isArray(newTarget.$sub)) {\n newTarget.$sub = [];\n }\n\n newTarget.$sub.push(lastTarget);\n }\n\n return lastTarget;\n}\n\nfunction addParams(params) {\n if (_typeof(params) === 'object' && !Array.isArray(params)) {\n exports.target = target = _objectSpread({}, target, params);\n } else {\n throw new Error('params must be an object');\n }\n}\n\nfunction withParamsDirect(params, validator) {\n return withParamsClosure(function (add) {\n return function () {\n add(params);\n\n for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n args[_key] = arguments[_key];\n }\n\n return validator.apply(this, args);\n };\n });\n}\n\nfunction withParamsClosure(closure) {\n var validator = closure(addParams);\n return function () {\n pushParams();\n\n try {\n for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n args[_key2] = arguments[_key2];\n }\n\n return validator.apply(this, args);\n } finally {\n popParams();\n }\n };\n}\n\nfunction withParams(paramsOrClosure, maybeValidator) {\n if (_typeof(paramsOrClosure) === 'object' && maybeValidator !== undefined) {\n return withParamsDirect(paramsOrClosure, maybeValidator);\n }\n\n return withParamsClosure(paramsOrClosure);\n}","'use strict';\nvar $export = require('./_export');\nvar toObject = require('./_to-object');\nvar toPrimitive = require('./_to-primitive');\n\n$export($export.P + $export.F * require('./_fails')(function () {\n return new Date(NaN).toJSON() !== null\n || Date.prototype.toJSON.call({ toISOString: function () { return 1; } }) !== 1;\n}), 'Date', {\n // eslint-disable-next-line no-unused-vars\n toJSON: function toJSON(key) {\n var O = toObject(this);\n var pv = toPrimitive(O);\n return typeof pv == 'number' && !isFinite(pv) ? null : O.toISOString();\n }\n});\n","var toInteger = require('./_to-integer');\nvar defined = require('./_defined');\n// true -> String#at\n// false -> String#codePointAt\nmodule.exports = function (TO_STRING) {\n return function (that, pos) {\n var s = String(defined(that));\n var i = toInteger(pos);\n var l = s.length;\n var a, b;\n if (i < 0 || i >= l) return TO_STRING ? '' : undefined;\n a = s.charCodeAt(i);\n return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff\n ? TO_STRING ? s.charAt(i) : a\n : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;\n };\n};\n","'use strict';\nvar $export = require('./_export');\nvar toInteger = require('./_to-integer');\nvar aNumberValue = require('./_a-number-value');\nvar repeat = require('./_string-repeat');\nvar $toFixed = 1.0.toFixed;\nvar floor = Math.floor;\nvar data = [0, 0, 0, 0, 0, 0];\nvar ERROR = 'Number.toFixed: incorrect invocation!';\nvar ZERO = '0';\n\nvar multiply = function (n, c) {\n var i = -1;\n var c2 = c;\n while (++i < 6) {\n c2 += n * data[i];\n data[i] = c2 % 1e7;\n c2 = floor(c2 / 1e7);\n }\n};\nvar divide = function (n) {\n var i = 6;\n var c = 0;\n while (--i >= 0) {\n c += data[i];\n data[i] = floor(c / n);\n c = (c % n) * 1e7;\n }\n};\nvar numToString = function () {\n var i = 6;\n var s = '';\n while (--i >= 0) {\n if (s !== '' || i === 0 || data[i] !== 0) {\n var t = String(data[i]);\n s = s === '' ? t : s + repeat.call(ZERO, 7 - t.length) + t;\n }\n } return s;\n};\nvar pow = function (x, n, acc) {\n return n === 0 ? acc : n % 2 === 1 ? pow(x, n - 1, acc * x) : pow(x * x, n / 2, acc);\n};\nvar log = function (x) {\n var n = 0;\n var x2 = x;\n while (x2 >= 4096) {\n n += 12;\n x2 /= 4096;\n }\n while (x2 >= 2) {\n n += 1;\n x2 /= 2;\n } return n;\n};\n\n$export($export.P + $export.F * (!!$toFixed && (\n 0.00008.toFixed(3) !== '0.000' ||\n 0.9.toFixed(0) !== '1' ||\n 1.255.toFixed(2) !== '1.25' ||\n 1000000000000000128.0.toFixed(0) !== '1000000000000000128'\n) || !require('./_fails')(function () {\n // V8 ~ Android 4.3-\n $toFixed.call({});\n})), 'Number', {\n toFixed: function toFixed(fractionDigits) {\n var x = aNumberValue(this, ERROR);\n var f = toInteger(fractionDigits);\n var s = '';\n var m = ZERO;\n var e, z, j, k;\n if (f < 0 || f > 20) throw RangeError(ERROR);\n // eslint-disable-next-line no-self-compare\n if (x != x) return 'NaN';\n if (x <= -1e21 || x >= 1e21) return String(x);\n if (x < 0) {\n s = '-';\n x = -x;\n }\n if (x > 1e-21) {\n e = log(x * pow(2, 69, 1)) - 69;\n z = e < 0 ? x * pow(2, -e, 1) : x / pow(2, e, 1);\n z *= 0x10000000000000;\n e = 52 - e;\n if (e > 0) {\n multiply(0, z);\n j = f;\n while (j >= 7) {\n multiply(1e7, 0);\n j -= 7;\n }\n multiply(pow(10, j, 1), 0);\n j = e - 1;\n while (j >= 23) {\n divide(1 << 23);\n j -= 23;\n }\n divide(1 << j);\n multiply(1, 1);\n divide(2);\n m = numToString();\n } else {\n multiply(0, z);\n multiply(1 << -e, 0);\n m = numToString() + repeat.call(ZERO, f);\n }\n }\n if (f > 0) {\n k = m.length;\n m = s + (k <= f ? '0.' + repeat.call(ZERO, f - k) + m : m.slice(0, k - f) + '.' + m.slice(k - f));\n } else {\n m = s + m;\n } return m;\n }\n});\n","'use strict';\nvar at = require('./_string-at')(true);\n\n // `AdvanceStringIndex` abstract operation\n// https://tc39.github.io/ecma262/#sec-advancestringindex\nmodule.exports = function (S, index, unicode) {\n return index + (unicode ? at(S, index).length : 1);\n};\n","// 20.2.2.16 Math.fround(x)\nvar $export = require('./_export');\n\n$export($export.S, 'Math', { fround: require('./_math-fround') });\n","// 20.2.2.20 Math.log1p(x)\nvar $export = require('./_export');\n\n$export($export.S, 'Math', { log1p: require('./_math-log1p') });\n","\"use strict\";\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 */\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/*namespace com.google.zxing.qrcode.encoder {*/\nvar BlockPair = /** @class */ (function () {\n function BlockPair(dataBytes, errorCorrectionBytes) {\n this.dataBytes = dataBytes;\n this.errorCorrectionBytes = errorCorrectionBytes;\n }\n BlockPair.prototype.getDataBytes = function () {\n return this.dataBytes;\n };\n BlockPair.prototype.getErrorCorrectionBytes = function () {\n return this.errorCorrectionBytes;\n };\n return BlockPair;\n}());\nexports.default = BlockPair;\n//# sourceMappingURL=BlockPair.js.map","var $export = require('./_export');\nvar $parseInt = require('./_parse-int');\n// 20.1.2.13 Number.parseInt(string, radix)\n$export($export.S + $export.F * (Number.parseInt != $parseInt), 'Number', { parseInt: $parseInt });\n","\"use strict\";\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 */\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/*namespace com.google.zxing.qrcode.detector {*/\nvar ResultPoint_1 = require(\"../../ResultPoint\");\n/**\n *Encapsulates an alignment pattern, which are the smaller square patterns found in\n * all but the simplest QR Codes.
\n *\n * @author Sean Owen\n */\nvar AlignmentPattern = /** @class */ (function (_super) {\n __extends(AlignmentPattern, _super);\n function AlignmentPattern(posX /*float*/, posY /*float*/, estimatedModuleSize /*float*/) {\n var _this = _super.call(this, posX, posY) || this;\n _this.estimatedModuleSize = estimatedModuleSize;\n return _this;\n }\n /**\n *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.
\n */\n AlignmentPattern.prototype.aboutEquals = function (moduleSize /*float*/, i /*float*/, j /*float*/) {\n if (Math.abs(i - this.getY()) <= moduleSize && Math.abs(j - this.getX()) <= moduleSize) {\n var moduleSizeDiff = Math.abs(moduleSize - this.estimatedModuleSize);\n return moduleSizeDiff <= 1.0 || moduleSizeDiff <= this.estimatedModuleSize;\n }\n return false;\n };\n /**\n * Combines this object's current estimate of a finder pattern position and module size\n * with a new estimate. It returns a new {@code FinderPattern} containing an average of the two.\n */\n AlignmentPattern.prototype.combineEstimate = function (i /*float*/, j /*float*/, newModuleSize /*float*/) {\n var combinedX = (this.getX() + j) / 2.0;\n var combinedY = (this.getY() + i) / 2.0;\n var combinedModuleSize = (this.estimatedModuleSize + newModuleSize) / 2.0;\n return new AlignmentPattern(combinedX, combinedY, combinedModuleSize);\n };\n return AlignmentPattern;\n}(ResultPoint_1.default));\nexports.default = AlignmentPattern;\n//# sourceMappingURL=AlignmentPattern.js.map","var metadata = require('./_metadata');\nvar anObject = require('./_an-object');\nvar ordinaryGetOwnMetadata = metadata.get;\nvar toMetaKey = metadata.key;\n\nmetadata.exp({ getOwnMetadata: function getOwnMetadata(metadataKey, target /* , targetKey */) {\n return ordinaryGetOwnMetadata(metadataKey, anObject(target)\n , arguments.length < 3 ? undefined : toMetaKey(arguments[2]));\n} });\n","'use strict';\n// 19.1.3.6 Object.prototype.toString()\nvar classof = require('./_classof');\nvar test = {};\ntest[require('./_wks')('toStringTag')] = 'z';\nif (test + '' != '[object z]') {\n require('./_redefine')(Object.prototype, 'toString', function toString() {\n return '[object ' + classof(this) + ']';\n }, true);\n}\n","var hasOwnProperty = {}.hasOwnProperty;\nmodule.exports = function (it, key) {\n return hasOwnProperty.call(it, key);\n};\n","\"use strict\";\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 */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar BitArray_1 = require(\"../common/BitArray\");\nvar DecodeHintType_1 = require(\"../DecodeHintType\");\nvar ResultMetadataType_1 = require(\"../ResultMetadataType\");\nvar ResultPoint_1 = require(\"../ResultPoint\");\nvar NotFoundException_1 = require(\"../NotFoundException\");\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 */\nvar OneDReader = /** @class */ (function () {\n function OneDReader() {\n }\n /*\n @Override\n public Result decode(BinaryBitmap image) throws NotFoundException, FormatException {\n return decode(image, null);\n }\n */\n // Note that we don't try rotation without the try harder flag, even if rotation was supported.\n // @Override\n OneDReader.prototype.decode = function (image, hints) {\n try {\n return this.doDecode(image, hints);\n }\n catch (nfe) {\n var tryHarder = hints && (hints.get(DecodeHintType_1.default.TRY_HARDER) === true);\n if (tryHarder && image.isRotateSupported()) {\n var rotatedImage = image.rotateCounterClockwise();\n var result = this.doDecode(rotatedImage, hints);\n // Record that we found it rotated 90 degrees CCW / 270 degrees CW\n var metadata = result.getResultMetadata();\n var orientation_1 = 270;\n if (metadata !== null && (metadata.get(ResultMetadataType_1.default.ORIENTATION) === true)) {\n // But if we found it reversed in doDecode(), add in that result here:\n orientation_1 = (orientation_1 + metadata.get(ResultMetadataType_1.default.ORIENTATION) % 360);\n }\n result.putMetadata(ResultMetadataType_1.default.ORIENTATION, orientation_1);\n // Update result points\n var points = result.getResultPoints();\n if (points !== null) {\n var height = rotatedImage.getHeight();\n for (var i = 0; i < points.length; i++) {\n points[i] = new ResultPoint_1.default(height - points[i].getY() - 1, points[i].getX());\n }\n }\n return result;\n }\n else {\n throw new NotFoundException_1.default();\n }\n }\n };\n // @Override\n OneDReader.prototype.reset = function () {\n // do nothing\n };\n /**\n * We're going to examine rows from the middle outward, searching alternately above and below the\n * middle, and farther out each time. rowStep is the number of rows between each successive\n * attempt above and below the middle. So we'd scan row middle, then middle - rowStep, then\n * middle + rowStep, then middle - (2 * rowStep), etc.\n * rowStep is bigger as the image is taller, but is always at least 1. We've somewhat arbitrarily\n * decided that moving up and down by about 1/16 of the image is pretty good; we try more of the\n * image if \"trying harder\".\n *\n * @param image The image to decode\n * @param hints Any hints that were requested\n * @return The contents of the decoded barcode\n * @throws NotFoundException Any spontaneous errors which occur\n */\n OneDReader.prototype.doDecode = function (image, hints) {\n var width = image.getWidth();\n var height = image.getHeight();\n var row = new BitArray_1.default(width);\n var tryHarder = hints && (hints.get(DecodeHintType_1.default.TRY_HARDER) === true);\n var rowStep = Math.max(1, height >> (tryHarder ? 8 : 5));\n var maxLines;\n if (tryHarder) {\n maxLines = height; // Look at the whole image, not just the center\n }\n else {\n maxLines = 15; // 15 rows spaced 1/32 apart is roughly the middle half of the image\n }\n var middle = Math.trunc(height / 2);\n for (var x = 0; x < maxLines; x++) {\n // Scanning from the middle out. Determine which row we're looking at next:\n var rowStepsAboveOrBelow = Math.trunc((x + 1) / 2);\n var isAbove = (x & 0x01) === 0; // i.e. is x even?\n var rowNumber = middle + rowStep * (isAbove ? rowStepsAboveOrBelow : -rowStepsAboveOrBelow);\n if (rowNumber < 0 || rowNumber >= height) {\n // Oops, if we run off the top or bottom, stop\n break;\n }\n // Estimate black point for this row and load it:\n try {\n row = image.getBlackRow(rowNumber, row);\n }\n catch (ignored) {\n continue;\n }\n var _loop_1 = function (attempt) {\n if (attempt === 1) { // trying again?\n row.reverse(); // reverse the row and continue\n // This means we will only ever draw result points *once* in the life of this method\n // since we want to avoid drawing the wrong points after flipping the row, and,\n // don't want to clutter with noise from every single row scan -- just the scans\n // that start on the center line.\n if (hints && (hints.get(DecodeHintType_1.default.NEED_RESULT_POINT_CALLBACK) === true)) {\n var newHints_1 = new Map();\n hints.forEach(function (hint, key) { return newHints_1.set(key, hint); });\n newHints_1.delete(DecodeHintType_1.default.NEED_RESULT_POINT_CALLBACK);\n hints = newHints_1;\n }\n }\n try {\n // Look for a barcode\n var result = this_1.decodeRow(rowNumber, row, hints);\n // We found our barcode\n if (attempt === 1) {\n // But it was upside down, so note that\n result.putMetadata(ResultMetadataType_1.default.ORIENTATION, 180);\n // And remember to flip the result points horizontally.\n var points = result.getResultPoints();\n if (points !== null) {\n points[0] = new ResultPoint_1.default(width - points[0].getX() - 1, points[0].getY());\n points[1] = new ResultPoint_1.default(width - points[1].getX() - 1, points[1].getY());\n }\n }\n return { value: result };\n }\n catch (re) {\n // continue -- just couldn't decode this row\n }\n };\n var this_1 = this;\n // While we have the image data in a BitArray, it's fairly cheap to reverse it in place to\n // handle decoding upside down barcodes.\n for (var attempt = 0; attempt < 2; attempt++) {\n var state_1 = _loop_1(attempt);\n if (typeof state_1 === \"object\")\n return state_1.value;\n }\n }\n throw new NotFoundException_1.default();\n };\n /**\n * Records the size of successive runs of white and black pixels in a row, starting at a given point.\n * The values are recorded in the given array, and the number of runs recorded is equal to the size\n * of the array. If the row starts on a white pixel at the given start point, then the first count\n * recorded is the run of white pixels starting from that point; likewise it is the count of a run\n * of black pixels if the row begin on a black pixels at that point.\n *\n * @param row row to count from\n * @param start offset into row to start at\n * @param counters array into which to record counts\n * @throws NotFoundException if counters cannot be filled entirely from row before running out\n * of pixels\n */\n OneDReader.recordPattern = function (row, start, counters) {\n var numCounters = counters.length;\n for (var index = 0; index < numCounters; index++)\n counters[index] = 0;\n var end = row.getSize();\n if (start >= end) {\n throw new NotFoundException_1.default();\n }\n var isWhite = !row.get(start);\n var counterPosition = 0;\n var i = start;\n while (i < end) {\n if (row.get(i) !== isWhite) {\n counters[counterPosition]++;\n }\n else {\n if (++counterPosition === numCounters) {\n break;\n }\n else {\n counters[counterPosition] = 1;\n isWhite = !isWhite;\n }\n }\n i++;\n }\n // If we read fully the last section of pixels and filled up our counters -- or filled\n // the last counter but ran off the side of the image, OK. Otherwise, a problem.\n if (!(counterPosition === numCounters || (counterPosition === numCounters - 1 && i === end))) {\n throw new NotFoundException_1.default();\n }\n };\n OneDReader.recordPatternInReverse = function (row, start, counters) {\n // This could be more efficient I guess\n var numTransitionsLeft = counters.length;\n var last = row.get(start);\n while (start > 0 && numTransitionsLeft >= 0) {\n if (row.get(--start) !== last) {\n numTransitionsLeft--;\n last = !last;\n }\n }\n if (numTransitionsLeft >= 0) {\n throw new NotFoundException_1.default();\n }\n OneDReader.recordPattern(row, start + 1, counters);\n };\n /**\n * Determines how closely a set of observed counts of runs of black/white values matches a given\n * target pattern. This is reported as the ratio of the total variance from the expected pattern\n * proportions across all pattern elements, to the length of the pattern.\n *\n * @param counters observed counters\n * @param pattern expected pattern\n * @param maxIndividualVariance The most any counter can differ before we give up\n * @return ratio of total variance between counters and pattern compared to total pattern size\n */\n OneDReader.patternMatchVariance = function (counters, pattern, maxIndividualVariance) {\n var numCounters = counters.length;\n var total = 0;\n var patternLength = 0;\n for (var i = 0; i < numCounters; i++) {\n total += counters[i];\n patternLength += pattern[i];\n }\n if (total < patternLength) {\n // If we don't even have one pixel per unit of bar width, assume this is too small\n // to reliably match, so fail:\n return Number.POSITIVE_INFINITY;\n }\n var unitBarWidth = total / patternLength;\n maxIndividualVariance *= unitBarWidth;\n var totalVariance = 0.0;\n for (var x = 0; x < numCounters; x++) {\n var counter = counters[x];\n var scaledPattern = pattern[x] * unitBarWidth;\n var variance = counter > scaledPattern ? counter - scaledPattern : scaledPattern - counter;\n if (variance > maxIndividualVariance) {\n return Number.POSITIVE_INFINITY;\n }\n totalVariance += variance;\n }\n return totalVariance / total;\n };\n return OneDReader;\n}());\nexports.default = OneDReader;\n//# sourceMappingURL=OneDReader.js.map","// https://github.com/tc39/proposal-promise-finally\n'use strict';\nvar $export = require('./_export');\nvar core = require('./_core');\nvar global = require('./_global');\nvar speciesConstructor = require('./_species-constructor');\nvar promiseResolve = require('./_promise-resolve');\n\n$export($export.P + $export.R, 'Promise', { 'finally': function (onFinally) {\n var C = speciesConstructor(this, core.Promise || global.Promise);\n var isFunction = typeof onFinally == 'function';\n return this.then(\n isFunction ? function (x) {\n return promiseResolve(C, onFinally()).then(function () { return x; });\n } : onFinally,\n isFunction ? function (e) {\n return promiseResolve(C, onFinally()).then(function () { throw e; });\n } : onFinally\n );\n} });\n","// https://rwaldron.github.io/proposal-math-extensions/\nvar $export = require('./_export');\n\n$export($export.S, 'Math', {\n clamp: function clamp(x, lower, upper) {\n return Math.min(upper, Math.max(lower, x));\n }\n});\n","// https://tc39.github.io/ecma262/#sec-toindex\nvar toInteger = require('./_to-integer');\nvar toLength = require('./_to-length');\nmodule.exports = function (it) {\n if (it === undefined) return 0;\n var number = toInteger(it);\n var length = toLength(number);\n if (number !== length) throw RangeError('Wrong length!');\n return length;\n};\n","'use strict';\n\nvar utils = require('./../utils');\nvar buildURL = require('../helpers/buildURL');\nvar InterceptorManager = require('./InterceptorManager');\nvar dispatchRequest = require('./dispatchRequest');\nvar mergeConfig = require('./mergeConfig');\n\n/**\n * Create a new instance of Axios\n *\n * @param {Object} instanceConfig The default config for the instance\n */\nfunction Axios(instanceConfig) {\n this.defaults = instanceConfig;\n this.interceptors = {\n request: new InterceptorManager(),\n response: new InterceptorManager()\n };\n}\n\n/**\n * Dispatch a request\n *\n * @param {Object} config The config specific for this request (merged with this.defaults)\n */\nAxios.prototype.request = function request(config) {\n /*eslint no-param-reassign:0*/\n // Allow for axios('example/url'[, config]) a la fetch API\n if (typeof config === 'string') {\n config = arguments[1] || {};\n config.url = arguments[0];\n } else {\n config = config || {};\n }\n\n config = mergeConfig(this.defaults, config);\n config.method = config.method ? config.method.toLowerCase() : 'get';\n\n // Hook up interceptors middleware\n var chain = [dispatchRequest, undefined];\n var promise = Promise.resolve(config);\n\n this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {\n chain.unshift(interceptor.fulfilled, interceptor.rejected);\n });\n\n this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {\n chain.push(interceptor.fulfilled, interceptor.rejected);\n });\n\n while (chain.length) {\n promise = promise.then(chain.shift(), chain.shift());\n }\n\n return promise;\n};\n\nAxios.prototype.getUri = function getUri(config) {\n config = mergeConfig(this.defaults, config);\n return buildURL(config.url, config.params, config.paramsSerializer).replace(/^\\?/, '');\n};\n\n// Provide aliases for supported request methods\nutils.forEach(['delete', 'get', 'head', 'options'], function forEachMethodNoData(method) {\n /*eslint func-names:0*/\n Axios.prototype[method] = function(url, config) {\n return this.request(utils.merge(config || {}, {\n method: method,\n url: url\n }));\n };\n});\n\nutils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {\n /*eslint func-names:0*/\n Axios.prototype[method] = function(url, data, config) {\n return this.request(utils.merge(config || {}, {\n method: method,\n url: url,\n data: data\n }));\n };\n});\n\nmodule.exports = Axios;\n","// 0 -> Array#forEach\n// 1 -> Array#map\n// 2 -> Array#filter\n// 3 -> Array#some\n// 4 -> Array#every\n// 5 -> Array#find\n// 6 -> Array#findIndex\nvar ctx = require('./_ctx');\nvar IObject = require('./_iobject');\nvar toObject = require('./_to-object');\nvar toLength = require('./_to-length');\nvar asc = require('./_array-species-create');\nmodule.exports = function (TYPE, $create) {\n var IS_MAP = TYPE == 1;\n var IS_FILTER = TYPE == 2;\n var IS_SOME = TYPE == 3;\n var IS_EVERY = TYPE == 4;\n var IS_FIND_INDEX = TYPE == 6;\n var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;\n var create = $create || asc;\n return function ($this, callbackfn, that) {\n var O = toObject($this);\n var self = IObject(O);\n var f = ctx(callbackfn, that, 3);\n var length = toLength(self.length);\n var index = 0;\n var result = IS_MAP ? create($this, length) : IS_FILTER ? create($this, 0) : undefined;\n var val, res;\n for (;length > index; index++) if (NO_HOLES || index in self) {\n val = self[index];\n res = f(val, index, O);\n if (TYPE) {\n if (IS_MAP) result[index] = res; // map\n else if (res) switch (TYPE) {\n case 3: return true; // some\n case 5: return val; // find\n case 6: return index; // findIndex\n case 2: result.push(val); // filter\n } else if (IS_EVERY) return false; // every\n }\n }\n return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : result;\n };\n};\n","// 20.2.2.28 Math.sign(x)\nvar $export = require('./_export');\n\n$export($export.S, 'Math', { sign: require('./_math-sign') });\n","'use strict';\n// 21.2.5.3 get RegExp.prototype.flags\nvar anObject = require('./_an-object');\nmodule.exports = function () {\n var that = anObject(this);\n var result = '';\n if (that.global) result += 'g';\n if (that.ignoreCase) result += 'i';\n if (that.multiline) result += 'm';\n if (that.unicode) result += 'u';\n if (that.sticky) result += 'y';\n return result;\n};\n","// https://rwaldron.github.io/proposal-math-extensions/\nvar $export = require('./_export');\n\n$export($export.S, 'Math', { DEG_PER_RAD: Math.PI / 180 });\n","// https://github.com/tc39/proposal-global\nvar $export = require('./_export');\n\n$export($export.G, { global: require('./_global') });\n","'use strict';\nvar $export = require('./_export');\nvar $reduce = require('./_array-reduce');\n\n$export($export.P + $export.F * !require('./_strict-method')([].reduce, true), 'Array', {\n // 22.1.3.18 / 15.4.4.21 Array.prototype.reduce(callbackfn [, initialValue])\n reduce: function reduce(callbackfn /* , initialValue */) {\n return $reduce(this, callbackfn, arguments.length, arguments[1], false);\n }\n});\n","// https://github.com/rwaldron/tc39-notes/blob/master/es6/2014-09/sept-25.md#510-globalasap-for-enqueuing-a-microtask\nvar $export = require('./_export');\nvar microtask = require('./_microtask')();\nvar process = require('./_global').process;\nvar isNode = require('./_cof')(process) == 'process';\n\n$export($export.G, {\n asap: function asap(fn) {\n var domain = isNode && process.domain;\n microtask(domain ? domain.bind(fn) : fn);\n }\n});\n","// 19.1.2.14 / 15.2.3.14 Object.keys(O)\nvar $keys = require('./_object-keys-internal');\nvar enumBugKeys = require('./_enum-bug-keys');\n\nmodule.exports = Object.keys || function keys(O) {\n return $keys(O, enumBugKeys);\n};\n","// 19.1.2.5 Object.freeze(O)\nvar isObject = require('./_is-object');\nvar meta = require('./_meta').onFreeze;\n\nrequire('./_object-sap')('freeze', function ($freeze) {\n return function freeze(it) {\n return $freeze && isObject(it) ? $freeze(meta(it)) : it;\n };\n});\n","'use strict';\n\n/**\n * Syntactic sugar for invoking a function and expanding an array for arguments.\n *\n * Common use case would be to use `Function.prototype.apply`.\n *\n * ```js\n * function f(x, y, z) {}\n * var args = [1, 2, 3];\n * f.apply(null, args);\n * ```\n *\n * With `spread` this example can be re-written.\n *\n * ```js\n * spread(function(x, y, z) {})([1, 2, 3]);\n * ```\n *\n * @param {Function} callback\n * @returns {Function}\n */\nmodule.exports = function spread(callback) {\n return function wrap(arr) {\n return callback.apply(null, arr);\n };\n};\n","\"use strict\";\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 */\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/*namespace com.google.zxing.common.reedsolomon {*/\nvar GenericGF_1 = require(\"./GenericGF\");\nvar System_1 = require(\"../../util/System\");\nvar IllegalArgumentException_1 = require(\"../../IllegalArgumentException\");\n/**\n *Represents 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 */\nvar GenericGFPoly = /** @class */ (function () {\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 function GenericGFPoly(field, coefficients) {\n if (coefficients.length === 0) {\n throw new IllegalArgumentException_1.default();\n }\n this.field = field;\n var 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 var firstNonZero = 1;\n while (firstNonZero < coefficientsLength && coefficients[firstNonZero] === 0) {\n firstNonZero++;\n }\n if (firstNonZero === coefficientsLength) {\n this.coefficients = Int32Array.from([0]);\n }\n else {\n this.coefficients = new Int32Array(coefficientsLength - firstNonZero);\n System_1.default.arraycopy(coefficients, firstNonZero, this.coefficients, 0, this.coefficients.length);\n }\n }\n else {\n this.coefficients = coefficients;\n }\n }\n GenericGFPoly.prototype.getCoefficients = function () {\n return this.coefficients;\n };\n /**\n * @return degree of this polynomial\n */\n GenericGFPoly.prototype.getDegree = function () {\n return this.coefficients.length - 1;\n };\n /**\n * @return true iff this polynomial is the monomial \"0\"\n */\n GenericGFPoly.prototype.isZero = function () {\n return this.coefficients[0] === 0;\n };\n /**\n * @return coefficient of x^degree term in this polynomial\n */\n GenericGFPoly.prototype.getCoefficient = function (degree /*int*/) {\n return this.coefficients[this.coefficients.length - 1 - degree];\n };\n /**\n * @return evaluation of this polynomial at a given point\n */\n GenericGFPoly.prototype.evaluateAt = function (a /*int*/) {\n if (a === 0) {\n // Just return the x^0 coefficient\n return this.getCoefficient(0);\n }\n var coefficients = this.coefficients;\n var result;\n if (a === 1) {\n // Just the sum of the coefficients\n result = 0;\n for (var i = 0, length_1 = coefficients.length; i !== length_1; i++) {\n var coefficient = coefficients[i];\n result = GenericGF_1.default.addOrSubtract(result, coefficient);\n }\n return result;\n }\n result = coefficients[0];\n var size = coefficients.length;\n var field = this.field;\n for (var i = 1; i < size; i++) {\n result = GenericGF_1.default.addOrSubtract(field.multiply(a, result), coefficients[i]);\n }\n return result;\n };\n GenericGFPoly.prototype.addOrSubtract = function (other) {\n if (!this.field.equals(other.field)) {\n throw new IllegalArgumentException_1.default('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 var smallerCoefficients = this.coefficients;\n var largerCoefficients = other.coefficients;\n if (smallerCoefficients.length > largerCoefficients.length) {\n var temp = smallerCoefficients;\n smallerCoefficients = largerCoefficients;\n largerCoefficients = temp;\n }\n var sumDiff = new Int32Array(largerCoefficients.length);\n var lengthDiff = largerCoefficients.length - smallerCoefficients.length;\n // Copy high-order terms only found in higher-degree polynomial's coefficients\n System_1.default.arraycopy(largerCoefficients, 0, sumDiff, 0, lengthDiff);\n for (var i = lengthDiff; i < largerCoefficients.length; i++) {\n sumDiff[i] = GenericGF_1.default.addOrSubtract(smallerCoefficients[i - lengthDiff], largerCoefficients[i]);\n }\n return new GenericGFPoly(this.field, sumDiff);\n };\n GenericGFPoly.prototype.multiply = function (other) {\n if (!this.field.equals(other.field)) {\n throw new IllegalArgumentException_1.default('GenericGFPolys do not have same GenericGF field');\n }\n if (this.isZero() || other.isZero()) {\n return this.field.getZero();\n }\n var aCoefficients = this.coefficients;\n var aLength = aCoefficients.length;\n var bCoefficients = other.coefficients;\n var bLength = bCoefficients.length;\n var product = new Int32Array(aLength + bLength - 1);\n var field = this.field;\n for (var i = 0; i < aLength; i++) {\n var aCoeff = aCoefficients[i];\n for (var j = 0; j < bLength; j++) {\n product[i + j] = GenericGF_1.default.addOrSubtract(product[i + j], field.multiply(aCoeff, bCoefficients[j]));\n }\n }\n return new GenericGFPoly(field, product);\n };\n GenericGFPoly.prototype.multiplyScalar = function (scalar /*int*/) {\n if (scalar === 0) {\n return this.field.getZero();\n }\n if (scalar === 1) {\n return this;\n }\n var size = this.coefficients.length;\n var field = this.field;\n var product = new Int32Array(size);\n var coefficients = this.coefficients;\n for (var i = 0; i < size; i++) {\n product[i] = field.multiply(coefficients[i], scalar);\n }\n return new GenericGFPoly(field, product);\n };\n GenericGFPoly.prototype.multiplyByMonomial = function (degree /*int*/, coefficient /*int*/) {\n if (degree < 0) {\n throw new IllegalArgumentException_1.default();\n }\n if (coefficient === 0) {\n return this.field.getZero();\n }\n var coefficients = this.coefficients;\n var size = coefficients.length;\n var product = new Int32Array(size + degree);\n var field = this.field;\n for (var i = 0; i < size; i++) {\n product[i] = field.multiply(coefficients[i], coefficient);\n }\n return new GenericGFPoly(field, product);\n };\n GenericGFPoly.prototype.divide = function (other) {\n if (!this.field.equals(other.field)) {\n throw new IllegalArgumentException_1.default('GenericGFPolys do not have same GenericGF field');\n }\n if (other.isZero()) {\n throw new IllegalArgumentException_1.default('Divide by 0');\n }\n var field = this.field;\n var quotient = field.getZero();\n var remainder = this;\n var denominatorLeadingTerm = other.getCoefficient(other.getDegree());\n var inverseDenominatorLeadingTerm = field.inverse(denominatorLeadingTerm);\n while (remainder.getDegree() >= other.getDegree() && !remainder.isZero()) {\n var degreeDifference = remainder.getDegree() - other.getDegree();\n var scale = field.multiply(remainder.getCoefficient(remainder.getDegree()), inverseDenominatorLeadingTerm);\n var term = other.multiplyByMonomial(degreeDifference, scale);\n var iterationQuotient = field.buildMonomial(degreeDifference, scale);\n quotient = quotient.addOrSubtract(iterationQuotient);\n remainder = remainder.addOrSubtract(term);\n }\n return [quotient, remainder];\n };\n /*@Override*/\n GenericGFPoly.prototype.toString = function () {\n var result = '';\n for (var degree = this.getDegree(); degree >= 0; degree--) {\n var coefficient = this.getCoefficient(degree);\n if (coefficient !== 0) {\n if (coefficient < 0) {\n result += ' - ';\n coefficient = -coefficient;\n }\n else {\n if (result.length > 0) {\n result += ' + ';\n }\n }\n if (degree === 0 || coefficient !== 1) {\n var alphaPower = this.field.log(coefficient);\n if (alphaPower === 0) {\n result += '1';\n }\n else if (alphaPower === 1) {\n result += 'a';\n }\n else {\n result += 'a^';\n result += alphaPower;\n }\n }\n if (degree !== 0) {\n if (degree === 1) {\n result += 'x';\n }\n else {\n result += 'x^';\n result += degree;\n }\n }\n }\n }\n return result;\n };\n return GenericGFPoly;\n}());\nexports.default = GenericGFPoly;\n//# sourceMappingURL=GenericGFPoly.js.map","var global = require('./_global');\nvar hide = require('./_hide');\nvar uid = require('./_uid');\nvar TYPED = uid('typed_array');\nvar VIEW = uid('view');\nvar ABV = !!(global.ArrayBuffer && global.DataView);\nvar CONSTR = ABV;\nvar i = 0;\nvar l = 9;\nvar Typed;\n\nvar TypedArrayConstructors = (\n 'Int8Array,Uint8Array,Uint8ClampedArray,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array'\n).split(',');\n\nwhile (i < l) {\n if (Typed = global[TypedArrayConstructors[i++]]) {\n hide(Typed.prototype, TYPED, true);\n hide(Typed.prototype, VIEW, true);\n } else CONSTR = false;\n}\n\nmodule.exports = {\n ABV: ABV,\n CONSTR: CONSTR,\n TYPED: TYPED,\n VIEW: VIEW\n};\n","var toInteger = require('./_to-integer');\nvar max = Math.max;\nvar min = Math.min;\nmodule.exports = function (index, length) {\n index = toInteger(index);\n return index < 0 ? max(index + length, 0) : min(index, length);\n};\n","\"use strict\";\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 */\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n *Encapsulates information about finder patterns in an image, including the location of\n * the three finder patterns, and their estimated module size.
\n *\n * @author Sean Owen\n */\nvar FinderPatternInfo = /** @class */ (function () {\n function FinderPatternInfo(patternCenters) {\n this.bottomLeft = patternCenters[0];\n this.topLeft = patternCenters[1];\n this.topRight = patternCenters[2];\n }\n FinderPatternInfo.prototype.getBottomLeft = function () {\n return this.bottomLeft;\n };\n FinderPatternInfo.prototype.getTopLeft = function () {\n return this.topLeft;\n };\n FinderPatternInfo.prototype.getTopRight = function () {\n return this.topRight;\n };\n return FinderPatternInfo;\n}());\nexports.default = FinderPatternInfo;\n//# sourceMappingURL=FinderPatternInfo.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar AbstractRSSReader_1 = require(\"./AbstractRSSReader\");\nvar Pair_1 = require(\"./Pair\");\nvar Result_1 = require(\"../../Result\");\nvar DecodeHintType_1 = require(\"../../DecodeHintType\");\nvar NotFoundException_1 = require(\"../../NotFoundException\");\nvar StringBuilder_1 = require(\"../../util/StringBuilder\");\nvar BarcodeFormat_1 = require(\"../../BarcodeFormat\");\nvar ResultPoint_1 = require(\"../../ResultPoint\");\nvar FinderPattern_1 = require(\"./FinderPattern\");\nvar DataCharacter_1 = require(\"./DataCharacter\");\nvar MathUtils_1 = require(\"../../common/detector/MathUtils\");\nvar RSSUtils_1 = require(\"./RSSUtils\");\nvar System_1 = require(\"../../util/System\");\nvar OneDReader_1 = require(\"../OneDReader\");\nvar RSS14Reader = /** @class */ (function (_super) {\n __extends(RSS14Reader, _super);\n function RSS14Reader() {\n var _this = _super !== null && _super.apply(this, arguments) || this;\n _this.possibleLeftPairs = [];\n _this.possibleRightPairs = [];\n return _this;\n }\n RSS14Reader.prototype.decodeRow = function (rowNumber, row, hints) {\n var leftPair = this.decodePair(row, false, rowNumber, hints);\n RSS14Reader.addOrTally(this.possibleLeftPairs, leftPair);\n row.reverse();\n var rightPair = this.decodePair(row, true, rowNumber, hints);\n RSS14Reader.addOrTally(this.possibleRightPairs, rightPair);\n row.reverse();\n for (var _i = 0, _a = this.possibleLeftPairs; _i < _a.length; _i++) {\n var left = _a[_i];\n if (left.getCount() > 1) {\n for (var _b = 0, _c = this.possibleRightPairs; _b < _c.length; _b++) {\n var right = _c[_b];\n if (right.getCount() > 1 && RSS14Reader.checkChecksum(left, right)) {\n return RSS14Reader.constructResult(left, right);\n }\n }\n }\n }\n throw new NotFoundException_1.default();\n };\n RSS14Reader.addOrTally = function (possiblePairs, pair) {\n if (pair == null) {\n return;\n }\n var found = false;\n for (var _i = 0, possiblePairs_1 = possiblePairs; _i < possiblePairs_1.length; _i++) {\n var other = possiblePairs_1[_i];\n if (other.getValue() === pair.getValue()) {\n other.incrementCount();\n found = true;\n break;\n }\n }\n if (!found) {\n possiblePairs.push(pair);\n }\n };\n RSS14Reader.prototype.reset = function () {\n this.possibleLeftPairs.length = 0;\n this.possibleRightPairs.length = 0;\n };\n RSS14Reader.constructResult = function (leftPair, rightPair) {\n var symbolValue = 4537077 * leftPair.getValue() + rightPair.getValue();\n var text = new String(symbolValue).toString();\n var buffer = new StringBuilder_1.default();\n for (var i = 13 - text.length; i > 0; i--) {\n buffer.append('0');\n }\n buffer.append(text);\n var checkDigit = 0;\n for (var i = 0; i < 13; i++) {\n var digit = buffer.charAt(i).charCodeAt(0) - '0'.charCodeAt(0);\n checkDigit += ((i & 0x01) === 0) ? 3 * digit : digit;\n }\n checkDigit = 10 - (checkDigit % 10);\n if (checkDigit === 10) {\n checkDigit = 0;\n }\n buffer.append(checkDigit.toString());\n var leftPoints = leftPair.getFinderPattern().getResultPoints();\n var rightPoints = rightPair.getFinderPattern().getResultPoints();\n return new Result_1.default(buffer.toString(), null, 0, [leftPoints[0], leftPoints[1], rightPoints[0], rightPoints[1]], BarcodeFormat_1.default.RSS_14, new Date().getTime());\n };\n RSS14Reader.checkChecksum = function (leftPair, rightPair) {\n var checkValue = (leftPair.getChecksumPortion() + 16 * rightPair.getChecksumPortion()) % 79;\n var targetCheckValue = 9 * leftPair.getFinderPattern().getValue() + rightPair.getFinderPattern().getValue();\n if (targetCheckValue > 72) {\n targetCheckValue--;\n }\n if (targetCheckValue > 8) {\n targetCheckValue--;\n }\n return checkValue === targetCheckValue;\n };\n RSS14Reader.prototype.decodePair = function (row, right, rowNumber, hints) {\n try {\n var startEnd = this.findFinderPattern(row, right);\n var pattern = this.parseFoundFinderPattern(row, rowNumber, right, startEnd);\n var resultPointCallback = hints == null ? null : hints.get(DecodeHintType_1.default.NEED_RESULT_POINT_CALLBACK);\n if (resultPointCallback != null) {\n var center = (startEnd[0] + startEnd[1]) / 2.0;\n if (right) {\n // row is actually reversed\n center = row.getSize() - 1 - center;\n }\n resultPointCallback.foundPossibleResultPoint(new ResultPoint_1.default(center, rowNumber));\n }\n var outside = this.decodeDataCharacter(row, pattern, true);\n var inside = this.decodeDataCharacter(row, pattern, false);\n return new Pair_1.default(1597 * outside.getValue() + inside.getValue(), outside.getChecksumPortion() + 4 * inside.getChecksumPortion(), pattern);\n }\n catch (err) {\n return null;\n }\n };\n RSS14Reader.prototype.decodeDataCharacter = function (row, pattern, outsideChar) {\n var counters = this.getDataCharacterCounters();\n for (var x = 0; x < counters.length; x++) {\n counters[x] = 0;\n }\n if (outsideChar) {\n OneDReader_1.default.recordPatternInReverse(row, pattern.getStartEnd()[0], counters);\n }\n else {\n OneDReader_1.default.recordPattern(row, pattern.getStartEnd()[1] + 1, counters);\n // reverse it\n for (var i = 0, j = counters.length - 1; i < j; i++, j--) {\n var temp = counters[i];\n counters[i] = counters[j];\n counters[j] = temp;\n }\n }\n var numModules = outsideChar ? 16 : 15;\n var elementWidth = MathUtils_1.default.sum(new Int32Array(counters)) / numModules;\n var oddCounts = this.getOddCounts();\n var evenCounts = this.getEvenCounts();\n var oddRoundingErrors = this.getOddRoundingErrors();\n var evenRoundingErrors = this.getEvenRoundingErrors();\n for (var i = 0; i < counters.length; i++) {\n var value = counters[i] / elementWidth;\n var count = Math.floor(value + 0.5);\n if (count < 1) {\n count = 1;\n }\n else if (count > 8) {\n count = 8;\n }\n var offset = Math.floor(i / 2);\n if ((i & 0x01) === 0) {\n oddCounts[offset] = count;\n oddRoundingErrors[offset] = value - count;\n }\n else {\n evenCounts[offset] = count;\n evenRoundingErrors[offset] = value - count;\n }\n }\n this.adjustOddEvenCounts(outsideChar, numModules);\n var oddSum = 0;\n var oddChecksumPortion = 0;\n for (var i = oddCounts.length - 1; i >= 0; i--) {\n oddChecksumPortion *= 9;\n oddChecksumPortion += oddCounts[i];\n oddSum += oddCounts[i];\n }\n var evenChecksumPortion = 0;\n var evenSum = 0;\n for (var i = evenCounts.length - 1; i >= 0; i--) {\n evenChecksumPortion *= 9;\n evenChecksumPortion += evenCounts[i];\n evenSum += evenCounts[i];\n }\n var checksumPortion = oddChecksumPortion + 3 * evenChecksumPortion;\n if (outsideChar) {\n if ((oddSum & 0x01) !== 0 || oddSum > 12 || oddSum < 4) {\n throw new NotFoundException_1.default();\n }\n var group = (12 - oddSum) / 2;\n var oddWidest = RSS14Reader.OUTSIDE_ODD_WIDEST[group];\n var evenWidest = 9 - oddWidest;\n var vOdd = RSSUtils_1.default.getRSSvalue(oddCounts, oddWidest, false);\n var vEven = RSSUtils_1.default.getRSSvalue(evenCounts, evenWidest, true);\n var tEven = RSS14Reader.OUTSIDE_EVEN_TOTAL_SUBSET[group];\n var gSum = RSS14Reader.OUTSIDE_GSUM[group];\n return new DataCharacter_1.default(vOdd * tEven + vEven + gSum, checksumPortion);\n }\n else {\n if ((evenSum & 0x01) !== 0 || evenSum > 10 || evenSum < 4) {\n throw new NotFoundException_1.default();\n }\n var group = (10 - evenSum) / 2;\n var oddWidest = RSS14Reader.INSIDE_ODD_WIDEST[group];\n var evenWidest = 9 - oddWidest;\n var vOdd = RSSUtils_1.default.getRSSvalue(oddCounts, oddWidest, true);\n var vEven = RSSUtils_1.default.getRSSvalue(evenCounts, evenWidest, false);\n var tOdd = RSS14Reader.INSIDE_ODD_TOTAL_SUBSET[group];\n var gSum = RSS14Reader.INSIDE_GSUM[group];\n return new DataCharacter_1.default(vEven * tOdd + vOdd + gSum, checksumPortion);\n }\n };\n RSS14Reader.prototype.findFinderPattern = function (row, rightFinderPattern) {\n var counters = this.getDecodeFinderCounters();\n counters[0] = 0;\n counters[1] = 0;\n counters[2] = 0;\n counters[3] = 0;\n var width = row.getSize();\n var isWhite = false;\n var rowOffset = 0;\n while (rowOffset < width) {\n isWhite = !row.get(rowOffset);\n if (rightFinderPattern === isWhite) {\n // Will encounter white first when searching for right finder pattern\n break;\n }\n rowOffset++;\n }\n var counterPosition = 0;\n var patternStart = rowOffset;\n for (var x = rowOffset; x < width; x++) {\n if (row.get(x) !== isWhite) {\n counters[counterPosition]++;\n }\n else {\n if (counterPosition === 3) {\n if (AbstractRSSReader_1.default.isFinderPattern(counters)) {\n return [patternStart, x];\n }\n patternStart += counters[0] + counters[1];\n counters[0] = counters[2];\n counters[1] = counters[3];\n counters[2] = 0;\n counters[3] = 0;\n counterPosition--;\n }\n else {\n counterPosition++;\n }\n counters[counterPosition] = 1;\n isWhite = !isWhite;\n }\n }\n throw new NotFoundException_1.default();\n };\n RSS14Reader.prototype.parseFoundFinderPattern = function (row, rowNumber, right, startEnd) {\n // Actually we found elements 2-5\n var firstIsBlack = row.get(startEnd[0]);\n var firstElementStart = startEnd[0] - 1;\n // Locate element 1\n while (firstElementStart >= 0 && firstIsBlack !== row.get(firstElementStart)) {\n firstElementStart--;\n }\n firstElementStart++;\n var firstCounter = startEnd[0] - firstElementStart;\n // Make 'counters' hold 1-4\n var counters = this.getDecodeFinderCounters();\n var copy = new Array(counters.length);\n System_1.default.arraycopy(counters, 0, copy, 1, counters.length - 1);\n copy[0] = firstCounter;\n var value = this.parseFinderValue(copy, RSS14Reader.FINDER_PATTERNS);\n var start = firstElementStart;\n var end = startEnd[1];\n if (right) {\n // row is actually reversed\n start = row.getSize() - 1 - start;\n end = row.getSize() - 1 - end;\n }\n return new FinderPattern_1.default(value, [firstElementStart, startEnd[1]], start, end, rowNumber);\n };\n RSS14Reader.prototype.adjustOddEvenCounts = function (outsideChar, numModules) {\n var oddSum = MathUtils_1.default.sum(new Int32Array(this.getOddCounts()));\n var evenSum = MathUtils_1.default.sum(new Int32Array(this.getEvenCounts()));\n var incrementOdd = false;\n var decrementOdd = false;\n var incrementEven = false;\n var decrementEven = false;\n if (outsideChar) {\n if (oddSum > 12) {\n decrementOdd = true;\n }\n else if (oddSum < 4) {\n incrementOdd = true;\n }\n if (evenSum > 12) {\n decrementEven = true;\n }\n else if (evenSum < 4) {\n incrementEven = true;\n }\n }\n else {\n if (oddSum > 11) {\n decrementOdd = true;\n }\n else if (oddSum < 5) {\n incrementOdd = true;\n }\n if (evenSum > 10) {\n decrementEven = true;\n }\n else if (evenSum < 4) {\n incrementEven = true;\n }\n }\n var mismatch = oddSum + evenSum - numModules;\n var oddParityBad = (oddSum & 0x01) === (outsideChar ? 1 : 0);\n var evenParityBad = (evenSum & 0x01) === 1;\n if (mismatch === 1) {\n if (oddParityBad) {\n if (evenParityBad) {\n throw new NotFoundException_1.default();\n }\n decrementOdd = true;\n }\n else {\n if (!evenParityBad) {\n throw new NotFoundException_1.default();\n }\n decrementEven = true;\n }\n }\n else if (mismatch === -1) {\n if (oddParityBad) {\n if (evenParityBad) {\n throw new NotFoundException_1.default();\n }\n incrementOdd = true;\n }\n else {\n if (!evenParityBad) {\n throw new NotFoundException_1.default();\n }\n incrementEven = true;\n }\n }\n else if (mismatch === 0) {\n if (oddParityBad) {\n if (!evenParityBad) {\n throw new NotFoundException_1.default();\n }\n // Both bad\n if (oddSum < evenSum) {\n incrementOdd = true;\n decrementEven = true;\n }\n else {\n decrementOdd = true;\n incrementEven = true;\n }\n }\n else {\n if (evenParityBad) {\n throw new NotFoundException_1.default();\n }\n // Nothing to do!\n }\n }\n else {\n throw new NotFoundException_1.default();\n }\n if (incrementOdd) {\n if (decrementOdd) {\n throw new NotFoundException_1.default();\n }\n AbstractRSSReader_1.default.increment(this.getOddCounts(), this.getOddRoundingErrors());\n }\n if (decrementOdd) {\n AbstractRSSReader_1.default.decrement(this.getOddCounts(), this.getOddRoundingErrors());\n }\n if (incrementEven) {\n if (decrementEven) {\n throw new NotFoundException_1.default();\n }\n AbstractRSSReader_1.default.increment(this.getEvenCounts(), this.getOddRoundingErrors());\n }\n if (decrementEven) {\n AbstractRSSReader_1.default.decrement(this.getEvenCounts(), this.getEvenRoundingErrors());\n }\n };\n RSS14Reader.OUTSIDE_EVEN_TOTAL_SUBSET = [1, 10, 34, 70, 126];\n RSS14Reader.INSIDE_ODD_TOTAL_SUBSET = [4, 20, 48, 81];\n RSS14Reader.OUTSIDE_GSUM = [0, 161, 961, 2015, 2715];\n RSS14Reader.INSIDE_GSUM = [0, 336, 1036, 1516];\n RSS14Reader.OUTSIDE_ODD_WIDEST = [8, 6, 4, 3, 1];\n RSS14Reader.INSIDE_ODD_WIDEST = [2, 4, 6, 8];\n RSS14Reader.FINDER_PATTERNS = [\n [3, 8, 2, 1],\n [3, 5, 5, 1],\n [3, 3, 7, 1],\n [3, 1, 9, 1],\n [2, 7, 4, 1],\n [2, 5, 6, 1],\n [2, 3, 8, 1],\n [1, 5, 7, 1],\n [1, 3, 9, 1],\n ];\n return RSS14Reader;\n}(AbstractRSSReader_1.default));\nexports.default = RSS14Reader;\n//# sourceMappingURL=RSS14Reader.js.map","'use strict';\nvar global = require('./_global');\nvar each = require('./_array-methods')(0);\nvar redefine = require('./_redefine');\nvar meta = require('./_meta');\nvar assign = require('./_object-assign');\nvar weak = require('./_collection-weak');\nvar isObject = require('./_is-object');\nvar validate = require('./_validate-collection');\nvar NATIVE_WEAK_MAP = require('./_validate-collection');\nvar IS_IE11 = !global.ActiveXObject && 'ActiveXObject' in global;\nvar WEAK_MAP = 'WeakMap';\nvar getWeak = meta.getWeak;\nvar isExtensible = Object.isExtensible;\nvar uncaughtFrozenStore = weak.ufstore;\nvar InternalMap;\n\nvar wrapper = function (get) {\n return function WeakMap() {\n return get(this, arguments.length > 0 ? arguments[0] : undefined);\n };\n};\n\nvar methods = {\n // 23.3.3.3 WeakMap.prototype.get(key)\n get: function get(key) {\n if (isObject(key)) {\n var data = getWeak(key);\n if (data === true) return uncaughtFrozenStore(validate(this, WEAK_MAP)).get(key);\n return data ? data[this._i] : undefined;\n }\n },\n // 23.3.3.5 WeakMap.prototype.set(key, value)\n set: function set(key, value) {\n return weak.def(validate(this, WEAK_MAP), key, value);\n }\n};\n\n// 23.3 WeakMap Objects\nvar $WeakMap = module.exports = require('./_collection')(WEAK_MAP, wrapper, methods, weak, true, true);\n\n// IE11 WeakMap frozen keys fix\nif (NATIVE_WEAK_MAP && IS_IE11) {\n InternalMap = weak.getConstructor(wrapper, WEAK_MAP);\n assign(InternalMap.prototype, methods);\n meta.NEED = true;\n each(['delete', 'has', 'get', 'set'], function (key) {\n var proto = $WeakMap.prototype;\n var method = proto[key];\n redefine(proto, key, function (a, b) {\n // store frozen objects on internal weakmap shim\n if (isObject(a) && !isExtensible(a)) {\n if (!this._f) this._f = new InternalMap();\n var result = this._f[key](a, b);\n return key == 'set' ? this : result;\n // store all the rest on native weakmap\n } return method.call(this, a, b);\n });\n });\n}\n","// 7.2.2 IsArray(argument)\nvar cof = require('./_cof');\nmodule.exports = Array.isArray || function isArray(arg) {\n return cof(arg) == 'Array';\n};\n","module.exports = function (it, Constructor, name, forbiddenField) {\n if (!(it instanceof Constructor) || (forbiddenField !== undefined && forbiddenField in it)) {\n throw TypeError(name + ': incorrect invocation!');\n } return it;\n};\n","\"use strict\";\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 */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar IllegalArgumentException_1 = require(\"../../IllegalArgumentException\");\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 */\nvar DataBlock = /** @class */ (function () {\n function DataBlock(numDataCodewords /*int*/, codewords) {\n this.numDataCodewords = numDataCodewords;\n this.codewords = codewords;\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 DataBlock.getDataBlocks = function (rawCodewords, version, ecLevel) {\n if (rawCodewords.length !== version.getTotalCodewords()) {\n throw new IllegalArgumentException_1.default();\n }\n // Figure out the number and size of data blocks used by this version and\n // error correction level\n var ecBlocks = version.getECBlocksForLevel(ecLevel);\n // First count the total number of data blocks\n var totalBlocks = 0;\n var ecBlockArray = ecBlocks.getECBlocks();\n for (var _i = 0, ecBlockArray_1 = ecBlockArray; _i < ecBlockArray_1.length; _i++) {\n var ecBlock = ecBlockArray_1[_i];\n totalBlocks += ecBlock.getCount();\n }\n // Now establish DataBlocks of the appropriate size and number of data codewords\n var result = new Array(totalBlocks);\n var numResultBlocks = 0;\n for (var _a = 0, ecBlockArray_2 = ecBlockArray; _a < ecBlockArray_2.length; _a++) {\n var ecBlock = ecBlockArray_2[_a];\n for (var i = 0; i < ecBlock.getCount(); i++) {\n var numDataCodewords = ecBlock.getDataCodewords();\n var numBlockCodewords = ecBlocks.getECCodewordsPerBlock() + numDataCodewords;\n result[numResultBlocks++] = new DataBlock(numDataCodewords, new Uint8Array(numBlockCodewords));\n }\n }\n // All blocks have the same amount of data, except that the last n\n // (where n may be 0) have 1 more byte. Figure out where these start.\n var shorterBlocksTotalCodewords = result[0].codewords.length;\n var longerBlocksStartAt = result.length - 1;\n // TYPESCRIPTPORT: check length is correct here\n while (longerBlocksStartAt >= 0) {\n var numCodewords = result[longerBlocksStartAt].codewords.length;\n if (numCodewords === shorterBlocksTotalCodewords) {\n break;\n }\n longerBlocksStartAt--;\n }\n longerBlocksStartAt++;\n var shorterBlocksNumDataCodewords = shorterBlocksTotalCodewords - ecBlocks.getECCodewordsPerBlock();\n // The last elements of result may be 1 element longer\n // first fill out as many elements as all of them have\n var rawCodewordsOffset = 0;\n for (var i = 0; i < shorterBlocksNumDataCodewords; i++) {\n for (var j = 0; j < numResultBlocks; j++) {\n result[j].codewords[i] = rawCodewords[rawCodewordsOffset++];\n }\n }\n // Fill out the last data block in the longer ones\n for (var j = longerBlocksStartAt; j < numResultBlocks; j++) {\n result[j].codewords[shorterBlocksNumDataCodewords] = rawCodewords[rawCodewordsOffset++];\n }\n // Now add in error correction blocks\n var max = result[0].codewords.length;\n for (var i = shorterBlocksNumDataCodewords; i < max; i++) {\n for (var j = 0; j < numResultBlocks; j++) {\n var iOffset = j < longerBlocksStartAt ? i : i + 1;\n result[j].codewords[iOffset] = rawCodewords[rawCodewordsOffset++];\n }\n }\n return result;\n };\n DataBlock.prototype.getNumDataCodewords = function () {\n return this.numDataCodewords;\n };\n DataBlock.prototype.getCodewords = function () {\n return this.codewords;\n };\n return DataBlock;\n}());\nexports.default = DataBlock;\n//# sourceMappingURL=DataBlock.js.map","\"use strict\";\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 */\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar BarcodeFormat_1 = require(\"../BarcodeFormat\");\nvar UPCEANReader_1 = require(\"./UPCEANReader\");\nvar NotFoundException_1 = require(\"../NotFoundException\");\n/**\n *Implements 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 */\nvar EAN13Reader = /** @class */ (function (_super) {\n __extends(EAN13Reader, _super);\n function EAN13Reader() {\n var _this = _super.call(this) || this;\n _this.decodeMiddleCounters = [0, 0, 0, 0];\n return _this;\n }\n EAN13Reader.prototype.decodeMiddle = function (row, startRange, resultString) {\n var counters = this.decodeMiddleCounters;\n counters[0] = 0;\n counters[1] = 0;\n counters[2] = 0;\n counters[3] = 0;\n var end = row.getSize();\n var rowOffset = startRange[1];\n var lgPatternFound = 0;\n for (var x = 0; x < 6 && rowOffset < end; x++) {\n var bestMatch = UPCEANReader_1.default.decodeDigit(row, counters, rowOffset, UPCEANReader_1.default.L_AND_G_PATTERNS);\n resultString += String.fromCharCode(('0'.charCodeAt(0) + bestMatch % 10));\n for (var _i = 0, counters_1 = counters; _i < counters_1.length; _i++) {\n var counter = counters_1[_i];\n rowOffset += counter;\n }\n if (bestMatch >= 10) {\n lgPatternFound |= 1 << (5 - x);\n }\n }\n resultString = EAN13Reader.determineFirstDigit(resultString, lgPatternFound);\n var middleRange = UPCEANReader_1.default.findGuardPattern(row, rowOffset, true, UPCEANReader_1.default.MIDDLE_PATTERN, new Array(UPCEANReader_1.default.MIDDLE_PATTERN.length).fill(0));\n rowOffset = middleRange[1];\n for (var x = 0; x < 6 && rowOffset < end; x++) {\n var bestMatch = UPCEANReader_1.default.decodeDigit(row, counters, rowOffset, UPCEANReader_1.default.L_PATTERNS);\n resultString += String.fromCharCode(('0'.charCodeAt(0) + bestMatch));\n for (var _a = 0, counters_2 = counters; _a < counters_2.length; _a++) {\n var counter = counters_2[_a];\n rowOffset += counter;\n }\n }\n return { rowOffset: rowOffset, resultString: resultString };\n };\n EAN13Reader.prototype.getBarcodeFormat = function () {\n return BarcodeFormat_1.default.EAN_13;\n };\n EAN13Reader.determineFirstDigit = function (resultString, lgPatternFound) {\n for (var 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_1.default();\n };\n EAN13Reader.FIRST_DIGIT_ENCODINGS = [0x00, 0x0B, 0x0D, 0xE, 0x13, 0x19, 0x1C, 0x15, 0x16, 0x1A];\n return EAN13Reader;\n}(UPCEANReader_1.default));\nexports.default = EAN13Reader;\n//# sourceMappingURL=EAN13Reader.js.map","var pIE = require('./_object-pie');\nvar createDesc = require('./_property-desc');\nvar toIObject = require('./_to-iobject');\nvar toPrimitive = require('./_to-primitive');\nvar has = require('./_has');\nvar IE8_DOM_DEFINE = require('./_ie8-dom-define');\nvar gOPD = Object.getOwnPropertyDescriptor;\n\nexports.f = require('./_descriptors') ? gOPD : function getOwnPropertyDescriptor(O, P) {\n O = toIObject(O);\n P = toPrimitive(P, true);\n if (IE8_DOM_DEFINE) try {\n return gOPD(O, P);\n } catch (e) { /* empty */ }\n if (has(O, P)) return createDesc(!pIE.f.call(O, P), O[P]);\n};\n","var $export = require('./_export');\nvar $task = require('./_task');\n$export($export.G + $export.B, {\n setImmediate: $task.set,\n clearImmediate: $task.clear\n});\n","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar BrowserCodeReader_1 = require(\"./BrowserCodeReader\");\nvar MultiFormatOneDReader_1 = require(\"../core/oned/MultiFormatOneDReader\");\n/**\n * @deprecated Moving to @zxing/browser\n *\n * Barcode reader reader to use from browser.\n */\nvar BrowserBarcodeReader = /** @class */ (function (_super) {\n __extends(BrowserBarcodeReader, _super);\n /**\n * Creates an instance of BrowserBarcodeReader.\n * @param {number} [timeBetweenScansMillis=500] the time delay between subsequent decode tries\n * @param {MapEncapsulates 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 */\nvar ECBlocks = /** @class */ (function () {\n function ECBlocks(ecCodewordsPerBlock /*int*/) {\n var ecBlocks = [];\n for (var _i = 1; _i < arguments.length; _i++) {\n ecBlocks[_i - 1] = arguments[_i];\n }\n this.ecCodewordsPerBlock = ecCodewordsPerBlock;\n this.ecBlocks = ecBlocks;\n }\n ECBlocks.prototype.getECCodewordsPerBlock = function () {\n return this.ecCodewordsPerBlock;\n };\n ECBlocks.prototype.getNumBlocks = function () {\n var total = 0;\n var ecBlocks = this.ecBlocks;\n for (var _i = 0, ecBlocks_1 = ecBlocks; _i < ecBlocks_1.length; _i++) {\n var ecBlock = ecBlocks_1[_i];\n total += ecBlock.getCount();\n }\n return total;\n };\n ECBlocks.prototype.getTotalECCodewords = function () {\n return this.ecCodewordsPerBlock * this.getNumBlocks();\n };\n ECBlocks.prototype.getECBlocks = function () {\n return this.ecBlocks;\n };\n return ECBlocks;\n}());\nexports.default = ECBlocks;\n//# sourceMappingURL=ECBlocks.js.map","var ctx = require('./_ctx');\nvar invoke = require('./_invoke');\nvar html = require('./_html');\nvar cel = require('./_dom-create');\nvar global = require('./_global');\nvar process = global.process;\nvar setTask = global.setImmediate;\nvar clearTask = global.clearImmediate;\nvar MessageChannel = global.MessageChannel;\nvar Dispatch = global.Dispatch;\nvar counter = 0;\nvar queue = {};\nvar ONREADYSTATECHANGE = 'onreadystatechange';\nvar defer, channel, port;\nvar run = function () {\n var id = +this;\n // eslint-disable-next-line no-prototype-builtins\n if (queue.hasOwnProperty(id)) {\n var fn = queue[id];\n delete queue[id];\n fn();\n }\n};\nvar listener = function (event) {\n run.call(event.data);\n};\n// Node.js 0.9+ & IE10+ has setImmediate, otherwise:\nif (!setTask || !clearTask) {\n setTask = function setImmediate(fn) {\n var args = [];\n var i = 1;\n while (arguments.length > i) args.push(arguments[i++]);\n queue[++counter] = function () {\n // eslint-disable-next-line no-new-func\n invoke(typeof fn == 'function' ? fn : Function(fn), args);\n };\n defer(counter);\n return counter;\n };\n clearTask = function clearImmediate(id) {\n delete queue[id];\n };\n // Node.js 0.8-\n if (require('./_cof')(process) == 'process') {\n defer = function (id) {\n process.nextTick(ctx(run, id, 1));\n };\n // Sphere (JS game engine) Dispatch API\n } else if (Dispatch && Dispatch.now) {\n defer = function (id) {\n Dispatch.now(ctx(run, id, 1));\n };\n // Browsers with MessageChannel, includes WebWorkers\n } else if (MessageChannel) {\n channel = new MessageChannel();\n port = channel.port2;\n channel.port1.onmessage = listener;\n defer = ctx(port.postMessage, port, 1);\n // Browsers with postMessage, skip WebWorkers\n // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'\n } else if (global.addEventListener && typeof postMessage == 'function' && !global.importScripts) {\n defer = function (id) {\n global.postMessage(id + '', '*');\n };\n global.addEventListener('message', listener, false);\n // IE8-\n } else if (ONREADYSTATECHANGE in cel('script')) {\n defer = function (id) {\n html.appendChild(cel('script'))[ONREADYSTATECHANGE] = function () {\n html.removeChild(this);\n run.call(id);\n };\n };\n // Rest old browsers\n } else {\n defer = function (id) {\n setTimeout(ctx(run, id, 1), 0);\n };\n }\n}\nmodule.exports = {\n set: setTask,\n clear: clearTask\n};\n","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Exception_1 = require(\"./Exception\");\n/**\n * Custom Error class of type Exception.\n */\nvar WriterException = /** @class */ (function (_super) {\n __extends(WriterException, _super);\n function WriterException() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n return WriterException;\n}(Exception_1.default));\nexports.default = WriterException;\n//# sourceMappingURL=WriterException.js.map","// 7.1.1 ToPrimitive(input [, PreferredType])\nvar isObject = require('./_is-object');\n// instead of the ES6 spec version, we didn't implement @@toPrimitive case\n// and the second argument - flag - preferred type is a string\nmodule.exports = function (it, S) {\n if (!isObject(it)) return it;\n var fn, val;\n if (S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;\n if (typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it))) return val;\n if (!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;\n throw TypeError(\"Can't convert object to primitive value\");\n};\n","var $export = require('./_export');\n// 19.1.2.4 / 15.2.3.6 Object.defineProperty(O, P, Attributes)\n$export($export.S + $export.F * !require('./_descriptors'), 'Object', { defineProperty: require('./_object-dp').f });\n","'use strict';\nvar ctx = require('./_ctx');\nvar $export = require('./_export');\nvar toObject = require('./_to-object');\nvar call = require('./_iter-call');\nvar isArrayIter = require('./_is-array-iter');\nvar toLength = require('./_to-length');\nvar createProperty = require('./_create-property');\nvar getIterFn = require('./core.get-iterator-method');\n\n$export($export.S + $export.F * !require('./_iter-detect')(function (iter) { Array.from(iter); }), 'Array', {\n // 22.1.2.1 Array.from(arrayLike, mapfn = undefined, thisArg = undefined)\n from: function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) {\n var O = toObject(arrayLike);\n var C = typeof this == 'function' ? this : Array;\n var aLen = arguments.length;\n var mapfn = aLen > 1 ? arguments[1] : undefined;\n var mapping = mapfn !== undefined;\n var index = 0;\n var iterFn = getIterFn(O);\n var length, result, step, iterator;\n if (mapping) mapfn = ctx(mapfn, aLen > 2 ? arguments[2] : undefined, 2);\n // if object isn't iterable or it's array with default iterator - use simple case\n if (iterFn != undefined && !(C == Array && isArrayIter(iterFn))) {\n for (iterator = iterFn.call(O), result = new C(); !(step = iterator.next()).done; index++) {\n createProperty(result, index, mapping ? call(iterator, mapfn, [step.value, index], true) : step.value);\n }\n } else {\n length = toLength(O.length);\n for (result = new C(length); length > index; index++) {\n createProperty(result, index, mapping ? mapfn(O[index], index) : O[index]);\n }\n }\n result.length = index;\n return result;\n }\n});\n","'use strict';\n\nmodule.exports = function bind(fn, thisArg) {\n return function wrap() {\n var args = new Array(arguments.length);\n for (var i = 0; i < args.length; i++) {\n args[i] = arguments[i];\n }\n return fn.apply(thisArg, args);\n };\n};\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.Vuelidate = Vuelidate;\nObject.defineProperty(exports, \"withParams\", {\n enumerable: true,\n get: function get() {\n return _params.withParams;\n }\n});\nexports.default = exports.validationMixin = void 0;\n\nvar _vval = require(\"./vval\");\n\nvar _params = require(\"./params\");\n\nfunction _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }\n\nfunction _nonIterableSpread() { throw new TypeError(\"Invalid attempt to spread non-iterable instance\"); }\n\nfunction _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === \"[object Arguments]\") return Array.from(iter); }\n\nfunction _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _typeof(obj) { if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nvar NIL = function NIL() {\n return null;\n};\n\nvar buildFromKeys = function buildFromKeys(keys, fn, keyFn) {\n return keys.reduce(function (build, key) {\n build[keyFn ? keyFn(key) : key] = fn(key);\n return build;\n }, {});\n};\n\nfunction isFunction(val) {\n return typeof val === 'function';\n}\n\nfunction isObject(val) {\n return val !== null && (_typeof(val) === 'object' || isFunction(val));\n}\n\nfunction isPromise(object) {\n return isObject(object) && isFunction(object.then);\n}\n\nvar getPath = function getPath(ctx, obj, path, fallback) {\n if (typeof path === 'function') {\n return path.call(ctx, obj, fallback);\n }\n\n path = Array.isArray(path) ? path : path.split('.');\n\n for (var i = 0; i < path.length; i++) {\n if (obj && _typeof(obj) === 'object') {\n obj = obj[path[i]];\n } else {\n return fallback;\n }\n }\n\n return typeof obj === 'undefined' ? fallback : obj;\n};\n\nvar __isVuelidateAsyncVm = '__isVuelidateAsyncVm';\n\nfunction makePendingAsyncVm(Vue, promise) {\n var asyncVm = new Vue({\n data: {\n p: true,\n v: false\n }\n });\n promise.then(function (value) {\n asyncVm.p = false;\n asyncVm.v = value;\n }, function (error) {\n asyncVm.p = false;\n asyncVm.v = false;\n throw error;\n });\n asyncVm[__isVuelidateAsyncVm] = true;\n return asyncVm;\n}\n\nvar validationGetters = {\n $invalid: function $invalid() {\n var _this = this;\n\n var proxy = this.proxy;\n return this.nestedKeys.some(function (nested) {\n return _this.refProxy(nested).$invalid;\n }) || this.ruleKeys.some(function (rule) {\n return !proxy[rule];\n });\n },\n $dirty: function $dirty() {\n var _this2 = this;\n\n if (this.dirty) {\n return true;\n }\n\n if (this.nestedKeys.length === 0) {\n return false;\n }\n\n return this.nestedKeys.every(function (key) {\n return _this2.refProxy(key).$dirty;\n });\n },\n $anyDirty: function $anyDirty() {\n var _this3 = this;\n\n if (this.dirty) {\n return true;\n }\n\n if (this.nestedKeys.length === 0) {\n return false;\n }\n\n return this.nestedKeys.some(function (key) {\n return _this3.refProxy(key).$anyDirty;\n });\n },\n $error: function $error() {\n return this.$dirty && !this.$pending && this.$invalid;\n },\n $anyError: function $anyError() {\n return this.$anyDirty && !this.$pending && this.$invalid;\n },\n $pending: function $pending() {\n var _this4 = this;\n\n return this.ruleKeys.some(function (key) {\n return _this4.getRef(key).$pending;\n }) || this.nestedKeys.some(function (key) {\n return _this4.refProxy(key).$pending;\n });\n },\n $params: function $params() {\n var _this5 = this;\n\n var vals = this.validations;\n return _objectSpread({}, buildFromKeys(this.nestedKeys, function (key) {\n return vals[key] && vals[key].$params || null;\n }), buildFromKeys(this.ruleKeys, function (key) {\n return _this5.getRef(key).$params;\n }));\n }\n};\n\nfunction setDirtyRecursive(newState) {\n this.dirty = newState;\n var proxy = this.proxy;\n var method = newState ? '$touch' : '$reset';\n this.nestedKeys.forEach(function (key) {\n proxy[key][method]();\n });\n}\n\nvar validationMethods = {\n $touch: function $touch() {\n setDirtyRecursive.call(this, true);\n },\n $reset: function $reset() {\n setDirtyRecursive.call(this, false);\n },\n $flattenParams: function $flattenParams() {\n var proxy = this.proxy;\n var params = [];\n\n for (var key in this.$params) {\n if (this.isNested(key)) {\n var childParams = proxy[key].$flattenParams();\n\n for (var j = 0; j < childParams.length; j++) {\n childParams[j].path.unshift(key);\n }\n\n params = params.concat(childParams);\n } else {\n params.push({\n path: [],\n name: key,\n params: this.$params[key]\n });\n }\n }\n\n return params;\n }\n};\nvar getterNames = Object.keys(validationGetters);\nvar methodNames = Object.keys(validationMethods);\nvar _cachedComponent = null;\n\nvar getComponent = function getComponent(Vue) {\n if (_cachedComponent) {\n return _cachedComponent;\n }\n\n var VBase = Vue.extend({\n computed: {\n refs: function refs() {\n var oldVval = this._vval;\n this._vval = this.children;\n (0, _vval.patchChildren)(oldVval, this._vval);\n var refs = {};\n\n this._vval.forEach(function (c) {\n refs[c.key] = c.vm;\n });\n\n return refs;\n }\n },\n beforeCreate: function beforeCreate() {\n this._vval = null;\n },\n beforeDestroy: function beforeDestroy() {\n if (this._vval) {\n (0, _vval.patchChildren)(this._vval);\n this._vval = null;\n }\n },\n methods: {\n getModel: function getModel() {\n return this.lazyModel ? this.lazyModel(this.prop) : this.model;\n },\n getModelKey: function getModelKey(key) {\n var model = this.getModel();\n\n if (model) {\n return model[key];\n }\n },\n hasIter: function hasIter() {\n return false;\n }\n }\n });\n var ValidationRule = VBase.extend({\n data: function data() {\n return {\n rule: null,\n lazyModel: null,\n model: null,\n lazyParentModel: null,\n rootModel: null\n };\n },\n methods: {\n runRule: function runRule(parent) {\n var model = this.getModel();\n (0, _params.pushParams)();\n var rawOutput = this.rule.call(this.rootModel, model, parent);\n var output = isPromise(rawOutput) ? makePendingAsyncVm(Vue, rawOutput) : rawOutput;\n var rawParams = (0, _params.popParams)();\n var params = rawParams && rawParams.$sub ? rawParams.$sub.length > 1 ? rawParams : rawParams.$sub[0] : null;\n return {\n output: output,\n params: params\n };\n }\n },\n computed: {\n run: function run() {\n var _this6 = this;\n\n var parent = this.lazyParentModel();\n\n var isArrayDependant = Array.isArray(parent) && parent.__ob__;\n\n if (isArrayDependant) {\n var arrayDep = parent.__ob__.dep;\n arrayDep.depend();\n var target = arrayDep.constructor.target;\n\n if (!this._indirectWatcher) {\n var Watcher = target.constructor;\n this._indirectWatcher = new Watcher(this, function () {\n return _this6.runRule(parent);\n }, null, {\n lazy: true\n });\n }\n\n var model = this.getModel();\n\n if (!this._indirectWatcher.dirty && this._lastModel === model) {\n this._indirectWatcher.depend();\n\n return target.value;\n }\n\n this._lastModel = model;\n\n this._indirectWatcher.evaluate();\n\n this._indirectWatcher.depend();\n } else if (this._indirectWatcher) {\n this._indirectWatcher.teardown();\n\n this._indirectWatcher = null;\n }\n\n return this._indirectWatcher ? this._indirectWatcher.value : this.runRule(parent);\n },\n $params: function $params() {\n return this.run.params;\n },\n proxy: function proxy() {\n var output = this.run.output;\n\n if (output[__isVuelidateAsyncVm]) {\n return !!output.v;\n }\n\n return !!output;\n },\n $pending: function $pending() {\n var output = this.run.output;\n\n if (output[__isVuelidateAsyncVm]) {\n return output.p;\n }\n\n return false;\n }\n },\n destroyed: function destroyed() {\n if (this._indirectWatcher) {\n this._indirectWatcher.teardown();\n\n this._indirectWatcher = null;\n }\n }\n });\n var Validation = VBase.extend({\n data: function data() {\n return {\n dirty: false,\n validations: null,\n lazyModel: null,\n model: null,\n prop: null,\n lazyParentModel: null,\n rootModel: null\n };\n },\n methods: _objectSpread({}, validationMethods, {\n refProxy: function refProxy(key) {\n return this.getRef(key).proxy;\n },\n getRef: function getRef(key) {\n return this.refs[key];\n },\n isNested: function isNested(key) {\n return typeof this.validations[key] !== 'function';\n }\n }),\n computed: _objectSpread({}, validationGetters, {\n nestedKeys: function nestedKeys() {\n return this.keys.filter(this.isNested);\n },\n ruleKeys: function ruleKeys() {\n var _this7 = this;\n\n return this.keys.filter(function (k) {\n return !_this7.isNested(k);\n });\n },\n keys: function keys() {\n return Object.keys(this.validations).filter(function (k) {\n return k !== '$params';\n });\n },\n proxy: function proxy() {\n var _this8 = this;\n\n var keyDefs = buildFromKeys(this.keys, function (key) {\n return {\n enumerable: true,\n configurable: true,\n get: function get() {\n return _this8.refProxy(key);\n }\n };\n });\n var getterDefs = buildFromKeys(getterNames, function (key) {\n return {\n enumerable: true,\n configurable: true,\n get: function get() {\n return _this8[key];\n }\n };\n });\n var methodDefs = buildFromKeys(methodNames, function (key) {\n return {\n enumerable: false,\n configurable: true,\n get: function get() {\n return _this8[key];\n }\n };\n });\n var iterDefs = this.hasIter() ? {\n $iter: {\n enumerable: true,\n value: Object.defineProperties({}, _objectSpread({}, keyDefs))\n }\n } : {};\n return Object.defineProperties({}, _objectSpread({}, keyDefs, iterDefs, {\n $model: {\n enumerable: true,\n get: function get() {\n var parent = _this8.lazyParentModel();\n\n if (parent != null) {\n return parent[_this8.prop];\n } else {\n return null;\n }\n },\n set: function set(value) {\n var parent = _this8.lazyParentModel();\n\n if (parent != null) {\n parent[_this8.prop] = value;\n\n _this8.$touch();\n }\n }\n }\n }, getterDefs, methodDefs));\n },\n children: function children() {\n var _this9 = this;\n\n return _toConsumableArray(this.nestedKeys.map(function (key) {\n return renderNested(_this9, key);\n })).concat(_toConsumableArray(this.ruleKeys.map(function (key) {\n return renderRule(_this9, key);\n }))).filter(Boolean);\n }\n })\n });\n var GroupValidation = Validation.extend({\n methods: {\n isNested: function isNested(key) {\n return typeof this.validations[key]() !== 'undefined';\n },\n getRef: function getRef(key) {\n var vm = this;\n return {\n get proxy() {\n return vm.validations[key]() || false;\n }\n\n };\n }\n }\n });\n var EachValidation = Validation.extend({\n computed: {\n keys: function keys() {\n var model = this.getModel();\n\n if (isObject(model)) {\n return Object.keys(model);\n } else {\n return [];\n }\n },\n tracker: function tracker() {\n var _this10 = this;\n\n var trackBy = this.validations.$trackBy;\n return trackBy ? function (key) {\n return \"\".concat(getPath(_this10.rootModel, _this10.getModelKey(key), trackBy));\n } : function (x) {\n return \"\".concat(x);\n };\n },\n getModelLazy: function getModelLazy() {\n var _this11 = this;\n\n return function () {\n return _this11.getModel();\n };\n },\n children: function children() {\n var _this12 = this;\n\n var def = this.validations;\n var model = this.getModel();\n\n var validations = _objectSpread({}, def);\n\n delete validations['$trackBy'];\n var usedTracks = {};\n return this.keys.map(function (key) {\n var track = _this12.tracker(key);\n\n if (usedTracks.hasOwnProperty(track)) {\n return null;\n }\n\n usedTracks[track] = true;\n return (0, _vval.h)(Validation, track, {\n validations: validations,\n prop: key,\n lazyParentModel: _this12.getModelLazy,\n model: model[key],\n rootModel: _this12.rootModel\n });\n }).filter(Boolean);\n }\n },\n methods: {\n isNested: function isNested() {\n return true;\n },\n getRef: function getRef(key) {\n return this.refs[this.tracker(key)];\n },\n hasIter: function hasIter() {\n return true;\n }\n }\n });\n\n var renderNested = function renderNested(vm, key) {\n if (key === '$each') {\n return (0, _vval.h)(EachValidation, key, {\n validations: vm.validations[key],\n lazyParentModel: vm.lazyParentModel,\n prop: key,\n lazyModel: vm.getModel,\n rootModel: vm.rootModel\n });\n }\n\n var validations = vm.validations[key];\n\n if (Array.isArray(validations)) {\n var root = vm.rootModel;\n var refVals = buildFromKeys(validations, function (path) {\n return function () {\n return getPath(root, root.$v, path);\n };\n }, function (v) {\n return Array.isArray(v) ? v.join('.') : v;\n });\n return (0, _vval.h)(GroupValidation, key, {\n validations: refVals,\n lazyParentModel: NIL,\n prop: key,\n lazyModel: NIL,\n rootModel: root\n });\n }\n\n return (0, _vval.h)(Validation, key, {\n validations: validations,\n lazyParentModel: vm.getModel,\n prop: key,\n lazyModel: vm.getModelKey,\n rootModel: vm.rootModel\n });\n };\n\n var renderRule = function renderRule(vm, key) {\n return (0, _vval.h)(ValidationRule, key, {\n rule: vm.validations[key],\n lazyParentModel: vm.lazyParentModel,\n lazyModel: vm.getModel,\n rootModel: vm.rootModel\n });\n };\n\n _cachedComponent = {\n VBase: VBase,\n Validation: Validation\n };\n return _cachedComponent;\n};\n\nvar _cachedVue = null;\n\nfunction getVue(rootVm) {\n if (_cachedVue) return _cachedVue;\n var Vue = rootVm.constructor;\n\n while (Vue.super) {\n Vue = Vue.super;\n }\n\n _cachedVue = Vue;\n return Vue;\n}\n\nvar validateModel = function validateModel(model, validations) {\n var Vue = getVue(model);\n\n var _getComponent = getComponent(Vue),\n Validation = _getComponent.Validation,\n VBase = _getComponent.VBase;\n\n var root = new VBase({\n computed: {\n children: function children() {\n var vals = typeof validations === 'function' ? validations.call(model) : validations;\n return [(0, _vval.h)(Validation, '$v', {\n validations: vals,\n lazyParentModel: NIL,\n prop: '$v',\n model: model,\n rootModel: model\n })];\n }\n }\n });\n return root;\n};\n\nvar validationMixin = {\n data: function data() {\n var vals = this.$options.validations;\n\n if (vals) {\n this._vuelidate = validateModel(this, vals);\n }\n\n return {};\n },\n beforeCreate: function beforeCreate() {\n var options = this.$options;\n var vals = options.validations;\n if (!vals) return;\n if (!options.computed) options.computed = {};\n if (options.computed.$v) return;\n\n options.computed.$v = function () {\n return this._vuelidate ? this._vuelidate.refs.$v.proxy : null;\n };\n },\n beforeDestroy: function beforeDestroy() {\n if (this._vuelidate) {\n this._vuelidate.$destroy();\n\n this._vuelidate = null;\n }\n }\n};\nexports.validationMixin = validationMixin;\n\nfunction Vuelidate(Vue) {\n Vue.mixin(validationMixin);\n}\n\nvar _default = Vuelidate;\nexports.default = _default;","var isObject = require('./_is-object');\nvar document = require('./_global').document;\n// typeof document.createElement is 'object' in old IE\nvar is = isObject(document) && isObject(document.createElement);\nmodule.exports = function (it) {\n return is ? document.createElement(it) : {};\n};\n","// https://rwaldron.github.io/proposal-math-extensions/\nvar $export = require('./_export');\n\n$export($export.S, 'Math', { RAD_PER_DEG: 180 / Math.PI });\n","// https://rwaldron.github.io/proposal-math-extensions/\nvar $export = require('./_export');\nvar scale = require('./_math-scale');\nvar fround = require('./_math-fround');\n\n$export($export.S, 'Math', {\n fscale: function fscale(x, inLow, inHigh, outLow, outHigh) {\n return fround(scale(x, inLow, inHigh, outLow, outHigh));\n }\n});\n","// call something on iterator step with safe closing on error\nvar anObject = require('./_an-object');\nmodule.exports = function (iterator, fn, value, entries) {\n try {\n return entries ? fn(anObject(value)[0], value[1]) : fn(value);\n // 7.4.6 IteratorClose(iterator, completion)\n } catch (e) {\n var ret = iterator['return'];\n if (ret !== undefined) anObject(ret.call(iterator));\n throw e;\n }\n};\n","\"use strict\";\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 */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar IllegalArgumentException_1 = require(\"../../IllegalArgumentException\");\nvar ModeValues;\n(function (ModeValues) {\n ModeValues[ModeValues[\"TERMINATOR\"] = 0] = \"TERMINATOR\";\n ModeValues[ModeValues[\"NUMERIC\"] = 1] = \"NUMERIC\";\n ModeValues[ModeValues[\"ALPHANUMERIC\"] = 2] = \"ALPHANUMERIC\";\n ModeValues[ModeValues[\"STRUCTURED_APPEND\"] = 3] = \"STRUCTURED_APPEND\";\n ModeValues[ModeValues[\"BYTE\"] = 4] = \"BYTE\";\n ModeValues[ModeValues[\"ECI\"] = 5] = \"ECI\";\n ModeValues[ModeValues[\"KANJI\"] = 6] = \"KANJI\";\n ModeValues[ModeValues[\"FNC1_FIRST_POSITION\"] = 7] = \"FNC1_FIRST_POSITION\";\n ModeValues[ModeValues[\"FNC1_SECOND_POSITION\"] = 8] = \"FNC1_SECOND_POSITION\";\n /** See GBT 18284-2000; \"Hanzi\" is a transliteration of this mode name. */\n ModeValues[ModeValues[\"HANZI\"] = 9] = \"HANZI\";\n})(ModeValues = exports.ModeValues || (exports.ModeValues = {}));\n/**\n *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 */\nvar Mode = /** @class */ (function () {\n function Mode(value, stringValue, characterCountBitsForVersions, bits /*int*/) {\n this.value = value;\n this.stringValue = stringValue;\n this.characterCountBitsForVersions = characterCountBitsForVersions;\n this.bits = bits;\n Mode.FOR_BITS.set(bits, this);\n Mode.FOR_VALUE.set(value, this);\n }\n /**\n * @param bits four bits encoding a QR Code data mode\n * @return Mode encoded by these bits\n * @throws IllegalArgumentException if bits do not correspond to a known mode\n */\n Mode.forBits = function (bits /*int*/) {\n var mode = Mode.FOR_BITS.get(bits);\n if (undefined === mode) {\n throw new IllegalArgumentException_1.default();\n }\n return mode;\n };\n /**\n * @param version version in question\n * @return number of bits used, in this QR Code symbol {@link Version}, to encode the\n * count of characters that will follow encoded in this Mode\n */\n Mode.prototype.getCharacterCountBits = function (version) {\n var versionNumber = version.getVersionNumber();\n var offset;\n if (versionNumber <= 9) {\n offset = 0;\n }\n else if (versionNumber <= 26) {\n offset = 1;\n }\n else {\n offset = 2;\n }\n return this.characterCountBitsForVersions[offset];\n };\n Mode.prototype.getValue = function () {\n return this.value;\n };\n Mode.prototype.getBits = function () {\n return this.bits;\n };\n Mode.prototype.equals = function (o) {\n if (!(o instanceof Mode)) {\n return false;\n }\n var other = o;\n return this.value === other.value;\n };\n Mode.prototype.toString = function () {\n return this.stringValue;\n };\n Mode.FOR_BITS = new Map();\n Mode.FOR_VALUE = new Map();\n Mode.TERMINATOR = new Mode(ModeValues.TERMINATOR, 'TERMINATOR', Int32Array.from([0, 0, 0]), 0x00); // Not really a mode...\n Mode.NUMERIC = new Mode(ModeValues.NUMERIC, 'NUMERIC', Int32Array.from([10, 12, 14]), 0x01);\n Mode.ALPHANUMERIC = new Mode(ModeValues.ALPHANUMERIC, 'ALPHANUMERIC', Int32Array.from([9, 11, 13]), 0x02);\n Mode.STRUCTURED_APPEND = new Mode(ModeValues.STRUCTURED_APPEND, 'STRUCTURED_APPEND', Int32Array.from([0, 0, 0]), 0x03); // Not supported\n Mode.BYTE = new Mode(ModeValues.BYTE, 'BYTE', Int32Array.from([8, 16, 16]), 0x04);\n Mode.ECI = new Mode(ModeValues.ECI, 'ECI', Int32Array.from([0, 0, 0]), 0x07); // character counts don't apply\n Mode.KANJI = new Mode(ModeValues.KANJI, 'KANJI', Int32Array.from([8, 10, 12]), 0x08);\n Mode.FNC1_FIRST_POSITION = new Mode(ModeValues.FNC1_FIRST_POSITION, 'FNC1_FIRST_POSITION', Int32Array.from([0, 0, 0]), 0x05);\n Mode.FNC1_SECOND_POSITION = new Mode(ModeValues.FNC1_SECOND_POSITION, 'FNC1_SECOND_POSITION', Int32Array.from([0, 0, 0]), 0x09);\n /** See GBT 18284-2000; \"Hanzi\" is a transliteration of this mode name. */\n Mode.HANZI = new Mode(ModeValues.HANZI, 'HANZI', Int32Array.from([8, 10, 12]), 0x0D);\n return Mode;\n}());\nexports.default = Mode;\n//# sourceMappingURL=Mode.js.map","'use strict';\n// 22.1.3.9 Array.prototype.findIndex(predicate, thisArg = undefined)\nvar $export = require('./_export');\nvar $find = require('./_array-methods')(6);\nvar KEY = 'findIndex';\nvar forced = true;\n// Shouldn't skip holes\nif (KEY in []) Array(1)[KEY](function () { forced = false; });\n$export($export.P + $export.F * forced, 'Array', {\n findIndex: function findIndex(callbackfn /* , that = undefined */) {\n return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n }\n});\nrequire('./_add-to-unscopables')(KEY);\n","\"use strict\";\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 */\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/*namespace com.google.zxing {*/\nrequire(\"./InvertedLuminanceSource\"); // required because of circular dependencies between LuminanceSource and InvertedLuminanceSource\nvar InvertedLuminanceSource_1 = require(\"./InvertedLuminanceSource\");\nvar LuminanceSource_1 = require(\"./LuminanceSource\");\nvar System_1 = require(\"./util/System\");\nvar IllegalArgumentException_1 = require(\"./IllegalArgumentException\");\n/**\n * This class is used to help decode images from files which arrive as RGB data from\n * an ARGB pixel array. It does not support rotation.\n *\n * @author dswitkin@google.com (Daniel Switkin)\n * @author Betaminos\n */\nvar RGBLuminanceSource = /** @class */ (function (_super) {\n __extends(RGBLuminanceSource, _super);\n function RGBLuminanceSource(luminances, width /*int*/, height /*int*/, dataWidth /*int*/, dataHeight /*int*/, left /*int*/, top /*int*/) {\n var _this = _super.call(this, width, height) || this;\n _this.dataWidth = dataWidth;\n _this.dataHeight = dataHeight;\n _this.left = left;\n _this.top = top;\n if (luminances.BYTES_PER_ELEMENT === 4) { // Int32Array\n var size = width * height;\n var luminancesUint8Array = new Uint8ClampedArray(size);\n for (var offset = 0; offset < size; offset++) {\n var pixel = luminances[offset];\n var r = (pixel >> 16) & 0xff; // red\n var g2 = (pixel >> 7) & 0x1fe; // 2 * green\n var b = pixel & 0xff; // blue\n // Calculate green-favouring average cheaply\n luminancesUint8Array[offset] = /*(byte) */ ((r + g2 + b) / 4) & 0xFF;\n }\n _this.luminances = luminancesUint8Array;\n }\n else {\n _this.luminances = luminances;\n }\n if (undefined === dataWidth) {\n _this.dataWidth = width;\n }\n if (undefined === dataHeight) {\n _this.dataHeight = height;\n }\n if (undefined === left) {\n _this.left = 0;\n }\n if (undefined === top) {\n _this.top = 0;\n }\n if (_this.left + width > _this.dataWidth || _this.top + height > _this.dataHeight) {\n throw new IllegalArgumentException_1.default('Crop rectangle does not fit within image data.');\n }\n return _this;\n }\n /*@Override*/\n RGBLuminanceSource.prototype.getRow = function (y /*int*/, row) {\n if (y < 0 || y >= this.getHeight()) {\n throw new IllegalArgumentException_1.default('Requested row is outside the image: ' + y);\n }\n var width = this.getWidth();\n if (row === null || row === undefined || row.length < width) {\n row = new Uint8ClampedArray(width);\n }\n var offset = (y + this.top) * this.dataWidth + this.left;\n System_1.default.arraycopy(this.luminances, offset, row, 0, width);\n return row;\n };\n /*@Override*/\n RGBLuminanceSource.prototype.getMatrix = function () {\n var width = this.getWidth();\n var height = this.getHeight();\n // If the caller asks for the entire underlying image, save the copy and give them the\n // original data. The docs specifically warn that result.length must be ignored.\n if (width === this.dataWidth && height === this.dataHeight) {\n return this.luminances;\n }\n var area = width * height;\n var matrix = new Uint8ClampedArray(area);\n var inputOffset = this.top * this.dataWidth + this.left;\n // If the width matches the full width of the underlying data, perform a single copy.\n if (width === this.dataWidth) {\n System_1.default.arraycopy(this.luminances, inputOffset, matrix, 0, area);\n return matrix;\n }\n // Otherwise copy one cropped row at a time.\n for (var y = 0; y < height; y++) {\n var outputOffset = y * width;\n System_1.default.arraycopy(this.luminances, inputOffset, matrix, outputOffset, width);\n inputOffset += this.dataWidth;\n }\n return matrix;\n };\n /*@Override*/\n RGBLuminanceSource.prototype.isCropSupported = function () {\n return true;\n };\n /*@Override*/\n RGBLuminanceSource.prototype.crop = function (left /*int*/, top /*int*/, width /*int*/, height /*int*/) {\n return new RGBLuminanceSource(this.luminances, width, height, this.dataWidth, this.dataHeight, this.left + left, this.top + top);\n };\n RGBLuminanceSource.prototype.invert = function () {\n return new InvertedLuminanceSource_1.default(this);\n };\n return RGBLuminanceSource;\n}(LuminanceSource_1.default));\nexports.default = RGBLuminanceSource;\n//# sourceMappingURL=RGBLuminanceSource.js.map","\"use strict\";\n/*\n * Copyright (C) 2012 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 */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar BarcodeFormat_1 = require(\"../BarcodeFormat\");\nvar UPCEANReader_1 = require(\"./UPCEANReader\");\nvar Result_1 = require(\"../Result\");\nvar ResultPoint_1 = require(\"../ResultPoint\");\nvar ResultMetadataType_1 = require(\"../ResultMetadataType\");\nvar NotFoundException_1 = require(\"../NotFoundException\");\n/**\n * @see UPCEANExtension5Support\n */\nvar UPCEANExtension2Support = /** @class */ (function () {\n function UPCEANExtension2Support() {\n this.decodeMiddleCounters = [0, 0, 0, 0];\n this.decodeRowStringBuffer = '';\n }\n UPCEANExtension2Support.prototype.decodeRow = function (rowNumber, row, extensionStartRange) {\n var result = this.decodeRowStringBuffer;\n var end = this.decodeMiddle(row, extensionStartRange, result);\n var resultString = result.toString();\n var extensionData = UPCEANExtension2Support.parseExtensionString(resultString);\n var resultPoints = [\n new ResultPoint_1.default((extensionStartRange[0] + extensionStartRange[1]) / 2.0, rowNumber),\n new ResultPoint_1.default(end, rowNumber)\n ];\n var extensionResult = new Result_1.default(resultString, null, 0, resultPoints, BarcodeFormat_1.default.UPC_EAN_EXTENSION, new Date().getTime());\n if (extensionData != null) {\n extensionResult.putAllMetadata(extensionData);\n }\n return extensionResult;\n };\n UPCEANExtension2Support.prototype.decodeMiddle = function (row, startRange, resultString) {\n var counters = this.decodeMiddleCounters;\n counters[0] = 0;\n counters[1] = 0;\n counters[2] = 0;\n counters[3] = 0;\n var end = row.getSize();\n var rowOffset = startRange[1];\n var checkParity = 0;\n for (var x = 0; x < 2 && rowOffset < end; x++) {\n var bestMatch = UPCEANReader_1.default.decodeDigit(row, counters, rowOffset, UPCEANReader_1.default.L_AND_G_PATTERNS);\n resultString += String.fromCharCode(('0'.charCodeAt(0) + bestMatch % 10));\n for (var _i = 0, counters_1 = counters; _i < counters_1.length; _i++) {\n var counter = counters_1[_i];\n rowOffset += counter;\n }\n if (bestMatch >= 10) {\n checkParity |= 1 << (1 - x);\n }\n if (x !== 1) {\n // Read off separator if not last\n rowOffset = row.getNextSet(rowOffset);\n rowOffset = row.getNextUnset(rowOffset);\n }\n }\n if (resultString.length !== 2) {\n throw new NotFoundException_1.default();\n }\n if (parseInt(resultString.toString()) % 4 !== checkParity) {\n throw new NotFoundException_1.default();\n }\n return rowOffset;\n };\n UPCEANExtension2Support.parseExtensionString = function (raw) {\n if (raw.length !== 2) {\n return null;\n }\n return new Map([[ResultMetadataType_1.default.ISSUE_NUMBER, parseInt(raw)]]);\n };\n return UPCEANExtension2Support;\n}());\nexports.default = UPCEANExtension2Support;\n//# sourceMappingURL=UPCEANExtension2Support.js.map","'use strict';\nrequire('./es6.regexp.exec');\nvar redefine = require('./_redefine');\nvar hide = require('./_hide');\nvar fails = require('./_fails');\nvar defined = require('./_defined');\nvar wks = require('./_wks');\nvar regexpExec = require('./_regexp-exec');\n\nvar SPECIES = wks('species');\n\nvar REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () {\n // #replace needs built-in support for named groups.\n // #match works fine because it just return the exec results, even if it has\n // a \"grops\" property.\n var re = /./;\n re.exec = function () {\n var result = [];\n result.groups = { a: '7' };\n return result;\n };\n return ''.replace(re, '$') !== '7';\n});\n\nvar SPLIT_WORKS_WITH_OVERWRITTEN_EXEC = (function () {\n // Chrome 51 has a buggy \"split\" implementation when RegExp#exec !== nativeExec\n var re = /(?:)/;\n var originalExec = re.exec;\n re.exec = function () { return originalExec.apply(this, arguments); };\n var result = 'ab'.split(re);\n return result.length === 2 && result[0] === 'a' && result[1] === 'b';\n})();\n\nmodule.exports = function (KEY, length, exec) {\n var SYMBOL = wks(KEY);\n\n var DELEGATES_TO_SYMBOL = !fails(function () {\n // String methods call symbol-named RegEp methods\n var O = {};\n O[SYMBOL] = function () { return 7; };\n return ''[KEY](O) != 7;\n });\n\n var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL ? !fails(function () {\n // Symbol-named RegExp methods call .exec\n var execCalled = false;\n var re = /a/;\n re.exec = function () { execCalled = true; return null; };\n if (KEY === 'split') {\n // RegExp[@@split] doesn't call the regex's exec method, but first creates\n // a new one. We need to return the patched regex when creating the new one.\n re.constructor = {};\n re.constructor[SPECIES] = function () { return re; };\n }\n re[SYMBOL]('');\n return !execCalled;\n }) : undefined;\n\n if (\n !DELEGATES_TO_SYMBOL ||\n !DELEGATES_TO_EXEC ||\n (KEY === 'replace' && !REPLACE_SUPPORTS_NAMED_GROUPS) ||\n (KEY === 'split' && !SPLIT_WORKS_WITH_OVERWRITTEN_EXEC)\n ) {\n var nativeRegExpMethod = /./[SYMBOL];\n var fns = exec(\n defined,\n SYMBOL,\n ''[KEY],\n function maybeCallNative(nativeMethod, regexp, str, arg2, forceStringMethod) {\n if (regexp.exec === regexpExec) {\n if (DELEGATES_TO_SYMBOL && !forceStringMethod) {\n // The native String method already delegates to @@method (this\n // polyfilled function), leasing to infinite recursion.\n // We avoid it by directly calling the native @@method method.\n return { done: true, value: nativeRegExpMethod.call(regexp, str, arg2) };\n }\n return { done: true, value: nativeMethod.call(str, regexp, arg2) };\n }\n return { done: false };\n }\n );\n var strfn = fns[0];\n var rxfn = fns[1];\n\n redefine(String.prototype, KEY, strfn);\n hide(RegExp.prototype, SYMBOL, length == 2\n // 21.2.5.8 RegExp.prototype[@@replace](string, replaceValue)\n // 21.2.5.11 RegExp.prototype[@@split](string, limit)\n ? function (string, arg) { return rxfn.call(string, this, arg); }\n // 21.2.5.6 RegExp.prototype[@@match](string)\n // 21.2.5.9 RegExp.prototype[@@search](string)\n : function (string) { return rxfn.call(string, this); }\n );\n }\n};\n","'use strict';\nvar isObject = require('./_is-object');\nvar getPrototypeOf = require('./_object-gpo');\nvar HAS_INSTANCE = require('./_wks')('hasInstance');\nvar FunctionProto = Function.prototype;\n// 19.2.3.6 Function.prototype[@@hasInstance](V)\nif (!(HAS_INSTANCE in FunctionProto)) require('./_object-dp').f(FunctionProto, HAS_INSTANCE, { value: function (O) {\n if (typeof this != 'function' || !isObject(O)) return false;\n if (!isObject(this.prototype)) return O instanceof this;\n // for environment w/o native `@@hasInstance` logic enough `instanceof`, but add this:\n while (O = getPrototypeOf(O)) if (this.prototype === O) return true;\n return false;\n} });\n","// 26.1.10 Reflect.isExtensible(target)\nvar $export = require('./_export');\nvar anObject = require('./_an-object');\nvar $isExtensible = Object.isExtensible;\n\n$export($export.S, 'Reflect', {\n isExtensible: function isExtensible(target) {\n anObject(target);\n return $isExtensible ? $isExtensible(target) : true;\n }\n});\n","\"use strict\";\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 */\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/*namespace com.google.zxing.common {*/\nvar Binarizer_1 = require(\"../Binarizer\");\nvar BitArray_1 = require(\"./BitArray\");\nvar BitMatrix_1 = require(\"./BitMatrix\");\nvar NotFoundException_1 = require(\"../NotFoundException\");\n/**\n * This Binarizer implementation uses the old ZXing global histogram approach. It is suitable\n * for low-end mobile devices which don't have enough CPU or memory to use a local thresholding\n * algorithm. However, because it picks a global black point, it cannot handle difficult shadows\n * and gradients.\n *\n * Faster mobile devices and all desktop applications should probably use HybridBinarizer instead.\n *\n * @author dswitkin@google.com (Daniel Switkin)\n * @author Sean Owen\n */\nvar GlobalHistogramBinarizer = /** @class */ (function (_super) {\n __extends(GlobalHistogramBinarizer, _super);\n function GlobalHistogramBinarizer(source) {\n var _this = _super.call(this, source) || this;\n _this.luminances = GlobalHistogramBinarizer.EMPTY;\n _this.buckets = new Int32Array(GlobalHistogramBinarizer.LUMINANCE_BUCKETS);\n return _this;\n }\n // Applies simple sharpening to the row data to improve performance of the 1D Readers.\n /*@Override*/\n GlobalHistogramBinarizer.prototype.getBlackRow = function (y /*int*/, row) {\n var source = this.getLuminanceSource();\n var width = source.getWidth();\n if (row === undefined || row === null || row.getSize() < width) {\n row = new BitArray_1.default(width);\n }\n else {\n row.clear();\n }\n this.initArrays(width);\n var localLuminances = source.getRow(y, this.luminances);\n var localBuckets = this.buckets;\n for (var x = 0; x < width; x++) {\n localBuckets[(localLuminances[x] & 0xff) >> GlobalHistogramBinarizer.LUMINANCE_SHIFT]++;\n }\n var blackPoint = GlobalHistogramBinarizer.estimateBlackPoint(localBuckets);\n if (width < 3) {\n // Special case for very small images\n for (var x = 0; x < width; x++) {\n if ((localLuminances[x] & 0xff) < blackPoint) {\n row.set(x);\n }\n }\n }\n else {\n var left = localLuminances[0] & 0xff;\n var center = localLuminances[1] & 0xff;\n for (var x = 1; x < width - 1; x++) {\n var right = localLuminances[x + 1] & 0xff;\n // A simple -1 4 -1 box filter with a weight of 2.\n if (((center * 4) - left - right) / 2 < blackPoint) {\n row.set(x);\n }\n left = center;\n center = right;\n }\n }\n return row;\n };\n // Does not sharpen the data, as this call is intended to only be used by 2D Readers.\n /*@Override*/\n GlobalHistogramBinarizer.prototype.getBlackMatrix = function () {\n var source = this.getLuminanceSource();\n var width = source.getWidth();\n var height = source.getHeight();\n var matrix = new BitMatrix_1.default(width, height);\n // Quickly calculates the histogram by sampling four rows from the image. This proved to be\n // more robust on the blackbox tests than sampling a diagonal as we used to do.\n this.initArrays(width);\n var localBuckets = this.buckets;\n for (var y = 1; y < 5; y++) {\n var row = height * y / 5;\n var localLuminances_1 = source.getRow(row, this.luminances);\n var right = Math.floor((width * 4) / 5);\n for (var x = Math.floor(width / 5); x < right; x++) {\n var pixel = localLuminances_1[x] & 0xff;\n localBuckets[pixel >> GlobalHistogramBinarizer.LUMINANCE_SHIFT]++;\n }\n }\n var blackPoint = GlobalHistogramBinarizer.estimateBlackPoint(localBuckets);\n // We delay reading the entire image luminance until the black point estimation succeeds.\n // Although we end up reading four rows twice, it is consistent with our motto of\n // \"fail quickly\" which is necessary for continuous scanning.\n var localLuminances = source.getMatrix();\n for (var y = 0; y < height; y++) {\n var offset = y * width;\n for (var x = 0; x < width; x++) {\n var pixel = localLuminances[offset + x] & 0xff;\n if (pixel < blackPoint) {\n matrix.set(x, y);\n }\n }\n }\n return matrix;\n };\n /*@Override*/\n GlobalHistogramBinarizer.prototype.createBinarizer = function (source) {\n return new GlobalHistogramBinarizer(source);\n };\n GlobalHistogramBinarizer.prototype.initArrays = function (luminanceSize /*int*/) {\n if (this.luminances.length < luminanceSize) {\n this.luminances = new Uint8ClampedArray(luminanceSize);\n }\n var buckets = this.buckets;\n for (var x = 0; x < GlobalHistogramBinarizer.LUMINANCE_BUCKETS; x++) {\n buckets[x] = 0;\n }\n };\n GlobalHistogramBinarizer.estimateBlackPoint = function (buckets) {\n // Find the tallest peak in the histogram.\n var numBuckets = buckets.length;\n var maxBucketCount = 0;\n var firstPeak = 0;\n var firstPeakSize = 0;\n for (var x = 0; x < numBuckets; x++) {\n if (buckets[x] > firstPeakSize) {\n firstPeak = x;\n firstPeakSize = buckets[x];\n }\n if (buckets[x] > maxBucketCount) {\n maxBucketCount = buckets[x];\n }\n }\n // Find the second-tallest peak which is somewhat far from the tallest peak.\n var secondPeak = 0;\n var secondPeakScore = 0;\n for (var x = 0; x < numBuckets; x++) {\n var distanceToBiggest = x - firstPeak;\n // Encourage more distant second peaks by multiplying by square of distance.\n var score = buckets[x] * distanceToBiggest * distanceToBiggest;\n if (score > secondPeakScore) {\n secondPeak = x;\n secondPeakScore = score;\n }\n }\n // Make sure firstPeak corresponds to the black peak.\n if (firstPeak > secondPeak) {\n var temp = firstPeak;\n firstPeak = secondPeak;\n secondPeak = temp;\n }\n // If there is too little contrast in the image to pick a meaningful black point, throw rather\n // than waste time trying to decode the image, and risk false positives.\n if (secondPeak - firstPeak <= numBuckets / 16) {\n throw new NotFoundException_1.default();\n }\n // Find a valley between them that is low and closer to the white peak.\n var bestValley = secondPeak - 1;\n var bestValleyScore = -1;\n for (var x = secondPeak - 1; x > firstPeak; x--) {\n var fromFirst = x - firstPeak;\n var score = fromFirst * fromFirst * (secondPeak - x) * (maxBucketCount - buckets[x]);\n if (score > bestValleyScore) {\n bestValley = x;\n bestValleyScore = score;\n }\n }\n return bestValley << GlobalHistogramBinarizer.LUMINANCE_SHIFT;\n };\n GlobalHistogramBinarizer.LUMINANCE_BITS = 5;\n GlobalHistogramBinarizer.LUMINANCE_SHIFT = 8 - GlobalHistogramBinarizer.LUMINANCE_BITS;\n GlobalHistogramBinarizer.LUMINANCE_BUCKETS = 1 << GlobalHistogramBinarizer.LUMINANCE_BITS;\n GlobalHistogramBinarizer.EMPTY = Uint8ClampedArray.from([0]);\n return GlobalHistogramBinarizer;\n}(Binarizer_1.default));\nexports.default = GlobalHistogramBinarizer;\n//# sourceMappingURL=GlobalHistogramBinarizer.js.map","var isObject = require('./_is-object');\nvar document = require('./_global').document;\n// typeof document.createElement is 'object' in old IE\nvar is = isObject(document) && isObject(document.createElement);\nmodule.exports = function (it) {\n return is ? document.createElement(it) : {};\n};\n","// 26.1.2 Reflect.construct(target, argumentsList [, newTarget])\nvar $export = require('./_export');\nvar create = require('./_object-create');\nvar aFunction = require('./_a-function');\nvar anObject = require('./_an-object');\nvar isObject = require('./_is-object');\nvar fails = require('./_fails');\nvar bind = require('./_bind');\nvar rConstruct = (require('./_global').Reflect || {}).construct;\n\n// MS Edge supports only 2 arguments and argumentsList argument is optional\n// FF Nightly sets third argument as `new.target`, but does not create `this` from it\nvar NEW_TARGET_BUG = fails(function () {\n function F() { /* empty */ }\n return !(rConstruct(function () { /* empty */ }, [], F) instanceof F);\n});\nvar ARGS_BUG = !fails(function () {\n rConstruct(function () { /* empty */ });\n});\n\n$export($export.S + $export.F * (NEW_TARGET_BUG || ARGS_BUG), 'Reflect', {\n construct: function construct(Target, args /* , newTarget */) {\n aFunction(Target);\n anObject(args);\n var newTarget = arguments.length < 3 ? Target : aFunction(arguments[2]);\n if (ARGS_BUG && !NEW_TARGET_BUG) return rConstruct(Target, args, newTarget);\n if (Target == newTarget) {\n // w/o altered newTarget, optimization for 0-4 arguments\n switch (args.length) {\n case 0: return new Target();\n case 1: return new Target(args[0]);\n case 2: return new Target(args[0], args[1]);\n case 3: return new Target(args[0], args[1], args[2]);\n case 4: return new Target(args[0], args[1], args[2], args[3]);\n }\n // w/o altered newTarget, lot of arguments case\n var $args = [null];\n $args.push.apply($args, args);\n return new (bind.apply(Target, $args))();\n }\n // with altered newTarget, not support built-in constructors\n var proto = newTarget.prototype;\n var instance = create(isObject(proto) ? proto : Object.prototype);\n var result = Function.apply.call(Target, instance, args);\n return isObject(result) ? result : instance;\n }\n});\n","'use strict';\n// https://github.com/sebmarkbage/ecmascript-string-left-right-trim\nrequire('./_string-trim')('trimLeft', function ($trim) {\n return function trimLeft() {\n return $trim(this, 1);\n };\n}, 'trimStart');\n","'use strict';\nvar $export = require('./_export');\nvar html = require('./_html');\nvar cof = require('./_cof');\nvar toAbsoluteIndex = require('./_to-absolute-index');\nvar toLength = require('./_to-length');\nvar arraySlice = [].slice;\n\n// fallback for not array-like ES3 strings and DOM objects\n$export($export.P + $export.F * require('./_fails')(function () {\n if (html) arraySlice.call(html);\n}), 'Array', {\n slice: function slice(begin, end) {\n var len = toLength(this.length);\n var klass = cof(this);\n end = end === undefined ? len : end;\n if (klass == 'Array') return arraySlice.call(this, begin, end);\n var start = toAbsoluteIndex(begin, len);\n var upTo = toAbsoluteIndex(end, len);\n var size = toLength(upTo - start);\n var cloned = new Array(size);\n var i = 0;\n for (; i < size; i++) cloned[i] = klass == 'String'\n ? this.charAt(start + i)\n : this[start + i];\n return cloned;\n }\n});\n","// getting tag from 19.1.3.6 Object.prototype.toString()\nvar cof = require('./_cof');\nvar TAG = require('./_wks')('toStringTag');\n// ES3 wrong here\nvar ARG = cof(function () { return arguments; }()) == 'Arguments';\n\n// fallback for IE11 Script Access Denied error\nvar tryGet = function (it, key) {\n try {\n return it[key];\n } catch (e) { /* empty */ }\n};\n\nmodule.exports = function (it) {\n var O, T, B;\n return it === undefined ? 'Undefined' : it === null ? 'Null'\n // @@toStringTag case\n : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T\n // builtinTag case\n : ARG ? cof(O)\n // ES3 arguments fallback\n : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;\n};\n","// 7.1.13 ToObject(argument)\nvar defined = require('./_defined');\nmodule.exports = function (it) {\n return Object(defined(it));\n};\n","\"use strict\";\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 */\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/*namespace com.google.zxing.qrcode.encoder {*/\nvar EncodeHintType_1 = require(\"../../EncodeHintType\");\nvar BitArray_1 = require(\"../../common/BitArray\");\nvar CharacterSetECI_1 = require(\"../../common/CharacterSetECI\");\nvar GenericGF_1 = require(\"../../common/reedsolomon/GenericGF\");\nvar ReedSolomonEncoder_1 = require(\"../../common/reedsolomon/ReedSolomonEncoder\");\nvar Mode_1 = require(\"../decoder/Mode\");\nvar Version_1 = require(\"../decoder/Version\");\nvar MaskUtil_1 = require(\"./MaskUtil\");\nvar ByteMatrix_1 = require(\"./ByteMatrix\");\nvar QRCode_1 = require(\"./QRCode\");\nvar MatrixUtil_1 = require(\"./MatrixUtil\");\nvar StringEncoding_1 = require(\"../../util/StringEncoding\");\nvar BlockPair_1 = require(\"./BlockPair\");\nvar WriterException_1 = require(\"../../WriterException\");\n/*import java.io.UnsupportedEncodingException;*/\n/*import java.util.ArrayList;*/\n/*import java.util.Collection;*/\n/*import java.util.Map;*/\n/**\n * @author satorux@google.com (Satoru Takabayashi) - creator\n * @author dswitkin@google.com (Daniel Switkin) - ported from C++\n */\nvar Encoder = /** @class */ (function () {\n // TYPESCRIPTPORT: changed to UTF8, the default for js\n function Encoder() {\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 Encoder.calculateMaskPenalty = function (matrix) {\n return MaskUtil_1.default.applyMaskPenaltyRule1(matrix)\n + MaskUtil_1.default.applyMaskPenaltyRule2(matrix)\n + MaskUtil_1.default.applyMaskPenaltyRule3(matrix)\n + MaskUtil_1.default.applyMaskPenaltyRule4(matrix);\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 Encoder.encode = function (content, ecLevel, hints) {\n if (hints === void 0) { hints = null; }\n // Determine what character encoding has been specified by the caller, if any\n var encoding = Encoder.DEFAULT_BYTE_MODE_ENCODING;\n var hasEncodingHint = hints !== null && undefined !== hints.get(EncodeHintType_1.default.CHARACTER_SET);\n if (hasEncodingHint) {\n encoding = hints.get(EncodeHintType_1.default.CHARACTER_SET).toString();\n }\n // Pick an encoding mode appropriate for the content. Note that this will not attempt to use\n // multiple modes / segments even if that were more efficient. Twould be nice.\n var mode = this.chooseMode(content, encoding);\n // This will store the header information, like mode and\n // length, as well as \"header\" segments like an ECI segment.\n var headerBits = new BitArray_1.default();\n // Append ECI segment if applicable\n if (mode === Mode_1.default.BYTE && (hasEncodingHint || Encoder.DEFAULT_BYTE_MODE_ENCODING !== encoding)) {\n var eci = CharacterSetECI_1.default.getCharacterSetECIByName(encoding);\n if (eci !== undefined) {\n this.appendECI(eci, headerBits);\n }\n }\n // (With ECI in place,) Write the mode marker\n this.appendModeInfo(mode, headerBits);\n // Collect data within the main segment, separately, to count its size if needed. Don't add it to\n // main payload yet.\n var dataBits = new BitArray_1.default();\n this.appendBytes(content, mode, dataBits, encoding);\n var version;\n if (hints !== null && undefined !== hints.get(EncodeHintType_1.default.QR_VERSION)) {\n var versionNumber = Number.parseInt(hints.get(EncodeHintType_1.default.QR_VERSION).toString(), 10);\n version = Version_1.default.getVersionForNumber(versionNumber);\n var bitsNeeded = this.calculateBitsNeeded(mode, headerBits, dataBits, version);\n if (!this.willFit(bitsNeeded, version, ecLevel)) {\n throw new WriterException_1.default('Data too big for requested version');\n }\n }\n else {\n version = this.recommendVersion(ecLevel, mode, headerBits, dataBits);\n }\n var headerAndDataBits = new BitArray_1.default();\n headerAndDataBits.appendBitArray(headerBits);\n // Find \"length\" of main segment and write it\n var numLetters = mode === Mode_1.default.BYTE ? dataBits.getSizeInBytes() : content.length;\n this.appendLengthInfo(numLetters, version, mode, headerAndDataBits);\n // Put data together into the overall payload\n headerAndDataBits.appendBitArray(dataBits);\n var ecBlocks = version.getECBlocksForLevel(ecLevel);\n var numDataBytes = version.getTotalCodewords() - ecBlocks.getTotalECCodewords();\n // Terminate the bits properly.\n this.terminateBits(numDataBytes, headerAndDataBits);\n // Interleave data bits with error correction code.\n var finalBits = this.interleaveWithECBytes(headerAndDataBits, version.getTotalCodewords(), numDataBytes, ecBlocks.getNumBlocks());\n var qrCode = new QRCode_1.default();\n qrCode.setECLevel(ecLevel);\n qrCode.setMode(mode);\n qrCode.setVersion(version);\n // Choose the mask pattern and set to \"qrCode\".\n var dimension = version.getDimensionForVersion();\n var matrix = new ByteMatrix_1.default(dimension, dimension);\n var maskPattern = this.chooseMaskPattern(finalBits, ecLevel, version, matrix);\n qrCode.setMaskPattern(maskPattern);\n // Build the matrix and set it to \"qrCode\".\n MatrixUtil_1.default.buildMatrix(finalBits, ecLevel, version, maskPattern, matrix);\n qrCode.setMatrix(matrix);\n return qrCode;\n };\n /**\n * Decides the smallest version of QR code that will contain all of the provided data.\n *\n * @throws WriterException if the data cannot fit in any version\n */\n Encoder.recommendVersion = function (ecLevel, mode, headerBits, dataBits) {\n // Hard part: need to know version to know how many bits length takes. But need to know how many\n // bits it takes to know version. First we take a guess at version by assuming version will be\n // the minimum, 1:\n var provisionalBitsNeeded = this.calculateBitsNeeded(mode, headerBits, dataBits, Version_1.default.getVersionForNumber(1));\n var provisionalVersion = this.chooseVersion(provisionalBitsNeeded, ecLevel);\n // Use that guess to calculate the right version. I am still not sure this works in 100% of cases.\n var bitsNeeded = this.calculateBitsNeeded(mode, headerBits, dataBits, provisionalVersion);\n return this.chooseVersion(bitsNeeded, ecLevel);\n };\n Encoder.calculateBitsNeeded = function (mode, headerBits, dataBits, version) {\n return headerBits.getSize() + mode.getCharacterCountBits(version) + dataBits.getSize();\n };\n /**\n * @return the code point of the table used in alphanumeric mode or\n * -1 if there is no corresponding code in the table.\n */\n Encoder.getAlphanumericCode = function (code /*int*/) {\n if (code < Encoder.ALPHANUMERIC_TABLE.length) {\n return Encoder.ALPHANUMERIC_TABLE[code];\n }\n return -1;\n };\n // public static chooseMode(content: string): Mode {\n // return chooseMode(content, null);\n // }\n /**\n * Choose the best mode by examining the content. Note that 'encoding' is used as a hint;\n * if it is Shift_JIS, and the input is only double-byte Kanji, then we return {@link Mode#KANJI}.\n */\n Encoder.chooseMode = function (content, encoding) {\n if (encoding === void 0) { encoding = null; }\n if (CharacterSetECI_1.default.SJIS.getName() === encoding && this.isOnlyDoubleByteKanji(content)) {\n // Choose Kanji mode if all input are double-byte characters\n return Mode_1.default.KANJI;\n }\n var hasNumeric = false;\n var hasAlphanumeric = false;\n for (var i = 0, length_1 = content.length; i < length_1; ++i) {\n var c = content.charAt(i);\n if (Encoder.isDigit(c)) {\n hasNumeric = true;\n }\n else if (this.getAlphanumericCode(c.charCodeAt(0)) !== -1) {\n hasAlphanumeric = true;\n }\n else {\n return Mode_1.default.BYTE;\n }\n }\n if (hasAlphanumeric) {\n return Mode_1.default.ALPHANUMERIC;\n }\n if (hasNumeric) {\n return Mode_1.default.NUMERIC;\n }\n return Mode_1.default.BYTE;\n };\n Encoder.isOnlyDoubleByteKanji = function (content) {\n var bytes;\n try {\n bytes = StringEncoding_1.default.encode(content, CharacterSetECI_1.default.SJIS); // content.getBytes(\"Shift_JIS\"))\n }\n catch (ignored /*: UnsupportedEncodingException*/) {\n return false;\n }\n var length = bytes.length;\n if (length % 2 !== 0) {\n return false;\n }\n for (var i = 0; i < length; i += 2) {\n var byte1 = bytes[i] & 0xFF;\n if ((byte1 < 0x81 || byte1 > 0x9F) && (byte1 < 0xE0 || byte1 > 0xEB)) {\n return false;\n }\n }\n return true;\n };\n Encoder.chooseMaskPattern = function (bits, ecLevel, version, matrix) {\n var minPenalty = Number.MAX_SAFE_INTEGER; // Lower penalty is better.\n var bestMaskPattern = -1;\n // We try all mask patterns to choose the best one.\n for (var maskPattern = 0; maskPattern < QRCode_1.default.NUM_MASK_PATTERNS; maskPattern++) {\n MatrixUtil_1.default.buildMatrix(bits, ecLevel, version, maskPattern, matrix);\n var penalty = this.calculateMaskPenalty(matrix);\n if (penalty < minPenalty) {\n minPenalty = penalty;\n bestMaskPattern = maskPattern;\n }\n }\n return bestMaskPattern;\n };\n Encoder.chooseVersion = function (numInputBits /*int*/, ecLevel) {\n for (var versionNum = 1; versionNum <= 40; versionNum++) {\n var version = Version_1.default.getVersionForNumber(versionNum);\n if (Encoder.willFit(numInputBits, version, ecLevel)) {\n return version;\n }\n }\n throw new WriterException_1.default('Data too big');\n };\n /**\n * @return true if the number of input bits will fit in a code with the specified version and\n * error correction level.\n */\n Encoder.willFit = function (numInputBits /*int*/, version, ecLevel) {\n // In the following comments, we use numbers of Version 7-H.\n // numBytes = 196\n var numBytes = version.getTotalCodewords();\n // getNumECBytes = 130\n var ecBlocks = version.getECBlocksForLevel(ecLevel);\n var numEcBytes = ecBlocks.getTotalECCodewords();\n // getNumDataBytes = 196 - 130 = 66\n var numDataBytes = numBytes - numEcBytes;\n var totalInputBytes = (numInputBits + 7) / 8;\n return numDataBytes >= totalInputBytes;\n };\n /**\n * Terminate bits as described in 8.4.8 and 8.4.9 of JISX0510:2004 (p.24).\n */\n Encoder.terminateBits = function (numDataBytes /*int*/, bits) {\n var capacity = numDataBytes * 8;\n if (bits.getSize() > capacity) {\n throw new WriterException_1.default('data bits cannot fit in the QR Code' + bits.getSize() + ' > ' +\n capacity);\n }\n for (var i = 0; i < 4 && bits.getSize() < capacity; ++i) {\n bits.appendBit(false);\n }\n // Append termination bits. See 8.4.8 of JISX0510:2004 (p.24) for details.\n // If the last byte isn't 8-bit aligned, we'll add padding bits.\n var numBitsInLastByte = bits.getSize() & 0x07;\n if (numBitsInLastByte > 0) {\n for (var i = numBitsInLastByte; i < 8; i++) {\n bits.appendBit(false);\n }\n }\n // If we have more space, we'll fill the space with padding patterns defined in 8.4.9 (p.24).\n var numPaddingBytes = numDataBytes - bits.getSizeInBytes();\n for (var i = 0; i < numPaddingBytes; ++i) {\n bits.appendBits((i & 0x01) === 0 ? 0xEC : 0x11, 8);\n }\n if (bits.getSize() !== capacity) {\n throw new WriterException_1.default('Bits size does not equal capacity');\n }\n };\n /**\n * Get number of data bytes and number of error correction bytes for block id \"blockID\". Store\n * the result in \"numDataBytesInBlock\", and \"numECBytesInBlock\". See table 12 in 8.5.1 of\n * JISX0510:2004 (p.30)\n */\n Encoder.getNumDataBytesAndNumECBytesForBlockID = function (numTotalBytes /*int*/, numDataBytes /*int*/, numRSBlocks /*int*/, blockID /*int*/, numDataBytesInBlock, numECBytesInBlock) {\n if (blockID >= numRSBlocks) {\n throw new WriterException_1.default('Block ID too large');\n }\n // numRsBlocksInGroup2 = 196 % 5 = 1\n var numRsBlocksInGroup2 = numTotalBytes % numRSBlocks;\n // numRsBlocksInGroup1 = 5 - 1 = 4\n var numRsBlocksInGroup1 = numRSBlocks - numRsBlocksInGroup2;\n // numTotalBytesInGroup1 = 196 / 5 = 39\n var numTotalBytesInGroup1 = Math.floor(numTotalBytes / numRSBlocks);\n // numTotalBytesInGroup2 = 39 + 1 = 40\n var numTotalBytesInGroup2 = numTotalBytesInGroup1 + 1;\n // numDataBytesInGroup1 = 66 / 5 = 13\n var numDataBytesInGroup1 = Math.floor(numDataBytes / numRSBlocks);\n // numDataBytesInGroup2 = 13 + 1 = 14\n var numDataBytesInGroup2 = numDataBytesInGroup1 + 1;\n // numEcBytesInGroup1 = 39 - 13 = 26\n var numEcBytesInGroup1 = numTotalBytesInGroup1 - numDataBytesInGroup1;\n // numEcBytesInGroup2 = 40 - 14 = 26\n var numEcBytesInGroup2 = numTotalBytesInGroup2 - numDataBytesInGroup2;\n // Sanity checks.\n // 26 = 26\n if (numEcBytesInGroup1 !== numEcBytesInGroup2) {\n throw new WriterException_1.default('EC bytes mismatch');\n }\n // 5 = 4 + 1.\n if (numRSBlocks !== numRsBlocksInGroup1 + numRsBlocksInGroup2) {\n throw new WriterException_1.default('RS blocks mismatch');\n }\n // 196 = (13 + 26) * 4 + (14 + 26) * 1\n if (numTotalBytes !==\n ((numDataBytesInGroup1 + numEcBytesInGroup1) *\n numRsBlocksInGroup1) +\n ((numDataBytesInGroup2 + numEcBytesInGroup2) *\n numRsBlocksInGroup2)) {\n throw new WriterException_1.default('Total bytes mismatch');\n }\n if (blockID < numRsBlocksInGroup1) {\n numDataBytesInBlock[0] = numDataBytesInGroup1;\n numECBytesInBlock[0] = numEcBytesInGroup1;\n }\n else {\n numDataBytesInBlock[0] = numDataBytesInGroup2;\n numECBytesInBlock[0] = numEcBytesInGroup2;\n }\n };\n /**\n * Interleave \"bits\" with corresponding error correction bytes. On success, store the result in\n * \"result\". The interleave rule is complicated. See 8.6 of JISX0510:2004 (p.37) for details.\n */\n Encoder.interleaveWithECBytes = function (bits, numTotalBytes /*int*/, numDataBytes /*int*/, numRSBlocks /*int*/) {\n // \"bits\" must have \"getNumDataBytes\" bytes of data.\n if (bits.getSizeInBytes() !== numDataBytes) {\n throw new WriterException_1.default('Number of bits and data bytes does not match');\n }\n // Step 1. Divide data bytes into blocks and generate error correction bytes for them. We'll\n // store the divided data bytes blocks and error correction bytes blocks into \"blocks\".\n var dataBytesOffset = 0;\n var maxNumDataBytes = 0;\n var maxNumEcBytes = 0;\n // Since, we know the number of reedsolmon blocks, we can initialize the vector with the number.\n var blocks = new Array(); // new Array, or missing
. Bailing hydration and performing ' +\n 'full client-side render.'\n );\n }\n }\n // either not server-rendered, or hydration failed.\n // create an empty node and replace it\n oldVnode = emptyNodeAt(oldVnode);\n }\n\n // replacing existing element\n var oldElm = oldVnode.elm;\n var parentElm = nodeOps.parentNode(oldElm);\n\n // create new node\n createElm(\n vnode,\n insertedVnodeQueue,\n // extremely rare edge case: do not insert if old element is in a\n // leaving transition. Only happens when combining transition +\n // keep-alive + HOCs. (#4590)\n oldElm._leaveCb ? null : parentElm,\n nodeOps.nextSibling(oldElm)\n );\n\n // update parent placeholder node element, recursively\n if (isDef(vnode.parent)) {\n var ancestor = vnode.parent;\n var patchable = isPatchable(vnode);\n while (ancestor) {\n for (var i = 0; i < cbs.destroy.length; ++i) {\n cbs.destroy[i](ancestor);\n }\n ancestor.elm = vnode.elm;\n if (patchable) {\n for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {\n cbs.create[i$1](emptyNode, ancestor);\n }\n // #6513\n // invoke insert hooks that may have been merged by create hooks.\n // e.g. for directives that uses the \"inserted\" hook.\n var insert = ancestor.data.hook.insert;\n if (insert.merged) {\n // start at index 1 to avoid re-invoking component mounted hook\n for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {\n insert.fns[i$2]();\n }\n }\n } else {\n registerRef(ancestor);\n }\n ancestor = ancestor.parent;\n }\n }\n\n // destroy old node\n if (isDef(parentElm)) {\n removeVnodes(parentElm, [oldVnode], 0, 0);\n } else if (isDef(oldVnode.tag)) {\n invokeDestroyHook(oldVnode);\n }\n }\n }\n\n invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);\n return vnode.elm\n }\n}\n\n/* */\n\nvar directives = {\n create: updateDirectives,\n update: updateDirectives,\n destroy: function unbindDirectives (vnode) {\n updateDirectives(vnode, emptyNode);\n }\n};\n\nfunction updateDirectives (oldVnode, vnode) {\n if (oldVnode.data.directives || vnode.data.directives) {\n _update(oldVnode, vnode);\n }\n}\n\nfunction _update (oldVnode, vnode) {\n var isCreate = oldVnode === emptyNode;\n var isDestroy = vnode === emptyNode;\n var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);\n var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);\n\n var dirsWithInsert = [];\n var dirsWithPostpatch = [];\n\n var key, oldDir, dir;\n for (key in newDirs) {\n oldDir = oldDirs[key];\n dir = newDirs[key];\n if (!oldDir) {\n // new directive, bind\n callHook$1(dir, 'bind', vnode, oldVnode);\n if (dir.def && dir.def.inserted) {\n dirsWithInsert.push(dir);\n }\n } else {\n // existing directive, update\n dir.oldValue = oldDir.value;\n dir.oldArg = oldDir.arg;\n callHook$1(dir, 'update', vnode, oldVnode);\n if (dir.def && dir.def.componentUpdated) {\n dirsWithPostpatch.push(dir);\n }\n }\n }\n\n if (dirsWithInsert.length) {\n var callInsert = function () {\n for (var i = 0; i < dirsWithInsert.length; i++) {\n callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);\n }\n };\n if (isCreate) {\n mergeVNodeHook(vnode, 'insert', callInsert);\n } else {\n callInsert();\n }\n }\n\n if (dirsWithPostpatch.length) {\n mergeVNodeHook(vnode, 'postpatch', function () {\n for (var i = 0; i < dirsWithPostpatch.length; i++) {\n callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);\n }\n });\n }\n\n if (!isCreate) {\n for (key in oldDirs) {\n if (!newDirs[key]) {\n // no longer present, unbind\n callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);\n }\n }\n }\n}\n\nvar emptyModifiers = Object.create(null);\n\nfunction normalizeDirectives$1 (\n dirs,\n vm\n) {\n var res = Object.create(null);\n if (!dirs) {\n // $flow-disable-line\n return res\n }\n var i, dir;\n for (i = 0; i < dirs.length; i++) {\n dir = dirs[i];\n if (!dir.modifiers) {\n // $flow-disable-line\n dir.modifiers = emptyModifiers;\n }\n res[getRawDirName(dir)] = dir;\n dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);\n }\n // $flow-disable-line\n return res\n}\n\nfunction getRawDirName (dir) {\n return dir.rawName || ((dir.name) + \".\" + (Object.keys(dir.modifiers || {}).join('.')))\n}\n\nfunction callHook$1 (dir, hook, vnode, oldVnode, isDestroy) {\n var fn = dir.def && dir.def[hook];\n if (fn) {\n try {\n fn(vnode.elm, dir, vnode, oldVnode, isDestroy);\n } catch (e) {\n handleError(e, vnode.context, (\"directive \" + (dir.name) + \" \" + hook + \" hook\"));\n }\n }\n}\n\nvar baseModules = [\n ref,\n directives\n];\n\n/* */\n\nfunction updateAttrs (oldVnode, vnode) {\n var opts = vnode.componentOptions;\n if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {\n return\n }\n if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {\n return\n }\n var key, cur, old;\n var elm = vnode.elm;\n var oldAttrs = oldVnode.data.attrs || {};\n var attrs = vnode.data.attrs || {};\n // clone observed objects, as the user probably wants to mutate it\n if (isDef(attrs.__ob__)) {\n attrs = vnode.data.attrs = extend({}, attrs);\n }\n\n for (key in attrs) {\n cur = attrs[key];\n old = oldAttrs[key];\n if (old !== cur) {\n setAttr(elm, key, cur);\n }\n }\n // #4391: in IE9, setting type can reset value for input[type=radio]\n // #6666: IE/Edge forces progress value down to 1 before setting a max\n /* istanbul ignore if */\n if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {\n setAttr(elm, 'value', attrs.value);\n }\n for (key in oldAttrs) {\n if (isUndef(attrs[key])) {\n if (isXlink(key)) {\n elm.removeAttributeNS(xlinkNS, getXlinkProp(key));\n } else if (!isEnumeratedAttr(key)) {\n elm.removeAttribute(key);\n }\n }\n }\n}\n\nfunction setAttr (el, key, value) {\n if (el.tagName.indexOf('-') > -1) {\n baseSetAttr(el, key, value);\n } else if (isBooleanAttr(key)) {\n // set attribute for blank value\n // e.g. \n if (isFalsyAttrValue(value)) {\n el.removeAttribute(key);\n } else {\n // technically allowfullscreen is a boolean attribute for