@cloudbase/framework-plugin-low-code 0.4.44 → 0.4.45

package/template/node_modules/@zxing/library/esm/core/qrcode/decoder/Decoder.js

@@ -0,0 +1,194 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+/*namespace com.google.zxing.qrcode.decoder {*/
+import ChecksumException from '../../ChecksumException';
+import BitMatrix from '../../common/BitMatrix';
+import GenericGF from '../../common/reedsolomon/GenericGF';
+import ReedSolomonDecoder from '../../common/reedsolomon/ReedSolomonDecoder';
+import BitMatrixParser from './BitMatrixParser';
+import DataBlock from './DataBlock';
+import DecodedBitStreamParser from './DecodedBitStreamParser';
+import QRCodeDecoderMetaData from './QRCodeDecoderMetaData';
+/*import java.util.Map;*/
+/**
+ * <p>The main class which implements QR Code decoding -- as opposed to locating and extracting
+ * the QR Code from an image.</p>
+ *
+ * @author Sean Owen
+ */
+var Decoder = /** @class */ (function () {
+    function Decoder() {
+        this.rsDecoder = new ReedSolomonDecoder(GenericGF.QR_CODE_FIELD_256);
+    }
+    // public decode(image: boolean[][]): DecoderResult /*throws ChecksumException, FormatException*/ {
+    //   return decode(image, null)
+    // }
+    /**
+     * <p>Convenience method that can decode a QR Code represented as a 2D array of booleans.
+     * "true" is taken to mean a black module.</p>
+     *
+     * @param image booleans representing white/black QR Code modules
+     * @param hints decoding hints that should be used to influence decoding
+     * @return text and bytes encoded within the QR Code
+     * @throws FormatException if the QR Code cannot be decoded
+     * @throws ChecksumException if error correction fails
+     */
+    Decoder.prototype.decodeBooleanArray = function (image, hints) {
+        return this.decodeBitMatrix(BitMatrix.parseFromBooleanArray(image), hints);
+    };
+    // public decodeBitMatrix(bits: BitMatrix): DecoderResult /*throws ChecksumException, FormatException*/ {
+    //   return decode(bits, null)
+    // }
+    /**
+     * <p>Decodes a QR Code represented as a {@link BitMatrix}. A 1 or "true" is taken to mean a black module.</p>
+     *
+     * @param bits booleans representing white/black QR Code modules
+     * @param hints decoding hints that should be used to influence decoding
+     * @return text and bytes encoded within the QR Code
+     * @throws FormatException if the QR Code cannot be decoded
+     * @throws ChecksumException if error correction fails
+     */
+    Decoder.prototype.decodeBitMatrix = function (bits, hints) {
+        // Construct a parser and read version, error-correction level
+        var parser = new BitMatrixParser(bits);
+        var ex = null;
+        try {
+            return this.decodeBitMatrixParser(parser, hints);
+        }
+        catch (e /*: FormatException, ChecksumException*/) {
+            ex = e;
+        }
+        try {
+            // Revert the bit matrix
+            parser.remask();
+            // Will be attempting a mirrored reading of the version and format info.
+            parser.setMirror(true);
+            // Preemptively read the version.
+            parser.readVersion();
+            // Preemptively read the format information.
+            parser.readFormatInformation();
+            /*
+             * Since we're here, this means we have successfully detected some kind
+             * of version and format information when mirrored. This is a good sign,
+             * that the QR code may be mirrored, and we should try once more with a
+             * mirrored content.
+             */
+            // Prepare for a mirrored reading.
+            parser.mirror();
+            var result = this.decodeBitMatrixParser(parser, hints);
+            // Success! Notify the caller that the code was mirrored.
+            result.setOther(new QRCodeDecoderMetaData(true));
+            return result;
+        }
+        catch (e /*FormatException | ChecksumException*/) {
+            // Throw the exception from the original reading
+            if (ex !== null) {
+                throw ex;
+            }
+            throw e;
+        }
+    };
+    Decoder.prototype.decodeBitMatrixParser = function (parser, hints) {
+        var e_1, _a, e_2, _b;
+        var version = parser.readVersion();
+        var ecLevel = parser.readFormatInformation().getErrorCorrectionLevel();
+        // Read codewords
+        var codewords = parser.readCodewords();
+        // Separate into data blocks
+        var dataBlocks = DataBlock.getDataBlocks(codewords, version, ecLevel);
+        // Count total number of data bytes
+        var totalBytes = 0;
+        try {
+            for (var dataBlocks_1 = __values(dataBlocks), dataBlocks_1_1 = dataBlocks_1.next(); !dataBlocks_1_1.done; dataBlocks_1_1 = dataBlocks_1.next()) {
+                var dataBlock = dataBlocks_1_1.value;
+                totalBytes += dataBlock.getNumDataCodewords();
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (dataBlocks_1_1 && !dataBlocks_1_1.done && (_a = dataBlocks_1.return)) _a.call(dataBlocks_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        var resultBytes = new Uint8Array(totalBytes);
+        var resultOffset = 0;
+        try {
+            // Error-correct and copy data blocks together into a stream of bytes
+            for (var dataBlocks_2 = __values(dataBlocks), dataBlocks_2_1 = dataBlocks_2.next(); !dataBlocks_2_1.done; dataBlocks_2_1 = dataBlocks_2.next()) {
+                var dataBlock = dataBlocks_2_1.value;
+                var codewordBytes = dataBlock.getCodewords();
+                var numDataCodewords = dataBlock.getNumDataCodewords();
+                this.correctErrors(codewordBytes, numDataCodewords);
+                for (var i = 0; i < numDataCodewords; i++) {
+                    resultBytes[resultOffset++] = codewordBytes[i];
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (dataBlocks_2_1 && !dataBlocks_2_1.done && (_b = dataBlocks_2.return)) _b.call(dataBlocks_2);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        // Decode the contents of that stream of bytes
+        return DecodedBitStreamParser.decode(resultBytes, version, ecLevel, hints);
+    };
+    /**
+     * <p>Given data and error-correction codewords received, possibly corrupted by errors, attempts to
+     * correct the errors in-place using Reed-Solomon error correction.</p>
+     *
+     * @param codewordBytes data and error correction codewords
+     * @param numDataCodewords number of codewords that are data bytes
+     * @throws ChecksumException if error correction fails
+     */
+    Decoder.prototype.correctErrors = function (codewordBytes, numDataCodewords /*int*/) {
+        // const numCodewords = codewordBytes.length;
+        // First read into an array of ints
+        var codewordsInts = new Int32Array(codewordBytes);
+        // TYPESCRIPTPORT: not realy necessary to transform to ints? could redesign everything to work with unsigned bytes?
+        // const codewordsInts = new Int32Array(numCodewords)
+        // for (let i = 0; i < numCodewords; i++) {
+        //   codewordsInts[i] = codewordBytes[i] & 0xFF
+        // }
+        try {
+            this.rsDecoder.decode(codewordsInts, codewordBytes.length - numDataCodewords);
+        }
+        catch (ignored /*: ReedSolomonException*/) {
+            throw new ChecksumException();
+        }
+        // Copy back into array of bytes -- only need to worry about the bytes that were data
+        // We don't care about errors in the error-correction codewords
+        for (var i = 0; i < numDataCodewords; i++) {
+            codewordBytes[i] = /*(byte) */ codewordsInts[i];
+        }
+    };
+    return Decoder;
+}());
+export default Decoder;
+//# sourceMappingURL=Decoder.js.map

package/template/node_modules/@zxing/library/esm/core/qrcode/decoder/Decoder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Decoder.js","sourceRoot":"","sources":["../../../../../src/core/qrcode/decoder/Decoder.ts"],"names":[],"mappings":"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"}

package/template/node_modules/@zxing/library/esm/core/qrcode/decoder/ECB.d.ts

@@ -0,0 +1,12 @@
+/**
+ * <p>Encapsulates the parameters for one error-correction block in one symbol version.
+ * This includes the number of data codewords, and the number of times a block with these
+ * parameters is used consecutively in the QR code version's format.</p>
+ */
+export default class ECB {
+    private count;
+    private dataCodewords;
+    constructor(count: number, dataCodewords: number);
+    getCount(): number;
+    getDataCodewords(): number;
+}

package/template/node_modules/@zxing/library/esm/core/qrcode/decoder/ECB.js

@@ -0,0 +1,20 @@
+/**
+ * <p>Encapsulates the parameters for one error-correction block in one symbol version.
+ * This includes the number of data codewords, and the number of times a block with these
+ * parameters is used consecutively in the QR code version's format.</p>
+ */
+var ECB = /** @class */ (function () {
+    function ECB(count /*int*/, dataCodewords /*int*/) {
+        this.count = count;
+        this.dataCodewords = dataCodewords;
+    }
+    ECB.prototype.getCount = function () {
+        return this.count;
+    };
+    ECB.prototype.getDataCodewords = function () {
+        return this.dataCodewords;
+    };
+    return ECB;
+}());
+export default ECB;
+//# sourceMappingURL=ECB.js.map

package/template/node_modules/@zxing/library/esm/core/qrcode/decoder/ECB.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ECB.js","sourceRoot":"","sources":["../../../../../src/core/qrcode/decoder/ECB.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH;IAII,aAAmB,KAAa,CAAC,OAAO,EAAE,aAAqB,CAAC,OAAO;QACnE,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;IACvC,CAAC;IAEM,sBAAQ,GAAf;QACI,OAAO,IAAI,CAAC,KAAK,CAAC;IACtB,CAAC;IAEM,8BAAgB,GAAvB;QACI,OAAO,IAAI,CAAC,aAAa,CAAC;IAC9B,CAAC;IACL,UAAC;AAAD,CAAC,AAhBD,IAgBC"}

package/template/node_modules/@zxing/library/esm/core/qrcode/decoder/ECBlocks.d.ts

@@ -0,0 +1,16 @@
+import ECB from './ECB';
+/**
+ * <p>Encapsulates a set of error-correction blocks in one symbol version. Most versions will
+ * use blocks of differing sizes within one version, so, this encapsulates the parameters for
+ * each set of blocks. It also holds the number of error-correction codewords per block since it
+ * will be the same across all blocks within one version.</p>
+ */
+export default class ECBlocks {
+    private ecCodewordsPerBlock;
+    private ecBlocks;
+    constructor(ecCodewordsPerBlock: number, ...ecBlocks: ECB[]);
+    getECCodewordsPerBlock(): number;
+    getNumBlocks(): number;
+    getTotalECCodewords(): number;
+    getECBlocks(): ECB[];
+}

package/template/node_modules/@zxing/library/esm/core/qrcode/decoder/ECBlocks.js

@@ -0,0 +1,58 @@
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+/**
+ * <p>Encapsulates a set of error-correction blocks in one symbol version. Most versions will
+ * use blocks of differing sizes within one version, so, this encapsulates the parameters for
+ * each set of blocks. It also holds the number of error-correction codewords per block since it
+ * will be the same across all blocks within one version.</p>
+ */
+var ECBlocks = /** @class */ (function () {
+    function ECBlocks(ecCodewordsPerBlock /*int*/) {
+        var ecBlocks = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            ecBlocks[_i - 1] = arguments[_i];
+        }
+        this.ecCodewordsPerBlock = ecCodewordsPerBlock;
+        this.ecBlocks = ecBlocks;
+    }
+    ECBlocks.prototype.getECCodewordsPerBlock = function () {
+        return this.ecCodewordsPerBlock;
+    };
+    ECBlocks.prototype.getNumBlocks = function () {
+        var e_1, _a;
+        var total = 0;
+        var ecBlocks = this.ecBlocks;
+        try {
+            for (var ecBlocks_1 = __values(ecBlocks), ecBlocks_1_1 = ecBlocks_1.next(); !ecBlocks_1_1.done; ecBlocks_1_1 = ecBlocks_1.next()) {
+                var ecBlock = ecBlocks_1_1.value;
+                total += ecBlock.getCount();
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (ecBlocks_1_1 && !ecBlocks_1_1.done && (_a = ecBlocks_1.return)) _a.call(ecBlocks_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return total;
+    };
+    ECBlocks.prototype.getTotalECCodewords = function () {
+        return this.ecCodewordsPerBlock * this.getNumBlocks();
+    };
+    ECBlocks.prototype.getECBlocks = function () {
+        return this.ecBlocks;
+    };
+    return ECBlocks;
+}());
+export default ECBlocks;
+//# sourceMappingURL=ECBlocks.js.map

package/template/node_modules/@zxing/library/esm/core/qrcode/decoder/ECBlocks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ECBlocks.js","sourceRoot":"","sources":["../../../../../src/core/qrcode/decoder/ECBlocks.ts"],"names":[],"mappings":";;;;;;;;;;;AAEA;;;;;GAKG;AACH;IAGI,kBAA2B,mBAA2B,CAAC,OAAO;QAAE,kBAAkB;aAAlB,UAAkB,EAAlB,qBAAkB,EAAlB,IAAkB;YAAlB,iCAAkB;;QAAvD,wBAAmB,GAAnB,mBAAmB,CAAQ;QAClD,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC7B,CAAC;IAEM,yCAAsB,GAA7B;QACI,OAAO,IAAI,CAAC,mBAAmB,CAAC;IACpC,CAAC;IAEM,+BAAY,GAAnB;;QACI,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,IAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;;YAC/B,KAAsB,IAAA,aAAA,SAAA,QAAQ,CAAA,kCAAA,wDAAE;gBAA3B,IAAM,OAAO,qBAAA;gBACd,KAAK,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;aAC/B;;;;;;;;;QACD,OAAO,KAAK,CAAC;IACjB,CAAC;IAEM,sCAAmB,GAA1B;QACI,OAAO,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;IAC1D,CAAC;IAEM,8BAAW,GAAlB;QACI,OAAO,IAAI,CAAC,QAAQ,CAAC;IACzB,CAAC;IACL,eAAC;AAAD,CAAC,AA3BD,IA2BC"}

package/template/node_modules/@zxing/library/esm/core/qrcode/decoder/ErrorCorrectionLevel.d.ts

@@ -0,0 +1,38 @@
+export declare enum ErrorCorrectionLevelValues {
+    L = 0,
+    M = 1,
+    Q = 2,
+    H = 3
+}
+/**
+ * <p>See ISO 18004:2006, 6.5.1. This enum encapsulates the four error correction levels
+ * defined by the QR code standard.</p>
+ *
+ * @author Sean Owen
+ */
+export default class ErrorCorrectionLevel {
+    private value;
+    private stringValue;
+    private bits;
+    private static FOR_BITS;
+    private static FOR_VALUE;
+    /** L = ~7% correction */
+    static L: ErrorCorrectionLevel;
+    /** M = ~15% correction */
+    static M: ErrorCorrectionLevel;
+    /** Q = ~25% correction */
+    static Q: ErrorCorrectionLevel;
+    /** H = ~30% correction */
+    static H: ErrorCorrectionLevel;
+    private constructor();
+    getValue(): ErrorCorrectionLevelValues;
+    getBits(): number;
+    static fromString(s: string): ErrorCorrectionLevel;
+    toString(): string;
+    equals(o: any): boolean;
+    /**
+     * @param bits int containing the two bits encoding a QR Code's error correction level
+     * @return ErrorCorrectionLevel representing the encoded error correction level
+     */
+    static forBits(bits: number): ErrorCorrectionLevel;
+}

package/template/node_modules/@zxing/library/esm/core/qrcode/decoder/ErrorCorrectionLevel.js

@@ -0,0 +1,88 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/*namespace com.google.zxing.qrcode.decoder {*/
+import ArgumentException from '../../ArgumentException';
+import IllegalArgumentException from '../../IllegalArgumentException';
+export var ErrorCorrectionLevelValues;
+(function (ErrorCorrectionLevelValues) {
+    ErrorCorrectionLevelValues[ErrorCorrectionLevelValues["L"] = 0] = "L";
+    ErrorCorrectionLevelValues[ErrorCorrectionLevelValues["M"] = 1] = "M";
+    ErrorCorrectionLevelValues[ErrorCorrectionLevelValues["Q"] = 2] = "Q";
+    ErrorCorrectionLevelValues[ErrorCorrectionLevelValues["H"] = 3] = "H";
+})(ErrorCorrectionLevelValues || (ErrorCorrectionLevelValues = {}));
+/**
+ * <p>See ISO 18004:2006, 6.5.1. This enum encapsulates the four error correction levels
+ * defined by the QR code standard.</p>
+ *
+ * @author Sean Owen
+ */
+var ErrorCorrectionLevel = /** @class */ (function () {
+    function ErrorCorrectionLevel(value, stringValue, bits /*int*/) {
+        this.value = value;
+        this.stringValue = stringValue;
+        this.bits = bits;
+        ErrorCorrectionLevel.FOR_BITS.set(bits, this);
+        ErrorCorrectionLevel.FOR_VALUE.set(value, this);
+    }
+    ErrorCorrectionLevel.prototype.getValue = function () {
+        return this.value;
+    };
+    ErrorCorrectionLevel.prototype.getBits = function () {
+        return this.bits;
+    };
+    ErrorCorrectionLevel.fromString = function (s) {
+        switch (s) {
+            case 'L': return ErrorCorrectionLevel.L;
+            case 'M': return ErrorCorrectionLevel.M;
+            case 'Q': return ErrorCorrectionLevel.Q;
+            case 'H': return ErrorCorrectionLevel.H;
+            default: throw new ArgumentException(s + 'not available');
+        }
+    };
+    ErrorCorrectionLevel.prototype.toString = function () {
+        return this.stringValue;
+    };
+    ErrorCorrectionLevel.prototype.equals = function (o) {
+        if (!(o instanceof ErrorCorrectionLevel)) {
+            return false;
+        }
+        var other = o;
+        return this.value === other.value;
+    };
+    /**
+     * @param bits int containing the two bits encoding a QR Code's error correction level
+     * @return ErrorCorrectionLevel representing the encoded error correction level
+     */
+    ErrorCorrectionLevel.forBits = function (bits /*int*/) {
+        if (bits < 0 || bits >= ErrorCorrectionLevel.FOR_BITS.size) {
+            throw new IllegalArgumentException();
+        }
+        return ErrorCorrectionLevel.FOR_BITS.get(bits);
+    };
+    ErrorCorrectionLevel.FOR_BITS = new Map();
+    ErrorCorrectionLevel.FOR_VALUE = new Map();
+    /** L = ~7% correction */
+    ErrorCorrectionLevel.L = new ErrorCorrectionLevel(ErrorCorrectionLevelValues.L, 'L', 0x01);
+    /** M = ~15% correction */
+    ErrorCorrectionLevel.M = new ErrorCorrectionLevel(ErrorCorrectionLevelValues.M, 'M', 0x00);
+    /** Q = ~25% correction */
+    ErrorCorrectionLevel.Q = new ErrorCorrectionLevel(ErrorCorrectionLevelValues.Q, 'Q', 0x03);
+    /** H = ~30% correction */
+    ErrorCorrectionLevel.H = new ErrorCorrectionLevel(ErrorCorrectionLevelValues.H, 'H', 0x02);
+    return ErrorCorrectionLevel;
+}());
+export default ErrorCorrectionLevel;
+//# sourceMappingURL=ErrorCorrectionLevel.js.map

package/template/node_modules/@zxing/library/esm/core/qrcode/decoder/ErrorCorrectionLevel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ErrorCorrectionLevel.js","sourceRoot":"","sources":["../../../../../src/core/qrcode/decoder/ErrorCorrectionLevel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,+CAA+C;AAG/C,OAAO,iBAAiB,MAAM,yBAAyB,CAAC;AACxD,OAAO,wBAAwB,MAAM,gCAAgC,CAAC;AAEtE,MAAM,CAAN,IAAY,0BAKX;AALD,WAAY,0BAA0B;IAClC,qEAAC,CAAA;IACD,qEAAC,CAAA;IACD,qEAAC,CAAA;IACD,qEAAC,CAAA;AACL,CAAC,EALW,0BAA0B,KAA1B,0BAA0B,QAKrC;AAED;;;;;GAKG;AACH;IAcI,8BAA4B,KAAiC,EAAU,WAAmB,EAAU,IAAY,CAAC,OAAO;QAA5F,UAAK,GAAL,KAAK,CAA4B;QAAU,gBAAW,GAAX,WAAW,CAAQ;QAAU,SAAI,GAAJ,IAAI,CAAQ;QAC5G,oBAAoB,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QAC9C,oBAAoB,CAAC,SAAS,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IACpD,CAAC;IAEM,uCAAQ,GAAf;QACI,OAAO,IAAI,CAAC,KAAK,CAAC;IACtB,CAAC;IAEM,sCAAO,GAAd;QACI,OAAO,IAAI,CAAC,IAAI,CAAC;IACrB,CAAC;IAEa,+BAAU,GAAxB,UAAyB,CAAS;QAC9B,QAAQ,CAAC,EAAE;YACP,KAAK,GAAG,CAAC,CAAC,OAAO,oBAAoB,CAAC,CAAC,CAAC;YACxC,KAAK,GAAG,CAAC,CAAC,OAAO,oBAAoB,CAAC,CAAC,CAAC;YACxC,KAAK,GAAG,CAAC,CAAC,OAAO,oBAAoB,CAAC,CAAC,CAAC;YACxC,KAAK,GAAG,CAAC,CAAC,OAAO,oBAAoB,CAAC,CAAC,CAAC;YACxC,OAAO,CAAC,CAAC,MAAM,IAAI,iBAAiB,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC;SAC7D;IACL,CAAC;IAEM,uCAAQ,GAAf;QACI,OAAO,IAAI,CAAC,WAAW,CAAC;IAC5B,CAAC;IAEM,qCAAM,GAAb,UAAc,CAAM;QAChB,IAAI,CAAC,CAAC,CAAC,YAAY,oBAAoB,CAAC,EAAE;YACtC,OAAO,KAAK,CAAC;SAChB;QACD,IAAM,KAAK,GAAyB,CAAC,CAAC;QACtC,OAAO,IAAI,CAAC,KAAK,KAAK,KAAK,CAAC,KAAK,CAAC;IACtC,CAAC;IACD;;;OAGG;IACW,4BAAO,GAArB,UAAsB,IAAY,CAAC,OAAO;QACtC,IAAI,IAAI,GAAG,CAAC,IAAI,IAAI,IAAI,oBAAoB,CAAC,QAAQ,CAAC,IAAI,EAAE;YACxD,MAAM,IAAI,wBAAwB,EAAE,CAAC;SACxC;QACD,OAAO,oBAAoB,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACnD,CAAC;IAvDc,6BAAQ,GAAG,IAAI,GAAG,EAAgC,CAAC;IACnD,8BAAS,GAAG,IAAI,GAAG,EAAoD,CAAC;IAEvF,yBAAyB;IACX,sBAAC,GAAG,IAAI,oBAAoB,CAAC,0BAA0B,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;IACpF,0BAA0B;IACZ,sBAAC,GAAG,IAAI,oBAAoB,CAAC,0BAA0B,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;IACpF,0BAA0B;IACZ,sBAAC,GAAG,IAAI,oBAAoB,CAAC,0BAA0B,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;IACpF,0BAA0B;IACZ,sBAAC,GAAG,IAAI,oBAAoB,CAAC,0BAA0B,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;IA+CxF,2BAAC;CAAA,AA3DD,IA2DC;eA3DoB,oBAAoB"}

package/template/node_modules/@zxing/library/esm/core/qrcode/decoder/FormatInformation.d.ts

@@ -0,0 +1,33 @@
+import ErrorCorrectionLevel from './ErrorCorrectionLevel';
+/**
+ * <p>Encapsulates a QR Code's format information, including the data mask used and
+ * error correction level.</p>
+ *
+ * @author Sean Owen
+ * @see DataMask
+ * @see ErrorCorrectionLevel
+ */
+export default class FormatInformation {
+    private static FORMAT_INFO_MASK_QR;
+    /**
+     * See ISO 18004:2006, Annex C, Table C.1
+     */
+    private static FORMAT_INFO_DECODE_LOOKUP;
+    private errorCorrectionLevel;
+    private dataMask;
+    private constructor();
+    static numBitsDiffering(a: number, b: number): number;
+    /**
+     * @param maskedFormatInfo1 format info indicator, with mask still applied
+     * @param maskedFormatInfo2 second copy of same info; both are checked at the same time
+     *  to establish best match
+     * @return information about the format it specifies, or {@code null}
+     *  if doesn't seem to match any known pattern
+     */
+    static decodeFormatInformation(maskedFormatInfo1: number, maskedFormatInfo2: number): FormatInformation;
+    private static doDecodeFormatInformation;
+    getErrorCorrectionLevel(): ErrorCorrectionLevel;
+    getDataMask(): number;
+    hashCode(): number;
+    equals(o: Object): boolean;
+}

package/template/node_modules/@zxing/library/esm/core/qrcode/decoder/FormatInformation.js

@@ -0,0 +1,167 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+/*namespace com.google.zxing.qrcode.decoder {*/
+import ErrorCorrectionLevel from './ErrorCorrectionLevel';
+import Integer from '../../util/Integer';
+/**
+ * <p>Encapsulates a QR Code's format information, including the data mask used and
+ * error correction level.</p>
+ *
+ * @author Sean Owen
+ * @see DataMask
+ * @see ErrorCorrectionLevel
+ */
+var FormatInformation = /** @class */ (function () {
+    function FormatInformation(formatInfo /*int*/) {
+        // Bits 3,4
+        this.errorCorrectionLevel = ErrorCorrectionLevel.forBits((formatInfo >> 3) & 0x03);
+        // Bottom 3 bits
+        this.dataMask = /*(byte) */ (formatInfo & 0x07);
+    }
+    FormatInformation.numBitsDiffering = function (a /*int*/, b /*int*/) {
+        return Integer.bitCount(a ^ b);
+    };
+    /**
+     * @param maskedFormatInfo1 format info indicator, with mask still applied
+     * @param maskedFormatInfo2 second copy of same info; both are checked at the same time
+     *  to establish best match
+     * @return information about the format it specifies, or {@code null}
+     *  if doesn't seem to match any known pattern
+     */
+    FormatInformation.decodeFormatInformation = function (maskedFormatInfo1 /*int*/, maskedFormatInfo2 /*int*/) {
+        var formatInfo = FormatInformation.doDecodeFormatInformation(maskedFormatInfo1, maskedFormatInfo2);
+        if (formatInfo !== null) {
+            return formatInfo;
+        }
+        // Should return null, but, some QR codes apparently
+        // do not mask this info. Try again by actually masking the pattern
+        // first
+        return FormatInformation.doDecodeFormatInformation(maskedFormatInfo1 ^ FormatInformation.FORMAT_INFO_MASK_QR, maskedFormatInfo2 ^ FormatInformation.FORMAT_INFO_MASK_QR);
+    };
+    FormatInformation.doDecodeFormatInformation = function (maskedFormatInfo1 /*int*/, maskedFormatInfo2 /*int*/) {
+        var e_1, _a;
+        // Find the int in FORMAT_INFO_DECODE_LOOKUP with fewest bits differing
+        var bestDifference = Number.MAX_SAFE_INTEGER;
+        var bestFormatInfo = 0;
+        try {
+            for (var _b = __values(FormatInformation.FORMAT_INFO_DECODE_LOOKUP), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var decodeInfo = _c.value;
+                var targetInfo = decodeInfo[0];
+                if (targetInfo === maskedFormatInfo1 || targetInfo === maskedFormatInfo2) {
+                    // Found an exact match
+                    return new FormatInformation(decodeInfo[1]);
+                }
+                var bitsDifference = FormatInformation.numBitsDiffering(maskedFormatInfo1, targetInfo);
+                if (bitsDifference < bestDifference) {
+                    bestFormatInfo = decodeInfo[1];
+                    bestDifference = bitsDifference;
+                }
+                if (maskedFormatInfo1 !== maskedFormatInfo2) {
+                    // also try the other option
+                    bitsDifference = FormatInformation.numBitsDiffering(maskedFormatInfo2, targetInfo);
+                    if (bitsDifference < bestDifference) {
+                        bestFormatInfo = decodeInfo[1];
+                        bestDifference = bitsDifference;
+                    }
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        // Hamming distance of the 32 masked codes is 7, by construction, so <= 3 bits
+        // differing means we found a match
+        if (bestDifference <= 3) {
+            return new FormatInformation(bestFormatInfo);
+        }
+        return null;
+    };
+    FormatInformation.prototype.getErrorCorrectionLevel = function () {
+        return this.errorCorrectionLevel;
+    };
+    FormatInformation.prototype.getDataMask = function () {
+        return this.dataMask;
+    };
+    /*@Override*/
+    FormatInformation.prototype.hashCode = function () {
+        return (this.errorCorrectionLevel.getBits() << 3) | this.dataMask;
+    };
+    /*@Override*/
+    FormatInformation.prototype.equals = function (o) {
+        if (!(o instanceof FormatInformation)) {
+            return false;
+        }
+        var other = o;
+        return this.errorCorrectionLevel === other.errorCorrectionLevel &&
+            this.dataMask === other.dataMask;
+    };
+    FormatInformation.FORMAT_INFO_MASK_QR = 0x5412;
+    /**
+     * See ISO 18004:2006, Annex C, Table C.1
+     */
+    FormatInformation.FORMAT_INFO_DECODE_LOOKUP = [
+        Int32Array.from([0x5412, 0x00]),
+        Int32Array.from([0x5125, 0x01]),
+        Int32Array.from([0x5E7C, 0x02]),
+        Int32Array.from([0x5B4B, 0x03]),
+        Int32Array.from([0x45F9, 0x04]),
+        Int32Array.from([0x40CE, 0x05]),
+        Int32Array.from([0x4F97, 0x06]),
+        Int32Array.from([0x4AA0, 0x07]),
+        Int32Array.from([0x77C4, 0x08]),
+        Int32Array.from([0x72F3, 0x09]),
+        Int32Array.from([0x7DAA, 0x0A]),
+        Int32Array.from([0x789D, 0x0B]),
+        Int32Array.from([0x662F, 0x0C]),
+        Int32Array.from([0x6318, 0x0D]),
+        Int32Array.from([0x6C41, 0x0E]),
+        Int32Array.from([0x6976, 0x0F]),
+        Int32Array.from([0x1689, 0x10]),
+        Int32Array.from([0x13BE, 0x11]),
+        Int32Array.from([0x1CE7, 0x12]),
+        Int32Array.from([0x19D0, 0x13]),
+        Int32Array.from([0x0762, 0x14]),
+        Int32Array.from([0x0255, 0x15]),
+        Int32Array.from([0x0D0C, 0x16]),
+        Int32Array.from([0x083B, 0x17]),
+        Int32Array.from([0x355F, 0x18]),
+        Int32Array.from([0x3068, 0x19]),
+        Int32Array.from([0x3F31, 0x1A]),
+        Int32Array.from([0x3A06, 0x1B]),
+        Int32Array.from([0x24B4, 0x1C]),
+        Int32Array.from([0x2183, 0x1D]),
+        Int32Array.from([0x2EDA, 0x1E]),
+        Int32Array.from([0x2BED, 0x1F]),
+    ];
+    return FormatInformation;
+}());
+export default FormatInformation;
+//# sourceMappingURL=FormatInformation.js.map