https://www.anima.it/objects/jsQR.js

1(function webpackUniversalModuleDefinition(root, factory) {
2	if(typeof exports === 'object' && typeof module === 'object')
3		module.exports = factory();
4	else if(typeof define === 'function' && define.amd)
5		define([], factory);
6	else if(typeof exports === 'object')
7		exports["jsQR"] = factory();
8	else
9		root["jsQR"] = factory();
10})(typeof self !== 'undefined' ? self : this, function() {
11return /******/ (function(modules) { // webpackBootstrap
12/******/ 	// The module cache
13/******/ 	var installedModules = {};
14/******/
15/******/ 	// The require function
16/******/ 	function __webpack_require__(moduleId) {
17/******/
18/******/ 		// Check if module is in cache
19/******/ 		if(installedModules[moduleId]) {
20/******/ 			return installedModules[moduleId].exports;
21/******/ 		}
22/******/ 		// Create a new module (and put it into the cache)
23/******/ 		var module = installedModules[moduleId] = {
24/******/ 			i: moduleId,
25/******/ 			l: false,
26/******/ 			exports: {}
27/******/ 		};
28/******/
29/******/ 		// Execute the module function
30/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
31/******/
32/******/ 		// Flag the module as loaded
33/******/ 		module.l = true;
34/******/
35/******/ 		// Return the exports of the module
36/******/ 		return module.exports;
37/******/ 	}
38/******/
39/******/
40/******/ 	// expose the modules object (__webpack_modules__)
41/******/ 	__webpack_require__.m = modules;
42/******/
43/******/ 	// expose the module cache
44/******/ 	__webpack_require__.c = installedModules;
45/******/
46/******/ 	// define getter function for harmony exports
47/******/ 	__webpack_require__.d = function(exports, name, getter) {
48/******/ 		if(!__webpack_require__.o(exports, name)) {
49/******/ 			Object.defineProperty(exports, name, {
50/******/ 				configurable: false,
51/******/ 				enumerable: true,
52/******/ 				get: getter
53/******/ 			});
54/******/ 		}
55/******/ 	};
56/******/
57/******/ 	// getDefaultExport function for compatibility with non-harmony modules
58/******/ 	__webpack_require__.n = function(module) {
59/******/ 		var getter = module && module.__esModule ?
60/******/ 			function getDefault() { return module['default']; } :
61/******/ 			function getModuleExports() { return module; };
62/******/ 		__webpack_require__.d(getter, 'a', getter);
63/******/ 		return getter;
64/******/ 	};
65/******/
66/******/ 	// Object.prototype.hasOwnProperty.call
67/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
68/******/
69/******/ 	// __webpack_public_path__
70/******/ 	__webpack_require__.p = "";
71/******/
72/******/ 	// Load entry module and return exports
73/******/ 	return __webpack_require__(__webpack_require__.s = 3);
74/******/ })
75/************************************************************************/
76/******/ ([
77/* 0 */
78/***/ (function(module, exports, __webpack_require__) {
79
80"use strict";
81
82Object.defineProperty(exports, "__esModule", { value: true });
83var BitMatrix = /** @class */ (function () {
84    function BitMatrix(data, width) {
85        this.width = width;
86        this.height = data.length / width;
87        this.data = data;
88    }
89    BitMatrix.createEmpty = function (width, height) {
90        return new BitMatrix(new Uint8ClampedArray(width * height), width);
91    };
92    BitMatrix.prototype.get = function (x, y) {
93        if (x < 0 || x >= this.width || y < 0 || y >= this.height) {
94            return false;
95        }
96        return !!this.data[y * this.width + x];
97    };
98    BitMatrix.prototype.set = function (x, y, v) {
99        this.data[y * this.width + x] = v ? 1 : 0;
100    };
101    BitMatrix.prototype.setRegion = function (left, top, width, height, v) {
102        for (var y = top; y < top + height; y++) {
103            for (var x = left; x < left + width; x++) {
104                this.set(x, y, !!v);
105            }
106        }
107    };
108    return BitMatrix;
109}());
110exports.BitMatrix = BitMatrix;
111
112
113/***/ }),
114/* 1 */
115/***/ (function(module, exports, __webpack_require__) {
116
117"use strict";
118
119Object.defineProperty(exports, "__esModule", { value: true });
120var GenericGFPoly_1 = __webpack_require__(2);
121function addOrSubtractGF(a, b) {
122    return a ^ b; // tslint:disable-line:no-bitwise
123}
124exports.addOrSubtractGF = addOrSubtractGF;
125var GenericGF = /** @class */ (function () {
126    function GenericGF(primitive, size, genBase) {
127        this.primitive = primitive;
128        this.size = size;
129        this.generatorBase = genBase;
130        this.expTable = new Array(this.size);
131        this.logTable = new Array(this.size);
132        var x = 1;
133        for (var i = 0; i < this.size; i++) {
134            this.expTable[i] = x;
135            x = x * 2;
136            if (x >= this.size) {
137                x = (x ^ this.primitive) & (this.size - 1); // tslint:disable-line:no-bitwise
138            }
139        }
140        for (var i = 0; i < this.size - 1; i++) {
141            this.logTable[this.expTable[i]] = i;
142        }
143        this.zero = new GenericGFPoly_1.default(this, Uint8ClampedArray.from([0]));
144        this.one = new GenericGFPoly_1.default(this, Uint8ClampedArray.from([1]));
145    }
146    GenericGF.prototype.multiply = function (a, b) {
147        if (a === 0 || b === 0) {
148            return 0;
149        }
150        return this.expTable[(this.logTable[a] + this.logTable[b]) % (this.size - 1)];
151    };
152    GenericGF.prototype.inverse = function (a) {
153        if (a === 0) {
154            throw new Error("Can't invert 0");
155        }
156        return this.expTable[this.size - this.logTable[a] - 1];
157    };
158    GenericGF.prototype.buildMonomial = function (degree, coefficient) {
159        if (degree < 0) {
160            throw new Error("Invalid monomial degree less than 0");
161        }
162        if (coefficient === 0) {
163            return this.zero;
164        }
165        var coefficients = new Uint8ClampedArray(degree + 1);
166        coefficients[0] = coefficient;
167        return new GenericGFPoly_1.default(this, coefficients);
168    };
169    GenericGF.prototype.log = function (a) {
170        if (a === 0) {
171            throw new Error("Can't take log(0)");
172        }
173        return this.logTable[a];
174    };
175    GenericGF.prototype.exp = function (a) {
176        return this.expTable[a];
177    };
178    return GenericGF;
179}());
180exports.default = GenericGF;
181
182
183/***/ }),
184/* 2 */
185/***/ (function(module, exports, __webpack_require__) {
186
187"use strict";
188
189Object.defineProperty(exports, "__esModule", { value: true });
190var GenericGF_1 = __webpack_require__(1);
191var GenericGFPoly = /** @class */ (function () {
192    function GenericGFPoly(field, coefficients) {
193        if (coefficients.length === 0) {
194            throw new Error("No coefficients.");
195        }
196        this.field = field;
197        var coefficientsLength = coefficients.length;
198        if (coefficientsLength > 1 && coefficients[0] === 0) {
199            // Leading term must be non-zero for anything except the constant polynomial "0"
200            var firstNonZero = 1;
201            while (firstNonZero < coefficientsLength && coefficients[firstNonZero] === 0) {
202                firstNonZero++;
203            }
204            if (firstNonZero === coefficientsLength) {
205                this.coefficients = field.zero.coefficients;
206            }
207            else {
208                this.coefficients = new Uint8ClampedArray(coefficientsLength - firstNonZero);
209                for (var i = 0; i < this.coefficients.length; i++) {
210                    this.coefficients[i] = coefficients[firstNonZero + i];
211                }
212            }
213        }
214        else {
215            this.coefficients = coefficients;
216        }
217    }
218    GenericGFPoly.prototype.degree = function () {
219        return this.coefficients.length - 1;
220    };
221    GenericGFPoly.prototype.isZero = function () {
222        return this.coefficients[0] === 0;
223    };
224    GenericGFPoly.prototype.getCoefficient = function (degree) {
225        return this.coefficients[this.coefficients.length - 1 - degree];
226    };
227    GenericGFPoly.prototype.addOrSubtract = function (other) {
228        var _a;
229        if (this.isZero()) {
230            return other;
231        }
232        if (other.isZero()) {
233            return this;
234        }
235        var smallerCoefficients = this.coefficients;
236        var largerCoefficients = other.coefficients;
237        if (smallerCoefficients.length > largerCoefficients.length) {
238            _a = [largerCoefficients, smallerCoefficients], smallerCoefficients = _a[0], largerCoefficients = _a[1];
239        }
240        var sumDiff = new Uint8ClampedArray(largerCoefficients.length);
241        var lengthDiff = largerCoefficients.length - smallerCoefficients.length;
242        for (var i = 0; i < lengthDiff; i++) {
243            sumDiff[i] = largerCoefficients[i];
244        }
245        for (var i = lengthDiff; i < largerCoefficients.length; i++) {
246            sumDiff[i] = GenericGF_1.addOrSubtractGF(smallerCoefficients[i - lengthDiff], largerCoefficients[i]);
247        }
248        return new GenericGFPoly(this.field, sumDiff);
249    };
250    GenericGFPoly.prototype.multiply = function (scalar) {
251        if (scalar === 0) {
252            return this.field.zero;
253        }
254        if (scalar === 1) {
255            return this;
256        }
257        var size = this.coefficients.length;
258        var product = new Uint8ClampedArray(size);
259        for (var i = 0; i < size; i++) {
260            product[i] = this.field.multiply(this.coefficients[i], scalar);
261        }
262        return new GenericGFPoly(this.field, product);
263    };
264    GenericGFPoly.prototype.multiplyPoly = function (other) {
265        if (this.isZero() || other.isZero()) {
266            return this.field.zero;
267        }
268        var aCoefficients = this.coefficients;
269        var aLength = aCoefficients.length;
270        var bCoefficients = other.coefficients;
271        var bLength = bCoefficients.length;
272        var product = new Uint8ClampedArray(aLength + bLength - 1);
273        for (var i = 0; i < aLength; i++) {
274            var aCoeff = aCoefficients[i];
275            for (var j = 0; j < bLength; j++) {
276                product[i + j] = GenericGF_1.addOrSubtractGF(product[i + j], this.field.multiply(aCoeff, bCoefficients[j]));
277            }
278        }
279        return new GenericGFPoly(this.field, product);
280    };
281    GenericGFPoly.prototype.multiplyByMonomial = function (degree, coefficient) {
282        if (degree < 0) {
283            throw new Error("Invalid degree less than 0");
284        }
285        if (coefficient === 0) {
286            return this.field.zero;
287        }
288        var size = this.coefficients.length;
289        var product = new Uint8ClampedArray(size + degree);
290        for (var i = 0; i < size; i++) {
291            product[i] = this.field.multiply(this.coefficients[i], coefficient);
292        }
293        return new GenericGFPoly(this.field, product);
294    };
295    GenericGFPoly.prototype.evaluateAt = function (a) {
296        var result = 0;
297        if (a === 0) {
298            // Just return the x^0 coefficient
299            return this.getCoefficient(0);
300        }
301        var size = this.coefficients.length;
302        if (a === 1) {
303            // Just the sum of the coefficients
304            this.coefficients.forEach(function (coefficient) {
305                result = GenericGF_1.addOrSubtractGF(result, coefficient);
306            });
307            return result;
308        }
309        result = this.coefficients[0];
310        for (var i = 1; i < size; i++) {
311            result = GenericGF_1.addOrSubtractGF(this.field.multiply(a, result), this.coefficients[i]);
312        }
313        return result;
314    };
315    return GenericGFPoly;
316}());
317exports.default = GenericGFPoly;
318
319
320/***/ }),
321/* 3 */
322/***/ (function(module, exports, __webpack_require__) {
323
324"use strict";
325
326Object.defineProperty(exports, "__esModule", { value: true });
327var binarizer_1 = __webpack_require__(4);
328var decoder_1 = __webpack_require__(5);
329var extractor_1 = __webpack_require__(11);
330var locator_1 = __webpack_require__(12);
331function scan(matrix) {
332    var locations = locator_1.locate(matrix);
333    if (!locations) {
334        return null;
335    }
336    for (var _i = 0, locations_1 = locations; _i < locations_1.length; _i++) {
337        var location_1 = locations_1[_i];
338        var extracted = extractor_1.extract(matrix, location_1);
339        var decoded = decoder_1.decode(extracted.matrix);
340        if (decoded) {
341            return {
342                binaryData: decoded.bytes,
343                data: decoded.text,
344                chunks: decoded.chunks,
345                version: decoded.version,
346                location: {
347                    topRightCorner: extracted.mappingFunction(location_1.dimension, 0),
348                    topLeftCorner: extracted.mappingFunction(0, 0),
349                    bottomRightCorner: extracted.mappingFunction(location_1.dimension, location_1.dimension),
350                    bottomLeftCorner: extracted.mappingFunction(0, location_1.dimension),
351                    topRightFinderPattern: location_1.topRight,
352                    topLeftFinderPattern: location_1.topLeft,
353                    bottomLeftFinderPattern: location_1.bottomLeft,
354                    bottomRightAlignmentPattern: location_1.alignmentPattern,
355                },
356            };
357        }
358    }
359    return null;
360}
361var defaultOptions = {
362    inversionAttempts: "attemptBoth",
363};
364function jsQR(data, width, height, providedOptions) {
365    if (providedOptions === void 0) { providedOptions = {}; }
366    var options = defaultOptions;
367    Object.keys(options || {}).forEach(function (opt) {
368        options[opt] = providedOptions[opt] || options[opt];
369    });
370    var shouldInvert = options.inversionAttempts === "attemptBoth" || options.inversionAttempts === "invertFirst";
371    var tryInvertedFirst = options.inversionAttempts === "onlyInvert" || options.inversionAttempts === "invertFirst";
372    var _a = binarizer_1.binarize(data, width, height, shouldInvert), binarized = _a.binarized, inverted = _a.inverted;
373    var result = scan(tryInvertedFirst ? inverted : binarized);
374    if (!result && (options.inversionAttempts === "attemptBoth" || options.inversionAttempts === "invertFirst")) {
375        result = scan(tryInvertedFirst ? binarized : inverted);
376    }
377    return result;
378}
379jsQR.default = jsQR;
380exports.default = jsQR;
381
382
383/***/ }),
384/* 4 */
385/***/ (function(module, exports, __webpack_require__) {
386
387"use strict";
388
389Object.defineProperty(exports, "__esModule", { value: true });
390var BitMatrix_1 = __webpack_require__(0);
391var REGION_SIZE = 8;
392var MIN_DYNAMIC_RANGE = 24;
393function numBetween(value, min, max) {
394    return value < min ? min : value > max ? max : value;
395}
396// Like BitMatrix but accepts arbitry Uint8 values
397var Matrix = /** @class */ (function () {
398    function Matrix(width, height) {
399        this.width = width;
400        this.data = new Uint8ClampedArray(width * height);
401    }
402    Matrix.prototype.get = function (x, y) {
403        return this.data[y * this.width + x];
404    };
405    Matrix.prototype.set = function (x, y, value) {
406        this.data[y * this.width + x] = value;
407    };
408    return Matrix;
409}());
410function binarize(data, width, height, returnInverted) {
411    if (data.length !== width * height * 4) {
412        throw new Error("Malformed data passed to binarizer.");
413    }
414    // Convert image to greyscale
415    var greyscalePixels = new Matrix(width, height);
416    for (var x = 0; x < width; x++) {
417        for (var y = 0; y < height; y++) {
418            var r = data[((y * width + x) * 4) + 0];
419            var g = data[((y * width + x) * 4) + 1];
420            var b = data[((y * width + x) * 4) + 2];
421            greyscalePixels.set(x, y, 0.2126 * r + 0.7152 * g + 0.0722 * b);
422        }
423    }
424    var horizontalRegionCount = Math.ceil(width / REGION_SIZE);
425    var verticalRegionCount = Math.ceil(height / REGION_SIZE);
426    var blackPoints = new Matrix(horizontalRegionCount, verticalRegionCount);
427    for (var verticalRegion = 0; verticalRegion < verticalRegionCount; verticalRegion++) {
428        for (var hortizontalRegion = 0; hortizontalRegion < horizontalRegionCount; hortizontalRegion++) {
429            var sum = 0;
430            var min = Infinity;
431            var max = 0;
432            for (var y = 0; y < REGION_SIZE; y++) {
433                for (var x = 0; x < REGION_SIZE; x++) {
434                    var pixelLumosity = greyscalePixels.get(hortizontalRegion * REGION_SIZE + x, verticalRegion * REGION_SIZE + y);
435                    sum += pixelLumosity;
436                    min = Math.min(min, pixelLumosity);
437                    max = Math.max(max, pixelLumosity);
438                }
439            }
440            var average = sum / (Math.pow(REGION_SIZE, 2));
441            if (max - min <= MIN_DYNAMIC_RANGE) {
442                // If variation within the block is low, assume this is a block with only light or only
443                // dark pixels. In that case we do not want to use the average, as it would divide this
444                // low contrast area into black and white pixels, essentially creating data out of noise.
445                //
446                // Default the blackpoint for these blocks to be half the min - effectively white them out
447                average = min / 2;
448                if (verticalRegion > 0 && hortizontalRegion > 0) {
449                    // Correct the "white background" assumption for blocks that have neighbors by comparing
450                    // the pixels in this block to the previously calculated black points. This is based on
451                    // the fact that dark barcode symbology is always surrounded by some amount of light
452                    // background for which reasonable black point estimates were made. The bp estimated at
453                    // the boundaries is used for the interior.
454                    // The (min < bp) is arbitrary but works better than other heuristics that were tried.
455                    var averageNeighborBlackPoint = (blackPoints.get(hortizontalRegion, verticalRegion - 1) +
456                        (2 * blackPoints.get(hortizontalRegion - 1, verticalRegion)) +
457                        blackPoints.get(hortizontalRegion - 1, verticalRegion - 1)) / 4;
458                    if (min < averageNeighborBlackPoint) {
459                        average = averageNeighborBlackPoint;
460                    }
461                }
462            }
463            blackPoints.set(hortizontalRegion, verticalRegion, average);
464        }
465    }
466    var binarized = BitMatrix_1.BitMatrix.createEmpty(width, height);
467    var inverted = null;
468    if (returnInverted) {
469        inverted = BitMatrix_1.BitMatrix.createEmpty(width, height);
470    }
471    for (var verticalRegion = 0; verticalRegion < verticalRegionCount; verticalRegion++) {
472        for (var hortizontalRegion = 0; hortizontalRegion < horizontalRegionCount; hortizontalRegion++) {
473            var left = numBetween(hortizontalRegion, 2, horizontalRegionCount - 3);
474            var top_1 = numBetween(verticalRegion, 2, verticalRegionCount - 3);
475            var sum = 0;
476            for (var xRegion = -2; xRegion <= 2; xRegion++) {
477                for (var yRegion = -2; yRegion <= 2; yRegion++) {
478                    sum += blackPoints.get(left + xRegion, top_1 + yRegion);
479                }
480            }
481            var threshold = sum / 25;
482            for (var xRegion = 0; xRegion < REGION_SIZE; xRegion++) {
483                for (var yRegion = 0; yRegion < REGION_SIZE; yRegion++) {
484                    var x = hortizontalRegion * REGION_SIZE + xRegion;
485                    var y = verticalRegion * REGION_SIZE + yRegion;
486                    var lum = greyscalePixels.get(x, y);
487                    binarized.set(x, y, lum <= threshold);
488                    if (returnInverted) {
489                        inverted.set(x, y, !(lum <= threshold));
490                    }
491                }
492            }
493        }
494    }
495    if (returnInverted) {
496        return { binarized: binarized, inverted: inverted };
497    }
498    return { binarized: binarized };
499}
500exports.binarize = binarize;
501
502
503/***/ }),
504/* 5 */
505/***/ (function(module, exports, __webpack_require__) {
506
507"use strict";
508
509Object.defineProperty(exports, "__esModule", { value: true });
510var BitMatrix_1 = __webpack_require__(0);
511var decodeData_1 = __webpack_require__(6);
512var reedsolomon_1 = __webpack_require__(9);
513var version_1 = __webpack_require__(10);
514// tslint:disable:no-bitwise
515function numBitsDiffering(x, y) {
516    var z = x ^ y;
517    var bitCount = 0;
518    while (z) {
519        bitCount++;
520        z &= z - 1;
521    }
522    return bitCount;
523}
524function pushBit(bit, byte) {
525    return (byte << 1) | bit;
526}
527// tslint:enable:no-bitwise
528var FORMAT_INFO_TABLE = [
529    { bits: 0x5412, formatInfo: { errorCorrectionLevel: 1, dataMask: 0 } },
530    { bits: 0x5125, formatInfo: { errorCorrectionLevel: 1, dataMask: 1 } },
531    { bits: 0x5E7C, formatInfo: { errorCorrectionLevel: 1, dataMask: 2 } },
532    { bits: 0x5B4B, formatInfo: { errorCorrectionLevel: 1, dataMask: 3 } },
533    { bits: 0x45F9, formatInfo: { errorCorrectionLevel: 1, dataMask: 4 } },
534    { bits: 0x40CE, formatInfo: { errorCorrectionLevel: 1, dataMask: 5 } },
535    { bits: 0x4F97, formatInfo: { errorCorrectionLevel: 1, dataMask: 6 } },
536    { bits: 0x4AA0, formatInfo: { errorCorrectionLevel: 1, dataMask: 7 } },
537    { bits: 0x77C4, formatInfo: { errorCorrectionLevel: 0, dataMask: 0 } },
538    { bits: 0x72F3, formatInfo: { errorCorrectionLevel: 0, dataMask: 1 } },
539    { bits: 0x7DAA, formatInfo: { errorCorrectionLevel: 0, dataMask: 2 } },
540    { bits: 0x789D, formatInfo: { errorCorrectionLevel: 0, dataMask: 3 } },
541    { bits: 0x662F, formatInfo: { errorCorrectionLevel: 0, dataMask: 4 } },
542    { bits: 0x6318, formatInfo: { errorCorrectionLevel: 0, dataMask: 5 } },
543    { bits: 0x6C41, formatInfo: { errorCorrectionLevel: 0, dataMask: 6 } },
544    { bits: 0x6976, formatInfo: { errorCorrectionLevel: 0, dataMask: 7 } },
545    { bits: 0x1689, formatInfo: { errorCorrectionLevel: 3, dataMask: 0 } },
546    { bits: 0x13BE, formatInfo: { errorCorrectionLevel: 3, dataMask: 1 } },
547    { bits: 0x1CE7, formatInfo: { errorCorrectionLevel: 3, dataMask: 2 } },
548    { bits: 0x19D0, formatInfo: { errorCorrectionLevel: 3, dataMask: 3 } },
549    { bits: 0x0762, formatInfo: { errorCorrectionLevel: 3, dataMask: 4 } },
550    { bits: 0x0255, formatInfo: { errorCorrectionLevel: 3, dataMask: 5 } },
551    { bits: 0x0D0C, formatInfo: { errorCorrectionLevel: 3, dataMask: 6 } },
552    { bits: 0x083B, formatInfo: { errorCorrectionLevel: 3, dataMask: 7 } },
553    { bits: 0x355F, formatInfo: { errorCorrectionLevel: 2, dataMask: 0 } },
554    { bits: 0x3068, formatInfo: { errorCorrectionLevel: 2, dataMask: 1 } },
555    { bits: 0x3F31, formatInfo: { errorCorrectionLevel: 2, dataMask: 2 } },
556    { bits: 0x3A06, formatInfo: { errorCorrectionLevel: 2, dataMask: 3 } },
557    { bits: 0x24B4, formatInfo: { errorCorrectionLevel: 2, dataMask: 4 } },
558    { bits: 0x2183, formatInfo: { errorCorrectionLevel: 2, dataMask: 5 } },
559    { bits: 0x2EDA, formatInfo: { errorCorrectionLevel: 2, dataMask: 6 } },
560    { bits: 0x2BED, formatInfo: { errorCorrectionLevel: 2, dataMask: 7 } },
561];
562var DATA_MASKS = [
563    function (p) { return ((p.y + p.x) % 2) === 0; },
564    function (p) { return (p.y % 2) === 0; },
565    function (p) { return p.x % 3 === 0; },
566    function (p) { return (p.y + p.x) % 3 === 0; },
567    function (p) { return (Math.floor(p.y / 2) + Math.floor(p.x / 3)) % 2 === 0; },
568    function (p) { return ((p.x * p.y) % 2) + ((p.x * p.y) % 3) === 0; },
569    function (p) { return ((((p.y * p.x) % 2) + (p.y * p.x) % 3) % 2) === 0; },
570    function (p) { return ((((p.y + p.x) % 2) + (p.y * p.x) % 3) % 2) === 0; },
571];
572function buildFunctionPatternMask(version) {
573    var dimension = 17 + 4 * version.versionNumber;
574    var matrix = BitMatrix_1.BitMatrix.createEmpty(dimension, dimension);
575    matrix.setRegion(0, 0, 9, 9, true); // Top left finder pattern + separator + format
576    matrix.setRegion(dimension - 8, 0, 8, 9, true); // Top right finder pattern + separator + format
577    matrix.setRegion(0, dimension - 8, 9, 8, true); // Bottom left finder pattern + separator + format
578    // Alignment patterns
579    for (var _i = 0, _a = version.alignmentPatternCenters; _i < _a.length; _i++) {
580        var x = _a[_i];
581        for (var _b = 0, _c = version.alignmentPatternCenters; _b < _c.length; _b++) {
582            var y = _c[_b];
583            if (!(x === 6 && y === 6 || x === 6 && y === dimension - 7 || x === dimension - 7 && y === 6)) {
584                matrix.setRegion(x - 2, y - 2, 5, 5, true);
585            }
586        }
587    }
588    matrix.setRegion(6, 9, 1, dimension - 17, true); // Vertical timing pattern
589    matrix.setRegion(9, 6, dimension - 17, 1, true); // Horizontal timing pattern
590    if (version.versionNumber > 6) {
591        matrix.setRegion(dimension - 11, 0, 3, 6, true); // Version info, top right
592        matrix.setRegion(0, dimension - 11, 6, 3, true); // Version info, bottom left
593    }
594    return matrix;
595}
596function readCodewords(matrix, version, formatInfo) {
597    var dataMask = DATA_MASKS[formatInfo.dataMask];
598    var dimension = matrix.height;
599    var functionPatternMask = buildFunctionPatternMask(version);
600    var codewords = [];
601    var currentByte = 0;
602    var bitsRead = 0;
603    // Read columns in pairs, from right to left
604    var readingUp = true;
605    for (var columnIndex = dimension - 1; columnIndex > 0; columnIndex -= 2) {
606        if (columnIndex === 6) { // Skip whole column with vertical alignment pattern;
607            columnIndex--;
608        }
609        for (var i = 0; i < dimension; i++) {
610            var y = readingUp ? dimension - 1 - i : i;
611            for (var columnOffset = 0; columnOffset < 2; columnOffset++) {
612                var x = columnIndex - columnOffset;
613                if (!functionPatternMask.get(x, y)) {
614                    bitsRead++;
615                    var bit = matrix.get(x, y);
616                    if (dataMask({ y: y, x: x })) {
617                        bit = !bit;
618                    }
619                    currentByte = pushBit(bit, currentByte);
620                    if (bitsRead === 8) { // Whole bytes
621                        codewords.push(currentByte);
622                        bitsRead = 0;
623                        currentByte = 0;
624                    }
625                }
626            }
627        }
628        readingUp = !readingUp;
629    }
630    return codewords;
631}
632function readVersion(matrix) {
633    var dimension = matrix.height;
634    var provisionalVersion = Math.floor((dimension - 17) / 4);
635    if (provisionalVersion <= 6) { // 6 and under dont have version info in the QR code
636        return version_1.VERSIONS[provisionalVersion - 1];
637    }
638    var topRightVersionBits = 0;
639    for (var y = 5; y >= 0; y--) {
640        for (var x = dimension - 9; x >= dimension - 11; x--) {
641            topRightVersionBits = pushBit(matrix.get(x, y), topRightVersionBits);
642        }
643    }
644    var bottomLeftVersionBits = 0;
645    for (var x = 5; x >= 0; x--) {
646        for (var y = dimension - 9; y >= dimension - 11; y--) {
647            bottomLeftVersionBits = pushBit(matrix.get(x, y), bottomLeftVersionBits);
648        }
649    }
650    var bestDifference = Infinity;
651    var bestVersion;
652    for (var _i = 0, VERSIONS_1 = version_1.VERSIONS; _i < VERSIONS_1.length; _i++) {
653        var version = VERSIONS_1[_i];
654        if (version.infoBits === topRightVersionBits || version.infoBits === bottomLeftVersionBits) {
655            return version;
656        }
657        var difference = numBitsDiffering(topRightVersionBits, version.infoBits);
658        if (difference < bestDifference) {
659            bestVersion = version;
660            bestDifference = difference;
661        }
662        difference = numBitsDiffering(bottomLeftVersionBits, version.infoBits);
663        if (difference < bestDifference) {
664            bestVersion = version;
665            bestDifference = difference;
666        }
667    }
668    // We can tolerate up to 3 bits of error since no two version info codewords will
669    // differ in less than 8 bits.
670    if (bestDifference <= 3) {
671        return bestVersion;
672    }
673}
674function readFormatInformation(matrix) {
675    var topLeftFormatInfoBits = 0;
676    for (var x = 0; x <= 8; x++) {
677        if (x !== 6) { // Skip timing pattern bit
678            topLeftFormatInfoBits = pushBit(matrix.get(x, 8), topLeftFormatInfoBits);
679        }
680    }
681    for (var y = 7; y >= 0; y--) {
682        if (y !== 6) { // Skip timing pattern bit
683            topLeftFormatInfoBits = pushBit(matrix.get(8, y), topLeftFormatInfoBits);
684        }
685    }
686    var dimension = matrix.height;
687    var topRightBottomRightFormatInfoBits = 0;
688    for (var y = dimension - 1; y >= dimension - 7; y--) { // bottom left
689        topRightBottomRightFormatInfoBits = pushBit(matrix.get(8, y), topRightBottomRightFormatInfoBits);
690    }
691    for (var x = dimension - 8; x < dimension; x++) { // top right
692        topRightBottomRightFormatInfoBits = pushBit(matrix.get(x, 8), topRightBottomRightFormatInfoBits);
693    }
694    var bestDifference = Infinity;
695    var bestFormatInfo = null;
696    for (var _i = 0, FORMAT_INFO_TABLE_1 = FORMAT_INFO_TABLE; _i < FORMAT_INFO_TABLE_1.length; _i++) {
697        var _a = FORMAT_INFO_TABLE_1[_i], bits = _a.bits, formatInfo = _a.formatInfo;
698        if (bits === topLeftFormatInfoBits || bits === topRightBottomRightFormatInfoBits) {
699            return formatInfo;
700        }
701        var difference = numBitsDiffering(topLeftFormatInfoBits, bits);
702        if (difference < bestDifference) {
703            bestFormatInfo = formatInfo;
704            bestDifference = difference;
705        }
706        if (topLeftFormatInfoBits !== topRightBottomRightFormatInfoBits) { // also try the other option
707            difference = numBitsDiffering(topRightBottomRightFormatInfoBits, bits);
708            if (difference < bestDifference) {
709                bestFormatInfo = formatInfo;
710                bestDifference = difference;
711            }
712        }
713    }
714    // Hamming distance of the 32 masked codes is 7, by construction, so <= 3 bits differing means we found a match
715    if (bestDifference <= 3) {
716        return bestFormatInfo;
717    }
718    return null;
719}
720function getDataBlocks(codewords, version, ecLevel) {
721    var ecInfo = version.errorCorrectionLevels[ecLevel];
722    var dataBlocks = [];
723    var totalCodewords = 0;
724    ecInfo.ecBlocks.forEach(function (block) {
725        for (var i = 0; i < block.numBlocks; i++) {
726            dataBlocks.push({ numDataCodewords: block.dataCodewordsPerBlock, codewords: [] });
727            totalCodewords += block.dataCodewordsPerBlock + ecInfo.ecCodewordsPerBlock;
728        }
729    });
730    // In some cases the QR code will be malformed enough that we pull off more or less than we should.
731    // If we pull off less there's nothing we can do.
732    // If we pull off more we can safely truncate
733    if (codewords.length < totalCodewords) {
734        return null;
735    }
736    codewords = codewords.slice(0, totalCodewords);
737    var shortBlockSize = ecInfo.ecBlocks[0].dataCodewordsPerBlock;
738    // Pull codewords to fill the blocks up to the minimum size
739    for (var i = 0; i < shortBlockSize; i++) {
740        for (var _i = 0, dataBlocks_1 = dataBlocks; _i < dataBlocks_1.length; _i++) {
741            var dataBlock = dataBlocks_1[_i];
742            dataBlock.codewords.push(codewords.shift());
743        }
744    }
745    // If there are any large blocks, pull codewords to fill the last element of those
746    if (ecInfo.ecBlocks.length > 1) {
747        var smallBlockCount = ecInfo.ecBlocks[0].numBlocks;
748        var largeBlockCount = ecInfo.ecBlocks[1].numBlocks;
749        for (var i = 0; i < largeBlockCount; i++) {
750            dataBlocks[smallBlockCount + i].codewords.push(codewords.shift());
751        }
752    }
753    // Add the rest of the codewords to the blocks. These are the error correction codewords.
754    while (codewords.length > 0) {
755        for (var _a = 0, dataBlocks_2 = dataBlocks; _a < dataBlocks_2.length; _a++) {
756            var dataBlock = dataBlocks_2[_a];
757            dataBlock.codewords.push(codewords.shift());
758        }
759    }
760    return dataBlocks;
761}
762function decodeMatrix(matrix) {
763    var version = readVersion(matrix);
764    if (!version) {
765        return null;
766    }
767    var formatInfo = readFormatInformation(matrix);
768    if (!formatInfo) {
769        return null;
770    }
771    var codewords = readCodewords(matrix, version, formatInfo);
772    var dataBlocks = getDataBlocks(codewords, version, formatInfo.errorCorrectionLevel);
773    if (!dataBlocks) {
774        return null;
775    }
776    // Count total number of data bytes
777    var totalBytes = dataBlocks.reduce(function (a, b) { return a + b.numDataCodewords; }, 0);
778    var resultBytes = new Uint8ClampedArray(totalBytes);
779    var resultIndex = 0;
780    for (var _i = 0, dataBlocks_3 = dataBlocks; _i < dataBlocks_3.length; _i++) {
781        var dataBlock = dataBlocks_3[_i];
782        var correctedBytes = reedsolomon_1.decode(dataBlock.codewords, dataBlock.codewords.length - dataBlock.numDataCodewords);
783        if (!correctedBytes) {
784            return null;
785        }
786        for (var i = 0; i < dataBlock.numDataCodewords; i++) {
787            resultBytes[resultIndex++] = correctedBytes[i];
788        }
789    }
790    try {
791        return decodeData_1.decode(resultBytes, version.versionNumber);
792    }
793    catch (_a) {
794        return null;
795    }
796}
797function decode(matrix) {
798    if (matrix == null) {
799        return null;
800    }
801    var result = decodeMatrix(matrix);
802    if (result) {
803        return result;
804    }
805    // Decoding didn't work, try mirroring the QR across the topLeft -> bottomRight line.
806    for (var x = 0; x < matrix.width; x++) {
807        for (var y = x + 1; y < matrix.height; y++) {
808            if (matrix.get(x, y) !== matrix.get(y, x)) {
809                matrix.set(x, y, !matrix.get(x, y));
810                matrix.set(y, x, !matrix.get(y, x));
811            }
812        }
813    }
814    return decodeMatrix(matrix);
815}
816exports.decode = decode;
817
818
819/***/ }),
820/* 6 */
821/***/ (function(module, exports, __webpack_require__) {
822
823"use strict";
824
825Object.defineProperty(exports, "__esModule", { value: true });
826// tslint:disable:no-bitwise
827var BitStream_1 = __webpack_require__(7);
828var shiftJISTable_1 = __webpack_require__(8);
829var Mode;
830(function (Mode) {
831    Mode["Numeric"] = "numeric";
832    Mode["Alphanumeric"] = "alphanumeric";
833    Mode["Byte"] = "byte";
834    Mode["Kanji"] = "kanji";
835    Mode["ECI"] = "eci";
836})(Mode = exports.Mode || (exports.Mode = {}));
837var ModeByte;
838(function (ModeByte) {
839    ModeByte[ModeByte["Terminator"] = 0] = "Terminator";
840    ModeByte[ModeByte["Numeric"] = 1] = "Numeric";
841    ModeByte[ModeByte["Alphanumeric"] = 2] = "Alphanumeric";
842    ModeByte[ModeByte["Byte"] = 4] = "Byte";
843    ModeByte[ModeByte["Kanji"] = 8] = "Kanji";
844    ModeByte[ModeByte["ECI"] = 7] = "ECI";
845    // StructuredAppend = 0x3,
846    // FNC1FirstPosition = 0x5,
847    // FNC1SecondPosition = 0x9,
848})(ModeByte || (ModeByte = {}));
849function decodeNumeric(stream, size) {
850    var bytes = [];
851    var text = "";
852    var characterCountSize = [10, 12, 14][size];
853    var length = stream.readBits(characterCountSize);
854    // Read digits in groups of 3
855    while (length >= 3) {
856        var num = stream.readBits(10);
857        if (num >= 1000) {
858            throw new Error("Invalid numeric value above 999");
859        }
860        var a = Math.floor(num / 100);
861        var b = Math.floor(num / 10) % 10;
862        var c = num % 10;
863        bytes.push(48 + a, 48 + b, 48 + c);
864        text += a.toString() + b.toString() + c.toString();
865        length -= 3;
866    }
867    // If the number of digits aren't a multiple of 3, the remaining digits are special cased.
868    if (length === 2) {
869        var num = stream.readBits(7);
870        if (num >= 100) {
871            throw new Error("Invalid numeric value above 99");
872        }
873        var a = Math.floor(num / 10);
874        var b = num % 10;
875        bytes.push(48 + a, 48 + b);
876        text += a.toString() + b.toString();
877    }
878    else if (length === 1) {
879        var num = stream.readBits(4);
880        if (num >= 10) {
881            throw new Error("Invalid numeric value above 9");
882        }
883        bytes.push(48 + num);
884        text += num.toString();
885    }
886    return { bytes: bytes, text: text };
887}
888var AlphanumericCharacterCodes = [
889    "0", "1", "2", "3", "4", "5", "6", "7", "8",
890    "9", "A", "B", "C", "D", "E", "F", "G", "H",
891    "I", "J", "K", "L", "M", "N", "O", "P", "Q",
892    "R", "S", "T", "U", "V", "W", "X", "Y", "Z",
893    " ", "$", "%", "*", "+", "-", ".", "/", ":",
894];
895function decodeAlphanumeric(stream, size) {
896    var bytes = [];
897    var text = "";
898    var characterCountSize = [9, 11, 13][size];
899    var length = stream.readBits(characterCountSize);
900    while (length >= 2) {
901        var v = stream.readBits(11);
902        var a = Math.floor(v / 45);
903        var b = v % 45;
904        bytes.push(AlphanumericCharacterCodes[a].charCodeAt(0), AlphanumericCharacterCodes[b].charCodeAt(0));
905        text += AlphanumericCharacterCodes[a] + AlphanumericCharacterCodes[b];
906        length -= 2;
907    }
908    if (length === 1) {
909        var a = stream.readBits(6);
910        bytes.push(AlphanumericCharacterCodes[a].charCodeAt(0));
911        text += AlphanumericCharacterCodes[a];
912    }
913    return { bytes: bytes, text: text };
914}
915function decodeByte(stream, size) {
916    var bytes = [];
917    var text = "";
918    var characterCountSize = [8, 16, 16][size];
919    var length = stream.readBits(characterCountSize);
920    for (var i = 0; i < length; i++) {
921        var b = stream.readBits(8);
922        bytes.push(b);
923    }
924    try {
925        text += decodeURIComponent(bytes.map(function (b) { return "%" + ("0" + b.toString(16)).substr(-2); }).join(""));
926    }
927    catch (_a) {
928        // failed to decode
929    }
930    return { bytes: bytes, text: text };
931}
932function decodeKanji(stream, size) {
933    var bytes = [];
934    var text = "";
935    var characterCountSize = [8, 10, 12][size];
936    var length = stream.readBits(characterCountSize);
937    for (var i = 0; i < length; i++) {
938        var k = stream.readBits(13);
939        var c = (Math.floor(k / 0xC0) << 8) | (k % 0xC0);
940        if (c < 0x1F00) {
941            c += 0x8140;
942        }
943        else {
944            c += 0xC140;
945        }
946        bytes.push(c >> 8, c & 0xFF);
947        text += String.fromCharCode(shiftJISTable_1.shiftJISTable[c]);
948    }
949    return { bytes: bytes, text: text };
950}
951function decode(data, version) {
952    var _a, _b, _c, _d;
953    var stream = new BitStream_1.BitStream(data);
954    // There are 3 'sizes' based on the version. 1-9 is small (0), 10-26 is medium (1) and 27-40 is large (2).
955    var size = version <= 9 ? 0 : version <= 26 ? 1 : 2;
956    var result = {
957        text: "",
958        bytes: [],
959        chunks: [],
960        version: version,
961    };
962    while (stream.available() >= 4) {
963        var mode = stream.readBits(4);
964        if (mode === ModeByte.Terminator) {
965            return result;
966        }
967        else if (mode === ModeByte.ECI) {
968            if (stream.readBits(1) === 0) {
969                result.chunks.push({
970                    type: Mode.ECI,
971                    assignmentNumber: stream.readBits(7),
972                });
973            }
974            else if (stream.readBits(1) === 0) {
975                result.chunks.push({
976                    type: Mode.ECI,
977                    assignmentNumber: stream.readBits(14),
978                });
979            }
980            else if (stream.readBits(1) === 0) {
981                result.chunks.push({
982                    type: Mode.ECI,
983                    assignmentNumber: stream.readBits(21),
984                });
985            }
986            else {
987                // ECI data seems corrupted
988                result.chunks.push({
989                    type: Mode.ECI,
990                    assignmentNumber: -1,
991                });
992            }
993        }
994        else if (mode === ModeByte.Numeric) {
995            var numericResult = decodeNumeric(stream, size);
996            result.text += numericResult.text;
997            (_a = result.bytes).push.apply(_a, numericResult.bytes);
998            result.chunks.push({
999                type: Mode.Numeric,
1000                text: numericResult.text,
1001            });
1002        }
1003        else if (mode === ModeByte.Alphanumeric) {
1004            var alphanumericResult = decodeAlphanumeric(stream, size);
1005            result.text += alphanumericResult.text;
1006            (_b = result.bytes).push.apply(_b, alphanumericResult.bytes);
1007            result.chunks.push({
1008                type: Mode.Alphanumeric,
1009                text: alphanumericResult.text,
1010            });
1011        }
1012        else if (mode === ModeByte.Byte) {
1013            var byteResult = decodeByte(stream, size);
1014            result.text += byteResult.text;
1015            (_c = result.bytes).push.apply(_c, byteResult.bytes);
1016            result.chunks.push({
1017                type: Mode.Byte,
1018                bytes: byteResult.bytes,
1019                text: byteResult.text,
1020            });
1021        }
1022        else if (mode === ModeByte.Kanji) {
1023            var kanjiResult = decodeKanji(stream, size);
1024            result.text += kanjiResult.text;
1025            (_d = result.bytes).push.apply(_d, kanjiResult.bytes);
1026            result.chunks.push({
1027                type: Mode.Kanji,
1028                bytes: kanjiResult.bytes,
1029                text: kanjiResult.text,
1030            });
1031        }
1032    }
1033    // If there is no data left, or the remaining bits are all 0, then that counts as a termination marker
1034    if (stream.available() === 0 || stream.readBits(stream.available()) === 0) {
1035        return result;
1036    }
1037}
1038exports.decode = decode;
1039
1040
1041/***/ }),
1042/* 7 */
1043/***/ (function(module, exports, __webpack_require__) {
1044
1045"use strict";
1046
1047// tslint:disable:no-bitwise
1048Object.defineProperty(exports, "__esModule", { value: true });
1049var BitStream = /** @class */ (function () {
1050    function BitStream(bytes) {
1051        this.byteOffset = 0;
1052        this.bitOffset = 0;
1053        this.bytes = bytes;
1054    }
1055    BitStream.prototype.readBits = function (numBits) {
1056        if (numBits < 1 || numBits > 32 || numBits > this.available()) {
1057            throw new Error("Cannot read " + numBits.toString() + " bits");
1058        }
1059        var result = 0;
1060        // First, read remainder from current byte
1061        if (this.bitOffset > 0) {
1062            var bitsLeft = 8 - this.bitOffset;
1063            var toRead = numBits < bitsLeft ? numBits : bitsLeft;
1064            var bitsToNotRead = bitsLeft - toRead;
1065            var mask = (0xFF >> (8 - toRead)) << bitsToNotRead;
1066            result = (this.bytes[this.byteOffset] & mask) >> bitsToNotRead;
1067            numBits -= toRead;
1068            this.bitOffset += toRead;
1069            if (this.bitOffset === 8) {
1070                this.bitOffset = 0;
1071                this.byteOffset++;
1072            }
1073        }
1074        // Next read whole bytes
1075        if (numBits > 0) {
1076            while (numBits >= 8) {
1077                result = (result << 8) | (this.bytes[this.byteOffset] & 0xFF);
1078                this.byteOffset++;
1079                numBits -= 8;
1080            }
1081            // Finally read a partial byte
1082            if (numBits > 0) {
1083                var bitsToNotRead = 8 - numBits;
1084                var mask = (0xFF >> bitsToNotRead) << bitsToNotRead;
1085                result = (result << numBits) | ((this.bytes[this.byteOffset] & mask) >> bitsToNotRead);
1086                this.bitOffset += numBits;
1087            }
1088        }
1089        return result;
1090    };
1091    BitStream.prototype.available = function () {
1092        return 8 * (this.bytes.length - this.byteOffset) - this.bitOffset;
1093    };
1094    return BitStream;
1095}());
1096exports.BitStream = BitStream;
1097
1098
1099/***/ }),
1100/* 8 */
1101/***/ (function(module, exports, __webpack_require__) {
1102
1103"use strict";
1104
1105Object.defineProperty(exports, "__esModule", { value: true });
1106exports.shiftJISTable = {
1107    0x20: 0x0020,
1108    0x21: 0x0021,
1109    0x22: 0x0022,
1110    0x23: 0x0023,
1111    0x24: 0x0024,
1112    0x25: 0x0025,
1113    0x26: 0x0026,
1114    0x27: 0x0027,
1115    0x28: 0x0028,
1116    0x29: 0x0029,
1117    0x2A: 0x002A,
1118    0x2B: 0x002B,
1119    0x2C: 0x002C,
1120    0x2D: 0x002D,
1121    0x2E: 0x002E,
1122    0x2F: 0x002F,
1123    0x30: 0x0030,
1124    0x31: 0x0031,
1125    0x32: 0x0032,
1126    0x33: 0x0033,
1127    0x34: 0x0034,
1128    0x35: 0x0035,
1129    0x36: 0x0036,
1130    0x37: 0x0037,
1131    0x38: 0x0038,
1132    0x39: 0x0039,
1133    0x3A: 0x003A,
1134    0x3B: 0x003B,
1135    0x3C: 0x003C,
1136    0x3D: 0x003D,
1137    0x3E: 0x003E,
1138    0x3F: 0x003F,
1139    0x40: 0x0040,
1140    0x41: 0x0041,
1141    0x42: 0x0042,
1142    0x43: 0x0043,
1143    0x44: 0x0044,
1144    0x45: 0x0045,
1145    0x46: 0x0046,
1146    0x47: 0x0047,
1147    0x48: 0x0048,
1148    0x49: 0x0049,
1149    0x4A: 0x004A,
1150    0x4B: 0x004B,
1151    0x4C: 0x004C,
1152    0x4D: 0x004D,
1153    0x4E: 0x004E,
1154    0x4F: 0x004F,
1155    0x50: 0x0050,
1156    0x51: 0x0051,
1157    0x52: 0x0052,
1158    0x53: 0x0053,
1159    0x54: 0x0054,
1160    0x55: 0x0055,
1161    0x56: 0x0056,
1162    0x57: 0x0057,
1163    0x58: 0x0058,
1164    0x59: 0x0059,
1165    0x5A: 0x005A,
1166    0x5B: 0x005B,
1167    0x5C: 0x00A5,
1168    0x5D: 0x005D,
1169    0x5E: 0x005E,
1170    0x5F: 0x005F,
1171    0x60: 0x0060,
1172    0x61: 0x0061,
1173    0x62: 0x0062,
1174    0x63: 0x0063,
1175    0x64: 0x0064,
1176    0x65: 0x0065,
1177    0x66: 0x0066,
1178    0x67: 0x0067,
1179    0x68: 0x0068,
1180    0x69: 0x0069,
1181    0x6A: 0x006A,
1182    0x6B: 0x006B,
1183    0x6C: 0x006C,
1184    0x6D: 0x006D,
1185    0x6E: 0x006E,
1186    0x6F: 0x006F,
1187    0x70: 0x0070,
1188    0x71: 0x0071,
1189    0x72: 0x0072,
1190    0x73: 0x0073,