qrcode.vue 3.3.3 → 3.4.0

package/dist/qrcode.vue.browser.js

@@ -1,7 +1,7 @@
 /*!
- * qrcode.vue v3.3.3
+ * qrcode.vue v3.4.0
  * A Vue.js component to generate QRCode.
- * © 2017-2021 @scopewu(https://github.com/scopewu)
+ * © 2017-2023 @scopewu(https://github.com/scopewu)
  * MIT License.
  */
 (function (global, factory) {
@@ -10,7 +10,7 @@
     (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.QrcodeVue = factory(global.Vue));
 })(this, (function (vue) { 'use strict';
 
-    /*! *****************************************************************************
+    /******************************************************************************
     Copyright (c) Microsoft Corporation.
 
     Permission to use, copy, modify, and/or distribute this software for any
@@ -36,1435 +36,1055 @@
         return __assign.apply(this, arguments);
     };
 
-    var mode$1 = {
-    	MODE_NUMBER :		1 << 0,
-    	MODE_ALPHA_NUM : 	1 << 1,
-    	MODE_8BIT_BYTE : 	1 << 2,
-    	MODE_KANJI :		1 << 3
-    };
-
-    var mode = mode$1;
-
-    function QR8bitByte(data) {
-    	this.mode = mode.MODE_8BIT_BYTE;
-    	this.data = data;
-    }
-
-    QR8bitByte.prototype = {
-
-    	getLength : function(buffer) {
-    		return this.data.length;
-    	},
-    	
-    	write : function(buffer) {
-    		for (var i = 0; i < this.data.length; i++) {
-    			// not JIS ...
-    			buffer.put(this.data.charCodeAt(i), 8);
-    		}
-    	}
-    };
-
-    var _8BitByte = QR8bitByte;
-
-    var ErrorCorrectLevel = {
-    	L : 1,
-    	M : 0,
-    	Q : 3,
-    	H : 2
-    };
-
-    // ErrorCorrectLevel
-    var ECL = ErrorCorrectLevel;
-
-    function QRRSBlock(totalCount, dataCount) {
-    	this.totalCount = totalCount;
-    	this.dataCount  = dataCount;
-    }
-
-    QRRSBlock.RS_BLOCK_TABLE = [
-
-    	// L
-    	// M
-    	// Q
-    	// H
-
-    	// 1
-    	[1, 26, 19],
-    	[1, 26, 16],
-    	[1, 26, 13],
-    	[1, 26, 9],
-    	
-    	// 2
-    	[1, 44, 34],
-    	[1, 44, 28],
-    	[1, 44, 22],
-    	[1, 44, 16],
-
-    	// 3
-    	[1, 70, 55],
-    	[1, 70, 44],
-    	[2, 35, 17],
-    	[2, 35, 13],
-
-    	// 4		
-    	[1, 100, 80],
-    	[2, 50, 32],
-    	[2, 50, 24],
-    	[4, 25, 9],
-    	
-    	// 5
-    	[1, 134, 108],
-    	[2, 67, 43],
-    	[2, 33, 15, 2, 34, 16],
-    	[2, 33, 11, 2, 34, 12],
-    	
-    	// 6
-    	[2, 86, 68],
-    	[4, 43, 27],
-    	[4, 43, 19],
-    	[4, 43, 15],
-    	
-    	// 7		
-    	[2, 98, 78],
-    	[4, 49, 31],
-    	[2, 32, 14, 4, 33, 15],
-    	[4, 39, 13, 1, 40, 14],
-    	
-    	// 8
-    	[2, 121, 97],
-    	[2, 60, 38, 2, 61, 39],
-    	[4, 40, 18, 2, 41, 19],
-    	[4, 40, 14, 2, 41, 15],
-    	
-    	// 9
-    	[2, 146, 116],
-    	[3, 58, 36, 2, 59, 37],
-    	[4, 36, 16, 4, 37, 17],
-    	[4, 36, 12, 4, 37, 13],
-    	
-    	// 10		
-    	[2, 86, 68, 2, 87, 69],
-    	[4, 69, 43, 1, 70, 44],
-    	[6, 43, 19, 2, 44, 20],
-    	[6, 43, 15, 2, 44, 16],
-
-    	// 11
-    	[4, 101, 81],
-    	[1, 80, 50, 4, 81, 51],
-    	[4, 50, 22, 4, 51, 23],
-    	[3, 36, 12, 8, 37, 13],
-
-    	// 12
-    	[2, 116, 92, 2, 117, 93],
-    	[6, 58, 36, 2, 59, 37],
-    	[4, 46, 20, 6, 47, 21],
-    	[7, 42, 14, 4, 43, 15],
-
-    	// 13
-    	[4, 133, 107],
-    	[8, 59, 37, 1, 60, 38],
-    	[8, 44, 20, 4, 45, 21],
-    	[12, 33, 11, 4, 34, 12],
-
-    	// 14
-    	[3, 145, 115, 1, 146, 116],
-    	[4, 64, 40, 5, 65, 41],
-    	[11, 36, 16, 5, 37, 17],
-    	[11, 36, 12, 5, 37, 13],
-
-    	// 15
-    	[5, 109, 87, 1, 110, 88],
-    	[5, 65, 41, 5, 66, 42],
-    	[5, 54, 24, 7, 55, 25],
-    	[11, 36, 12],
-
-    	// 16
-    	[5, 122, 98, 1, 123, 99],
-    	[7, 73, 45, 3, 74, 46],
-    	[15, 43, 19, 2, 44, 20],
-    	[3, 45, 15, 13, 46, 16],
-
-    	// 17
-    	[1, 135, 107, 5, 136, 108],
-    	[10, 74, 46, 1, 75, 47],
-    	[1, 50, 22, 15, 51, 23],
-    	[2, 42, 14, 17, 43, 15],
-
-    	// 18
-    	[5, 150, 120, 1, 151, 121],
-    	[9, 69, 43, 4, 70, 44],
-    	[17, 50, 22, 1, 51, 23],
-    	[2, 42, 14, 19, 43, 15],
-
-    	// 19
-    	[3, 141, 113, 4, 142, 114],
-    	[3, 70, 44, 11, 71, 45],
-    	[17, 47, 21, 4, 48, 22],
-    	[9, 39, 13, 16, 40, 14],
-
-    	// 20
-    	[3, 135, 107, 5, 136, 108],
-    	[3, 67, 41, 13, 68, 42],
-    	[15, 54, 24, 5, 55, 25],
-    	[15, 43, 15, 10, 44, 16],
-
-    	// 21
-    	[4, 144, 116, 4, 145, 117],
-    	[17, 68, 42],
-    	[17, 50, 22, 6, 51, 23],
-    	[19, 46, 16, 6, 47, 17],
-
-    	// 22
-    	[2, 139, 111, 7, 140, 112],
-    	[17, 74, 46],
-    	[7, 54, 24, 16, 55, 25],
-    	[34, 37, 13],
-
-    	// 23
-    	[4, 151, 121, 5, 152, 122],
-    	[4, 75, 47, 14, 76, 48],
-    	[11, 54, 24, 14, 55, 25],
-    	[16, 45, 15, 14, 46, 16],
-
-    	// 24
-    	[6, 147, 117, 4, 148, 118],
-    	[6, 73, 45, 14, 74, 46],
-    	[11, 54, 24, 16, 55, 25],
-    	[30, 46, 16, 2, 47, 17],
-
-    	// 25
-    	[8, 132, 106, 4, 133, 107],
-    	[8, 75, 47, 13, 76, 48],
-    	[7, 54, 24, 22, 55, 25],
-    	[22, 45, 15, 13, 46, 16],
-
-    	// 26
-    	[10, 142, 114, 2, 143, 115],
-    	[19, 74, 46, 4, 75, 47],
-    	[28, 50, 22, 6, 51, 23],
-    	[33, 46, 16, 4, 47, 17],
-
-    	// 27
-    	[8, 152, 122, 4, 153, 123],
-    	[22, 73, 45, 3, 74, 46],
-    	[8, 53, 23, 26, 54, 24],
-    	[12, 45, 15, 28, 46, 16],
-
-    	// 28
-    	[3, 147, 117, 10, 148, 118],
-    	[3, 73, 45, 23, 74, 46],
-    	[4, 54, 24, 31, 55, 25],
-    	[11, 45, 15, 31, 46, 16],
-
-    	// 29
-    	[7, 146, 116, 7, 147, 117],
-    	[21, 73, 45, 7, 74, 46],
-    	[1, 53, 23, 37, 54, 24],
-    	[19, 45, 15, 26, 46, 16],
-
-    	// 30
-    	[5, 145, 115, 10, 146, 116],
-    	[19, 75, 47, 10, 76, 48],
-    	[15, 54, 24, 25, 55, 25],
-    	[23, 45, 15, 25, 46, 16],
-
-    	// 31
-    	[13, 145, 115, 3, 146, 116],
-    	[2, 74, 46, 29, 75, 47],
-    	[42, 54, 24, 1, 55, 25],
-    	[23, 45, 15, 28, 46, 16],
-
-    	// 32
-    	[17, 145, 115],
-    	[10, 74, 46, 23, 75, 47],
-    	[10, 54, 24, 35, 55, 25],
-    	[19, 45, 15, 35, 46, 16],
-
-    	// 33
-    	[17, 145, 115, 1, 146, 116],
-    	[14, 74, 46, 21, 75, 47],
-    	[29, 54, 24, 19, 55, 25],
-    	[11, 45, 15, 46, 46, 16],
-
-    	// 34
-    	[13, 145, 115, 6, 146, 116],
-    	[14, 74, 46, 23, 75, 47],
-    	[44, 54, 24, 7, 55, 25],
-    	[59, 46, 16, 1, 47, 17],
-
-    	// 35
-    	[12, 151, 121, 7, 152, 122],
-    	[12, 75, 47, 26, 76, 48],
-    	[39, 54, 24, 14, 55, 25],
-    	[22, 45, 15, 41, 46, 16],
-
-    	// 36
-    	[6, 151, 121, 14, 152, 122],
-    	[6, 75, 47, 34, 76, 48],
-    	[46, 54, 24, 10, 55, 25],
-    	[2, 45, 15, 64, 46, 16],
-
-    	// 37
-    	[17, 152, 122, 4, 153, 123],
-    	[29, 74, 46, 14, 75, 47],
-    	[49, 54, 24, 10, 55, 25],
-    	[24, 45, 15, 46, 46, 16],
-
-    	// 38
-    	[4, 152, 122, 18, 153, 123],
-    	[13, 74, 46, 32, 75, 47],
-    	[48, 54, 24, 14, 55, 25],
-    	[42, 45, 15, 32, 46, 16],
-
-    	// 39
-    	[20, 147, 117, 4, 148, 118],
-    	[40, 75, 47, 7, 76, 48],
-    	[43, 54, 24, 22, 55, 25],
-    	[10, 45, 15, 67, 46, 16],
-
-    	// 40
-    	[19, 148, 118, 6, 149, 119],
-    	[18, 75, 47, 31, 76, 48],
-    	[34, 54, 24, 34, 55, 25],
-    	[20, 45, 15, 61, 46, 16]
-    ];
-
-    QRRSBlock.getRSBlocks = function(typeNumber, errorCorrectLevel) {
-    	
-    	var rsBlock = QRRSBlock.getRsBlockTable(typeNumber, errorCorrectLevel);
-    	
-    	if (rsBlock == undefined) {
-    		throw new Error("bad rs block @ typeNumber:" + typeNumber + "/errorCorrectLevel:" + errorCorrectLevel);
-    	}
-
-    	var length = rsBlock.length / 3;
-    	
-    	var list = new Array();
-    	
-    	for (var i = 0; i < length; i++) {
-
-    		var count = rsBlock[i * 3 + 0];
-    		var totalCount = rsBlock[i * 3 + 1];
-    		var dataCount  = rsBlock[i * 3 + 2];
-
-    		for (var j = 0; j < count; j++) {
-    			list.push(new QRRSBlock(totalCount, dataCount) );	
-    		}
-    	}
-    	
-    	return list;
-    };
-
-    QRRSBlock.getRsBlockTable = function(typeNumber, errorCorrectLevel) {
-
-    	switch(errorCorrectLevel) {
-    	case ECL.L :
-    		return QRRSBlock.RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 0];
-    	case ECL.M :
-    		return QRRSBlock.RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 1];
-    	case ECL.Q :
-    		return QRRSBlock.RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 2];
-    	case ECL.H :
-    		return QRRSBlock.RS_BLOCK_TABLE[(typeNumber - 1) * 4 + 3];
-    	default :
-    		return undefined;
-    	}
-    };
-
-    var RSBlock$1 = QRRSBlock;
-
-    function QRBitBuffer() {
-    	this.buffer = new Array();
-    	this.length = 0;
-    }
-
-    QRBitBuffer.prototype = {
-
-    	get : function(index) {
-    		var bufIndex = Math.floor(index / 8);
-    		return ( (this.buffer[bufIndex] >>> (7 - index % 8) ) & 1) == 1;
-    	},
-    	
-    	put : function(num, length) {
-    		for (var i = 0; i < length; i++) {
-    			this.putBit( ( (num >>> (length - i - 1) ) & 1) == 1);
-    		}
-    	},
-    	
-    	getLengthInBits : function() {
-    		return this.length;
-    	},
-    	
-    	putBit : function(bit) {
-    	
-    		var bufIndex = Math.floor(this.length / 8);
-    		if (this.buffer.length <= bufIndex) {
-    			this.buffer.push(0);
-    		}
-    	
-    		if (bit) {
-    			this.buffer[bufIndex] |= (0x80 >>> (this.length % 8) );
-    		}
-    	
-    		this.length++;
-    	}
-    };
-
-    var BitBuffer$1 = QRBitBuffer;
-
-    var QRMath = {
-
-    	glog : function(n) {
-    	
-    		if (n < 1) {
-    			throw new Error("glog(" + n + ")");
-    		}
-    		
-    		return QRMath.LOG_TABLE[n];
-    	},
-    	
-    	gexp : function(n) {
-    	
-    		while (n < 0) {
-    			n += 255;
-    		}
-    	
-    		while (n >= 256) {
-    			n -= 255;
-    		}
-    	
-    		return QRMath.EXP_TABLE[n];
-    	},
-    	
-    	EXP_TABLE : new Array(256),
-    	
-    	LOG_TABLE : new Array(256)
-
+    /*
+     * QR Code generator library (TypeScript)
+     *
+     * Copyright (c) Project Nayuki. (MIT License)
+     * https://www.nayuki.io/page/qr-code-generator-library
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy of
+     * this software and associated documentation files (the "Software"), to deal in
+     * the Software without restriction, including without limitation the rights to
+     * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+     * the Software, and to permit persons to whom the Software is furnished to do so,
+     * subject to the following conditions:
+     * - The above copyright notice and this permission notice shall be included in
+     *   all copies or substantial portions of the Software.
+     * - The Software is provided "as is", without warranty of any kind, express or
+     *   implied, including but not limited to the warranties of merchantability,
+     *   fitness for a particular purpose and noninfringement. In no event shall the
+     *   authors or copyright holders be liable for any claim, damages or other
+     *   liability, whether in an action of contract, tort or otherwise, arising from,
+     *   out of or in connection with the Software or the use or other dealings in the
+     *   Software.
+     */
+    var qrcodegen;
+    (function (qrcodegen) {
+        /*---- QR Code symbol class ----*/
+        /*
+         * A QR Code symbol, which is a type of two-dimension barcode.
+         * Invented by Denso Wave and described in the ISO/IEC 18004 standard.
+         * Instances of this class represent an immutable square grid of dark and light cells.
+         * The class provides static factory functions to create a QR Code from text or binary data.
+         * The class covers the QR Code Model 2 specification, supporting all versions (sizes)
+         * from 1 to 40, all 4 error correction levels, and 4 character encoding modes.
+         *
+         * Ways to create a QR Code object:
+         * - High level: Take the payload data and call QrCode.encodeText() or QrCode.encodeBinary().
+         * - Mid level: Custom-make the list of segments and call QrCode.encodeSegments().
+         * - Low level: Custom-make the array of data codeword bytes (including
+         *   segment headers and final padding, excluding error correction codewords),
+         *   supply the appropriate version number, and call the QrCode() constructor.
+         * (Note that all ways require supplying the desired error correction level.)
+         */
+        var QrCode = /** @class */ (function () {
+            /*-- Constructor (low level) and fields --*/
+            // Creates a new QR Code with the given version number,
+            // error correction level, data codeword bytes, and mask number.
+            // This is a low-level API that most users should not use directly.
+            // A mid-level API is the encodeSegments() function.
+            function QrCode(
+            // The version number of this QR Code, which is between 1 and 40 (inclusive).
+            // This determines the size of this barcode.
+            version, 
+            // The error correction level used in this QR Code.
+            errorCorrectionLevel, dataCodewords, msk) {
+                this.version = version;
+                this.errorCorrectionLevel = errorCorrectionLevel;
+                // The modules of this QR Code (false = light, true = dark).
+                // Immutable after constructor finishes. Accessed through getModule().
+                this.modules = [];
+                // Indicates function modules that are not subjected to masking. Discarded when constructor finishes.
+                this.isFunction = [];
+                // Check scalar arguments
+                if (version < QrCode.MIN_VERSION || version > QrCode.MAX_VERSION)
+                    throw new RangeError("Version value out of range");
+                if (msk < -1 || msk > 7)
+                    throw new RangeError("Mask value out of range");
+                this.size = version * 4 + 17;
+                // Initialize both grids to be size*size arrays of Boolean false
+                var row = [];
+                for (var i = 0; i < this.size; i++)
+                    row.push(false);
+                for (var i = 0; i < this.size; i++) {
+                    this.modules.push(row.slice()); // Initially all light
+                    this.isFunction.push(row.slice());
+                }
+                // Compute ECC, draw modules
+                this.drawFunctionPatterns();
+                var allCodewords = this.addEccAndInterleave(dataCodewords);
+                this.drawCodewords(allCodewords);
+                // Do masking
+                if (msk == -1) { // Automatically choose best mask
+                    var minPenalty = 1000000000;
+                    for (var i = 0; i < 8; i++) {
+                        this.applyMask(i);
+                        this.drawFormatBits(i);
+                        var penalty = this.getPenaltyScore();
+                        if (penalty < minPenalty) {
+                            msk = i;
+                            minPenalty = penalty;
+                        }
+                        this.applyMask(i); // Undoes the mask due to XOR
+                    }
+                }
+                assert(0 <= msk && msk <= 7);
+                this.mask = msk;
+                this.applyMask(msk); // Apply the final choice of mask
+                this.drawFormatBits(msk); // Overwrite old format bits
+                this.isFunction = [];
+            }
+            /*-- Static factory functions (high level) --*/
+            // Returns a QR Code representing the given Unicode text string at the given error correction level.
+            // As a conservative upper bound, this function is guaranteed to succeed for strings that have 738 or fewer
+            // Unicode code points (not UTF-16 code units) if the low error correction level is used. The smallest possible
+            // QR Code version is automatically chosen for the output. The ECC level of the result may be higher than the
+            // ecl argument if it can be done without increasing the version.
+            QrCode.encodeText = function (text, ecl) {
+                var segs = qrcodegen.QrSegment.makeSegments(text);
+                return QrCode.encodeSegments(segs, ecl);
+            };
+            // Returns a QR Code representing the given binary data at the given error correction level.
+            // This function always encodes using the binary segment mode, not any text mode. The maximum number of
+            // bytes allowed is 2953. The smallest possible QR Code version is automatically chosen for the output.
+            // The ECC level of the result may be higher than the ecl argument if it can be done without increasing the version.
+            QrCode.encodeBinary = function (data, ecl) {
+                var seg = qrcodegen.QrSegment.makeBytes(data);
+                return QrCode.encodeSegments([seg], ecl);
+            };
+            /*-- Static factory functions (mid level) --*/
+            // Returns a QR Code representing the given segments with the given encoding parameters.
+            // The smallest possible QR Code version within the given range is automatically
+            // chosen for the output. Iff boostEcl is true, then the ECC level of the result
+            // may be higher than the ecl argument if it can be done without increasing the
+            // version. The mask number is either between 0 to 7 (inclusive) to force that
+            // mask, or -1 to automatically choose an appropriate mask (which may be slow).
+            // This function allows the user to create a custom sequence of segments that switches
+            // between modes (such as alphanumeric and byte) to encode text in less space.
+            // This is a mid-level API; the high-level API is encodeText() and encodeBinary().
+            QrCode.encodeSegments = function (segs, ecl, minVersion, maxVersion, mask, boostEcl) {
+                if (minVersion === void 0) { minVersion = 1; }
+                if (maxVersion === void 0) { maxVersion = 40; }
+                if (mask === void 0) { mask = -1; }
+                if (boostEcl === void 0) { boostEcl = true; }
+                if (!(QrCode.MIN_VERSION <= minVersion && minVersion <= maxVersion && maxVersion <= QrCode.MAX_VERSION)
+                    || mask < -1 || mask > 7)
+                    throw new RangeError("Invalid value");
+                // Find the minimal version number to use
+                var version;
+                var dataUsedBits;
+                for (version = minVersion;; version++) {
+                    var dataCapacityBits_1 = QrCode.getNumDataCodewords(version, ecl) * 8; // Number of data bits available
+                    var usedBits = QrSegment.getTotalBits(segs, version);
+                    if (usedBits <= dataCapacityBits_1) {
+                        dataUsedBits = usedBits;
+                        break; // This version number is found to be suitable
+                    }
+                    if (version >= maxVersion) // All versions in the range could not fit the given data
+                        throw new RangeError("Data too long");
+                }
+                // Increase the error correction level while the data still fits in the current version number
+                for (var _i = 0, _a = [QrCode.Ecc.MEDIUM, QrCode.Ecc.QUARTILE, QrCode.Ecc.HIGH]; _i < _a.length; _i++) { // From low to high
+                    var newEcl = _a[_i];
+                    if (boostEcl && dataUsedBits <= QrCode.getNumDataCodewords(version, newEcl) * 8)
+                        ecl = newEcl;
+                }
+                // Concatenate all segments to create the data bit string
+                var bb = [];
+                for (var _b = 0, segs_1 = segs; _b < segs_1.length; _b++) {
+                    var seg = segs_1[_b];
+                    appendBits(seg.mode.modeBits, 4, bb);
+                    appendBits(seg.numChars, seg.mode.numCharCountBits(version), bb);
+                    for (var _c = 0, _d = seg.getData(); _c < _d.length; _c++) {
+                        var b = _d[_c];
+                        bb.push(b);
+                    }
+                }
+                assert(bb.length == dataUsedBits);
+                // Add terminator and pad up to a byte if applicable
+                var dataCapacityBits = QrCode.getNumDataCodewords(version, ecl) * 8;
+                assert(bb.length <= dataCapacityBits);
+                appendBits(0, Math.min(4, dataCapacityBits - bb.length), bb);
+                appendBits(0, (8 - bb.length % 8) % 8, bb);
+                assert(bb.length % 8 == 0);
+                // Pad with alternating bytes until data capacity is reached
+                for (var padByte = 0xEC; bb.length < dataCapacityBits; padByte ^= 0xEC ^ 0x11)
+                    appendBits(padByte, 8, bb);
+                // Pack bits into bytes in big endian
+                var dataCodewords = [];
+                while (dataCodewords.length * 8 < bb.length)
+                    dataCodewords.push(0);
+                bb.forEach(function (b, i) {
+                    return dataCodewords[i >>> 3] |= b << (7 - (i & 7));
+                });
+                // Create the QR Code object
+                return new QrCode(version, ecl, dataCodewords, mask);
+            };
+            /*-- Accessor methods --*/
+            // Returns the color of the module (pixel) at the given coordinates, which is false
+            // for light or true for dark. The top left corner has the coordinates (x=0, y=0).
+            // If the given coordinates are out of bounds, then false (light) is returned.
+            QrCode.prototype.getModule = function (x, y) {
+                return 0 <= x && x < this.size && 0 <= y && y < this.size && this.modules[y][x];
+            };
+            QrCode.prototype.getModules = function () {
+                return this.modules;
+            };
+            /*-- Private helper methods for constructor: Drawing function modules --*/
+            // Reads this object's version field, and draws and marks all function modules.
+            QrCode.prototype.drawFunctionPatterns = function () {
+                // Draw horizontal and vertical timing patterns
+                for (var i = 0; i < this.size; i++) {
+                    this.setFunctionModule(6, i, i % 2 == 0);
+                    this.setFunctionModule(i, 6, i % 2 == 0);
+                }
+                // Draw 3 finder patterns (all corners except bottom right; overwrites some timing modules)
+                this.drawFinderPattern(3, 3);
+                this.drawFinderPattern(this.size - 4, 3);
+                this.drawFinderPattern(3, this.size - 4);
+                // Draw numerous alignment patterns
+                var alignPatPos = this.getAlignmentPatternPositions();
+                var numAlign = alignPatPos.length;
+                for (var i = 0; i < numAlign; i++) {
+                    for (var j = 0; j < numAlign; j++) {
+                        // Don't draw on the three finder corners
+                        if (!(i == 0 && j == 0 || i == 0 && j == numAlign - 1 || i == numAlign - 1 && j == 0))
+                            this.drawAlignmentPattern(alignPatPos[i], alignPatPos[j]);
+                    }
+                }
+                // Draw configuration data
+                this.drawFormatBits(0); // Dummy mask value; overwritten later in the constructor
+                this.drawVersion();
+            };
+            // Draws two copies of the format bits (with its own error correction code)
+            // based on the given mask and this object's error correction level field.
+            QrCode.prototype.drawFormatBits = function (mask) {
+                // Calculate error correction code and pack bits
+                var data = this.errorCorrectionLevel.formatBits << 3 | mask; // errCorrLvl is uint2, mask is uint3
+                var rem = data;
+                for (var i = 0; i < 10; i++)
+                    rem = (rem << 1) ^ ((rem >>> 9) * 0x537);
+                var bits = (data << 10 | rem) ^ 0x5412; // uint15
+                assert(bits >>> 15 == 0);
+                // Draw first copy
+                for (var i = 0; i <= 5; i++)
+                    this.setFunctionModule(8, i, getBit(bits, i));
+                this.setFunctionModule(8, 7, getBit(bits, 6));
+                this.setFunctionModule(8, 8, getBit(bits, 7));
+                this.setFunctionModule(7, 8, getBit(bits, 8));
+                for (var i = 9; i < 15; i++)
+                    this.setFunctionModule(14 - i, 8, getBit(bits, i));
+                // Draw second copy
+                for (var i = 0; i < 8; i++)
+                    this.setFunctionModule(this.size - 1 - i, 8, getBit(bits, i));
+                for (var i = 8; i < 15; i++)
+                    this.setFunctionModule(8, this.size - 15 + i, getBit(bits, i));
+                this.setFunctionModule(8, this.size - 8, true); // Always dark
+            };
+            // Draws two copies of the version bits (with its own error correction code),
+            // based on this object's version field, iff 7 <= version <= 40.
+            QrCode.prototype.drawVersion = function () {
+                if (this.version < 7)
+                    return;
+                // Calculate error correction code and pack bits
+                var rem = this.version; // version is uint6, in the range [7, 40]
+                for (var i = 0; i < 12; i++)
+                    rem = (rem << 1) ^ ((rem >>> 11) * 0x1F25);
+                var bits = this.version << 12 | rem; // uint18
+                assert(bits >>> 18 == 0);
+                // Draw two copies
+                for (var i = 0; i < 18; i++) {
+                    var color = getBit(bits, i);
+                    var a = this.size - 11 + i % 3;
+                    var b = Math.floor(i / 3);
+                    this.setFunctionModule(a, b, color);
+                    this.setFunctionModule(b, a, color);
+                }
+            };
+            // Draws a 9*9 finder pattern including the border separator,
+            // with the center module at (x, y). Modules can be out of bounds.
+            QrCode.prototype.drawFinderPattern = function (x, y) {
+                for (var dy = -4; dy <= 4; dy++) {
+                    for (var dx = -4; dx <= 4; dx++) {
+                        var dist = Math.max(Math.abs(dx), Math.abs(dy)); // Chebyshev/infinity norm
+                        var xx = x + dx;
+                        var yy = y + dy;
+                        if (0 <= xx && xx < this.size && 0 <= yy && yy < this.size)
+                            this.setFunctionModule(xx, yy, dist != 2 && dist != 4);
+                    }
+                }
+            };
+            // Draws a 5*5 alignment pattern, with the center module
+            // at (x, y). All modules must be in bounds.
+            QrCode.prototype.drawAlignmentPattern = function (x, y) {
+                for (var dy = -2; dy <= 2; dy++) {
+                    for (var dx = -2; dx <= 2; dx++)
+                        this.setFunctionModule(x + dx, y + dy, Math.max(Math.abs(dx), Math.abs(dy)) != 1);
+                }
+            };
+            // Sets the color of a module and marks it as a function module.
+            // Only used by the constructor. Coordinates must be in bounds.
+            QrCode.prototype.setFunctionModule = function (x, y, isDark) {
+                this.modules[y][x] = isDark;
+                this.isFunction[y][x] = true;
+            };
+            /*-- Private helper methods for constructor: Codewords and masking --*/
+            // Returns a new byte string representing the given data with the appropriate error correction
+            // codewords appended to it, based on this object's version and error correction level.
+            QrCode.prototype.addEccAndInterleave = function (data) {
+                var ver = this.version;
+                var ecl = this.errorCorrectionLevel;
+                if (data.length != QrCode.getNumDataCodewords(ver, ecl))
+                    throw new RangeError("Invalid argument");
+                // Calculate parameter numbers
+                var numBlocks = QrCode.NUM_ERROR_CORRECTION_BLOCKS[ecl.ordinal][ver];
+                var blockEccLen = QrCode.ECC_CODEWORDS_PER_BLOCK[ecl.ordinal][ver];
+                var rawCodewords = Math.floor(QrCode.getNumRawDataModules(ver) / 8);
+                var numShortBlocks = numBlocks - rawCodewords % numBlocks;
+                var shortBlockLen = Math.floor(rawCodewords / numBlocks);
+                // Split data into blocks and append ECC to each block
+                var blocks = [];
+                var rsDiv = QrCode.reedSolomonComputeDivisor(blockEccLen);
+                for (var i = 0, k = 0; i < numBlocks; i++) {
+                    var dat = data.slice(k, k + shortBlockLen - blockEccLen + (i < numShortBlocks ? 0 : 1));
+                    k += dat.length;
+                    var ecc = QrCode.reedSolomonComputeRemainder(dat, rsDiv);
+                    if (i < numShortBlocks)
+                        dat.push(0);
+                    blocks.push(dat.concat(ecc));
+                }
+                // Interleave (not concatenate) the bytes from every block into a single sequence
+                var result = [];
+                var _loop_1 = function (i) {
+                    blocks.forEach(function (block, j) {
+                        // Skip the padding byte in short blocks
+                        if (i != shortBlockLen - blockEccLen || j >= numShortBlocks)
+                            result.push(block[i]);
+                    });
+                };
+                for (var i = 0; i < blocks[0].length; i++) {
+                    _loop_1(i);
+                }
+                assert(result.length == rawCodewords);
+                return result;
+            };
+            // Draws the given sequence of 8-bit codewords (data and error correction) onto the entire
+            // data area of this QR Code. Function modules need to be marked off before this is called.
+            QrCode.prototype.drawCodewords = function (data) {
+                if (data.length != Math.floor(QrCode.getNumRawDataModules(this.version) / 8))
+                    throw new RangeError("Invalid argument");
+                var i = 0; // Bit index into the data
+                // Do the funny zigzag scan
+                for (var right = this.size - 1; right >= 1; right -= 2) { // Index of right column in each column pair
+                    if (right == 6)
+                        right = 5;
+                    for (var vert = 0; vert < this.size; vert++) { // Vertical counter
+                        for (var j = 0; j < 2; j++) {
+                            var x = right - j; // Actual x coordinate
+                            var upward = ((right + 1) & 2) == 0;
+                            var y = upward ? this.size - 1 - vert : vert; // Actual y coordinate
+                            if (!this.isFunction[y][x] && i < data.length * 8) {
+                                this.modules[y][x] = getBit(data[i >>> 3], 7 - (i & 7));
+                                i++;
+                            }
+                            // If this QR Code has any remainder bits (0 to 7), they were assigned as
+                            // 0/false/light by the constructor and are left unchanged by this method
+                        }
+                    }
+                }
+                assert(i == data.length * 8);
+            };
+            // XORs the codeword modules in this QR Code with the given mask pattern.
+            // The function modules must be marked and the codeword bits must be drawn
+            // before masking. Due to the arithmetic of XOR, calling applyMask() with
+            // the same mask value a second time will undo the mask. A final well-formed
+            // QR Code needs exactly one (not zero, two, etc.) mask applied.
+            QrCode.prototype.applyMask = function (mask) {
+                if (mask < 0 || mask > 7)
+                    throw new RangeError("Mask value out of range");
+                for (var y = 0; y < this.size; y++) {
+                    for (var x = 0; x < this.size; x++) {
+                        var invert = void 0;
+                        switch (mask) {
+                            case 0:
+                                invert = (x + y) % 2 == 0;
+                                break;
+                            case 1:
+                                invert = y % 2 == 0;
+                                break;
+                            case 2:
+                                invert = x % 3 == 0;
+                                break;
+                            case 3:
+                                invert = (x + y) % 3 == 0;
+                                break;
+                            case 4:
+                                invert = (Math.floor(x / 3) + Math.floor(y / 2)) % 2 == 0;
+                                break;
+                            case 5:
+                                invert = x * y % 2 + x * y % 3 == 0;
+                                break;
+                            case 6:
+                                invert = (x * y % 2 + x * y % 3) % 2 == 0;
+                                break;
+                            case 7:
+                                invert = ((x + y) % 2 + x * y % 3) % 2 == 0;
+                                break;
+                            default: throw new Error("Unreachable");
+                        }
+                        if (!this.isFunction[y][x] && invert)
+                            this.modules[y][x] = !this.modules[y][x];
+                    }
+                }
+            };
+            // Calculates and returns the penalty score based on state of this QR Code's current modules.
+            // This is used by the automatic mask choice algorithm to find the mask pattern that yields the lowest score.
+            QrCode.prototype.getPenaltyScore = function () {
+                var result = 0;
+                // Adjacent modules in row having same color, and finder-like patterns
+                for (var y = 0; y < this.size; y++) {
+                    var runColor = false;
+                    var runX = 0;
+                    var runHistory = [0, 0, 0, 0, 0, 0, 0];
+                    for (var x = 0; x < this.size; x++) {
+                        if (this.modules[y][x] == runColor) {
+                            runX++;
+                            if (runX == 5)
+                                result += QrCode.PENALTY_N1;
+                            else if (runX > 5)
+                                result++;
+                        }
+                        else {
+                            this.finderPenaltyAddHistory(runX, runHistory);
+                            if (!runColor)
+                                result += this.finderPenaltyCountPatterns(runHistory) * QrCode.PENALTY_N3;
+                            runColor = this.modules[y][x];
+                            runX = 1;
+                        }
+                    }
+                    result += this.finderPenaltyTerminateAndCount(runColor, runX, runHistory) * QrCode.PENALTY_N3;
+                }
+                // Adjacent modules in column having same color, and finder-like patterns
+                for (var x = 0; x < this.size; x++) {
+                    var runColor = false;
+                    var runY = 0;
+                    var runHistory = [0, 0, 0, 0, 0, 0, 0];
+                    for (var y = 0; y < this.size; y++) {
+                        if (this.modules[y][x] == runColor) {
+                            runY++;
+                            if (runY == 5)
+                                result += QrCode.PENALTY_N1;
+                            else if (runY > 5)
+                                result++;
+                        }
+                        else {
+                            this.finderPenaltyAddHistory(runY, runHistory);
+                            if (!runColor)
+                                result += this.finderPenaltyCountPatterns(runHistory) * QrCode.PENALTY_N3;
+                            runColor = this.modules[y][x];
+                            runY = 1;
+                        }
+                    }
+                    result += this.finderPenaltyTerminateAndCount(runColor, runY, runHistory) * QrCode.PENALTY_N3;
+                }
+                // 2*2 blocks of modules having same color
+                for (var y = 0; y < this.size - 1; y++) {
+                    for (var x = 0; x < this.size - 1; x++) {
+                        var color = this.modules[y][x];
+                        if (color == this.modules[y][x + 1] &&
+                            color == this.modules[y + 1][x] &&
+                            color == this.modules[y + 1][x + 1])
+                            result += QrCode.PENALTY_N2;
+                    }
+                }
+                // Balance of dark and light modules
+                var dark = 0;
+                for (var _i = 0, _a = this.modules; _i < _a.length; _i++) {
+                    var row = _a[_i];
+                    dark = row.reduce(function (sum, color) { return sum + (color ? 1 : 0); }, dark);
+                }
+                var total = this.size * this.size; // Note that size is odd, so dark/total != 1/2
+                // Compute the smallest integer k >= 0 such that (45-5k)% <= dark/total <= (55+5k)%
+                var k = Math.ceil(Math.abs(dark * 20 - total * 10) / total) - 1;
+                assert(0 <= k && k <= 9);
+                result += k * QrCode.PENALTY_N4;
+                assert(0 <= result && result <= 2568888); // Non-tight upper bound based on default values of PENALTY_N1, ..., N4
+                return result;
+            };
+            /*-- Private helper functions --*/
+            // Returns an ascending list of positions of alignment patterns for this version number.
+            // Each position is in the range [0,177), and are used on both the x and y axes.
+            // This could be implemented as lookup table of 40 variable-length lists of integers.
+            QrCode.prototype.getAlignmentPatternPositions = function () {
+                if (this.version == 1)
+                    return [];
+                else {
+                    var numAlign = Math.floor(this.version / 7) + 2;
+                    var step = (this.version == 32) ? 26 :
+                        Math.ceil((this.version * 4 + 4) / (numAlign * 2 - 2)) * 2;
+                    var result = [6];
+                    for (var pos = this.size - 7; result.length < numAlign; pos -= step)
+                        result.splice(1, 0, pos);
+                    return result;
+                }
+            };
+            // Returns the number of data bits that can be stored in a QR Code of the given version number, after
+            // all function modules are excluded. This includes remainder bits, so it might not be a multiple of 8.
+            // The result is in the range [208, 29648]. This could be implemented as a 40-entry lookup table.
+            QrCode.getNumRawDataModules = function (ver) {
+                if (ver < QrCode.MIN_VERSION || ver > QrCode.MAX_VERSION)
+                    throw new RangeError("Version number out of range");
+                var result = (16 * ver + 128) * ver + 64;
+                if (ver >= 2) {
+                    var numAlign = Math.floor(ver / 7) + 2;
+                    result -= (25 * numAlign - 10) * numAlign - 55;
+                    if (ver >= 7)
+                        result -= 36;
+                }
+                assert(208 <= result && result <= 29648);
+                return result;
+            };
+            // Returns the number of 8-bit data (i.e. not error correction) codewords contained in any
+            // QR Code of the given version number and error correction level, with remainder bits discarded.
+            // This stateless pure function could be implemented as a (40*4)-cell lookup table.
+            QrCode.getNumDataCodewords = function (ver, ecl) {
+                return Math.floor(QrCode.getNumRawDataModules(ver) / 8) -
+                    QrCode.ECC_CODEWORDS_PER_BLOCK[ecl.ordinal][ver] *
+                        QrCode.NUM_ERROR_CORRECTION_BLOCKS[ecl.ordinal][ver];
+            };
+            // Returns a Reed-Solomon ECC generator polynomial for the given degree. This could be
+            // implemented as a lookup table over all possible parameter values, instead of as an algorithm.
+            QrCode.reedSolomonComputeDivisor = function (degree) {
+                if (degree < 1 || degree > 255)
+                    throw new RangeError("Degree out of range");
+                // Polynomial coefficients are stored from highest to lowest power, excluding the leading term which is always 1.
+                // For example the polynomial x^3 + 255x^2 + 8x + 93 is stored as the uint8 array [255, 8, 93].
+                var result = [];
+                for (var i = 0; i < degree - 1; i++)
+                    result.push(0);
+                result.push(1); // Start off with the monomial x^0
+                // Compute the product polynomial (x - r^0) * (x - r^1) * (x - r^2) * ... * (x - r^{degree-1}),
+                // and drop the highest monomial term which is always 1x^degree.
+                // Note that r = 0x02, which is a generator element of this field GF(2^8/0x11D).
+                var root = 1;
+                for (var i = 0; i < degree; i++) {
+                    // Multiply the current product by (x - r^i)
+                    for (var j = 0; j < result.length; j++) {
+                        result[j] = QrCode.reedSolomonMultiply(result[j], root);
+                        if (j + 1 < result.length)
+                            result[j] ^= result[j + 1];
+                    }
+                    root = QrCode.reedSolomonMultiply(root, 0x02);
+                }
+                return result;
+            };
+            // Returns the Reed-Solomon error correction codeword for the given data and divisor polynomials.
+            QrCode.reedSolomonComputeRemainder = function (data, divisor) {
+                var result = divisor.map(function (_) { return 0; });
+                var _loop_2 = function (b) {
+                    var factor = b ^ result.shift();
+                    result.push(0);
+                    divisor.forEach(function (coef, i) {
+                        return result[i] ^= QrCode.reedSolomonMultiply(coef, factor);
+                    });
+                };
+                for (var _i = 0, data_1 = data; _i < data_1.length; _i++) {
+                    var b = data_1[_i];
+                    _loop_2(b);
+                }
+                return result;
+            };
+            // Returns the product of the two given field elements modulo GF(2^8/0x11D). The arguments and result
+            // are unsigned 8-bit integers. This could be implemented as a lookup table of 256*256 entries of uint8.
+            QrCode.reedSolomonMultiply = function (x, y) {
+                if (x >>> 8 != 0 || y >>> 8 != 0)
+                    throw new RangeError("Byte out of range");
+                // Russian peasant multiplication
+                var z = 0;
+                for (var i = 7; i >= 0; i--) {
+                    z = (z << 1) ^ ((z >>> 7) * 0x11D);
+                    z ^= ((y >>> i) & 1) * x;
+                }
+                assert(z >>> 8 == 0);
+                return z;
+            };
+            // Can only be called immediately after a light run is added, and
+            // returns either 0, 1, or 2. A helper function for getPenaltyScore().
+            QrCode.prototype.finderPenaltyCountPatterns = function (runHistory) {
+                var n = runHistory[1];
+                assert(n <= this.size * 3);
+                var core = n > 0 && runHistory[2] == n && runHistory[3] == n * 3 && runHistory[4] == n && runHistory[5] == n;
+                return (core && runHistory[0] >= n * 4 && runHistory[6] >= n ? 1 : 0)
+                    + (core && runHistory[6] >= n * 4 && runHistory[0] >= n ? 1 : 0);
+            };
+            // Must be called at the end of a line (row or column) of modules. A helper function for getPenaltyScore().
+            QrCode.prototype.finderPenaltyTerminateAndCount = function (currentRunColor, currentRunLength, runHistory) {
+                if (currentRunColor) { // Terminate dark run
+                    this.finderPenaltyAddHistory(currentRunLength, runHistory);
+                    currentRunLength = 0;
+                }
+                currentRunLength += this.size; // Add light border to final run
+                this.finderPenaltyAddHistory(currentRunLength, runHistory);
+                return this.finderPenaltyCountPatterns(runHistory);
+            };
+            // Pushes the given value to the front and drops the last value. A helper function for getPenaltyScore().
+            QrCode.prototype.finderPenaltyAddHistory = function (currentRunLength, runHistory) {
+                if (runHistory[0] == 0)
+                    currentRunLength += this.size; // Add light border to initial run
+                runHistory.pop();
+                runHistory.unshift(currentRunLength);
+            };
+            /*-- Constants and tables --*/
+            // The minimum version number supported in the QR Code Model 2 standard.
+            QrCode.MIN_VERSION = 1;
+            // The maximum version number supported in the QR Code Model 2 standard.
+            QrCode.MAX_VERSION = 40;
+            // For use in getPenaltyScore(), when evaluating which mask is best.
+            QrCode.PENALTY_N1 = 3;
+            QrCode.PENALTY_N2 = 3;
+            QrCode.PENALTY_N3 = 40;
+            QrCode.PENALTY_N4 = 10;
+            QrCode.ECC_CODEWORDS_PER_BLOCK = [
+                // Version: (note that index 0 is for padding, and is set to an illegal value)
+                //0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40    Error correction level
+                [-1, 7, 10, 15, 20, 26, 18, 20, 24, 30, 18, 20, 24, 26, 30, 22, 24, 28, 30, 28, 28, 28, 28, 30, 30, 26, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30],
+                [-1, 10, 16, 26, 18, 24, 16, 18, 22, 22, 26, 30, 22, 22, 24, 24, 28, 28, 26, 26, 26, 26, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28],
+                [-1, 13, 22, 18, 26, 18, 24, 18, 22, 20, 24, 28, 26, 24, 20, 30, 24, 28, 28, 26, 30, 28, 30, 30, 30, 30, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30],
+                [-1, 17, 28, 22, 16, 22, 28, 26, 26, 24, 28, 24, 28, 22, 24, 24, 30, 28, 28, 26, 28, 30, 24, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30], // High
+            ];
+            QrCode.NUM_ERROR_CORRECTION_BLOCKS = [
+                // Version: (note that index 0 is for padding, and is set to an illegal value)
+                //0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40    Error correction level
+                [-1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 4, 4, 4, 4, 4, 6, 6, 6, 6, 7, 8, 8, 9, 9, 10, 12, 12, 12, 13, 14, 15, 16, 17, 18, 19, 19, 20, 21, 22, 24, 25],
+                [-1, 1, 1, 1, 2, 2, 4, 4, 4, 5, 5, 5, 8, 9, 9, 10, 10, 11, 13, 14, 16, 17, 17, 18, 20, 21, 23, 25, 26, 28, 29, 31, 33, 35, 37, 38, 40, 43, 45, 47, 49],
+                [-1, 1, 1, 2, 2, 4, 4, 6, 6, 8, 8, 8, 10, 12, 16, 12, 17, 16, 18, 21, 20, 23, 23, 25, 27, 29, 34, 34, 35, 38, 40, 43, 45, 48, 51, 53, 56, 59, 62, 65, 68],
+                [-1, 1, 1, 2, 4, 4, 4, 5, 6, 8, 8, 11, 11, 16, 16, 18, 16, 19, 21, 25, 25, 25, 34, 30, 32, 35, 37, 40, 42, 45, 48, 51, 54, 57, 60, 63, 66, 70, 74, 77, 81], // High
+            ];
+            return QrCode;
+        }());
+        qrcodegen.QrCode = QrCode;
+        // Appends the given number of low-order bits of the given value
+        // to the given buffer. Requires 0 <= len <= 31 and 0 <= val < 2^len.
+        function appendBits(val, len, bb) {
+            if (len < 0 || len > 31 || val >>> len != 0)
+                throw new RangeError("Value out of range");
+            for (var i = len - 1; i >= 0; i--) // Append bit by bit
+                bb.push((val >>> i) & 1);
+        }
+        // Returns true iff the i'th bit of x is set to 1.
+        function getBit(x, i) {
+            return ((x >>> i) & 1) != 0;
+        }
+        // Throws an exception if the given condition is false.
+        function assert(cond) {
+            if (!cond)
+                throw new Error("Assertion error");
+        }
+        /*---- Data segment class ----*/
+        /*
+         * A segment of character/binary/control data in a QR Code symbol.
+         * Instances of this class are immutable.
+         * The mid-level way to create a segment is to take the payload data
+         * and call a static factory function such as QrSegment.makeNumeric().
+         * The low-level way to create a segment is to custom-make the bit buffer
+         * and call the QrSegment() constructor with appropriate values.
+         * This segment class imposes no length restrictions, but QR Codes have restrictions.
+         * Even in the most favorable conditions, a QR Code can only hold 7089 characters of data.
+         * Any segment longer than this is meaningless for the purpose of generating QR Codes.
+         */
+        var QrSegment = /** @class */ (function () {
+            /*-- Constructor (low level) and fields --*/
+            // Creates a new QR Code segment with the given attributes and data.
+            // The character count (numChars) must agree with the mode and the bit buffer length,
+            // but the constraint isn't checked. The given bit buffer is cloned and stored.
+            function QrSegment(
+            // The mode indicator of this segment.
+            mode, 
+            // The length of this segment's unencoded data. Measured in characters for
+            // numeric/alphanumeric/kanji mode, bytes for byte mode, and 0 for ECI mode.
+            // Always zero or positive. Not the same as the data's bit length.
+            numChars, 
+            // The data bits of this segment. Accessed through getData().
+            bitData) {
+                this.mode = mode;
+                this.numChars = numChars;
+                this.bitData = bitData;
+                if (numChars < 0)
+                    throw new RangeError("Invalid argument");
+                this.bitData = bitData.slice(); // Make defensive copy
+            }
+            /*-- Static factory functions (mid level) --*/
+            // Returns a segment representing the given binary data encoded in
+            // byte mode. All input byte arrays are acceptable. Any text string
+            // can be converted to UTF-8 bytes and encoded as a byte mode segment.
+            QrSegment.makeBytes = function (data) {
+                var bb = [];
+                for (var _i = 0, data_2 = data; _i < data_2.length; _i++) {
+                    var b = data_2[_i];
+                    appendBits(b, 8, bb);
+                }
+                return new QrSegment(QrSegment.Mode.BYTE, data.length, bb);
+            };
+            // Returns a segment representing the given string of decimal digits encoded in numeric mode.
+            QrSegment.makeNumeric = function (digits) {
+                if (!QrSegment.isNumeric(digits))
+                    throw new RangeError("String contains non-numeric characters");
+                var bb = [];
+                for (var i = 0; i < digits.length;) { // Consume up to 3 digits per iteration
+                    var n = Math.min(digits.length - i, 3);
+                    appendBits(parseInt(digits.substring(i, i + n), 10), n * 3 + 1, bb);
+                    i += n;
+                }
+                return new QrSegment(QrSegment.Mode.NUMERIC, digits.length, bb);
+            };
+            // Returns a segment representing the given text string encoded in alphanumeric mode.
+            // The characters allowed are: 0 to 9, A to Z (uppercase only), space,
+            // dollar, percent, asterisk, plus, hyphen, period, slash, colon.
+            QrSegment.makeAlphanumeric = function (text) {
+                if (!QrSegment.isAlphanumeric(text))
+                    throw new RangeError("String contains unencodable characters in alphanumeric mode");
+                var bb = [];
+                var i;
+                for (i = 0; i + 2 <= text.length; i += 2) { // Process groups of 2
+                    var temp = QrSegment.ALPHANUMERIC_CHARSET.indexOf(text.charAt(i)) * 45;
+                    temp += QrSegment.ALPHANUMERIC_CHARSET.indexOf(text.charAt(i + 1));
+                    appendBits(temp, 11, bb);
+                }
+                if (i < text.length) // 1 character remaining
+                    appendBits(QrSegment.ALPHANUMERIC_CHARSET.indexOf(text.charAt(i)), 6, bb);
+                return new QrSegment(QrSegment.Mode.ALPHANUMERIC, text.length, bb);
+            };
+            // Returns a new mutable list of zero or more segments to represent the given Unicode text string.
+            // The result may use various segment modes and switch modes to optimize the length of the bit stream.
+            QrSegment.makeSegments = function (text) {
+                // Select the most efficient segment encoding automatically
+                if (text == "")
+                    return [];
+                else if (QrSegment.isNumeric(text))
+                    return [QrSegment.makeNumeric(text)];
+                else if (QrSegment.isAlphanumeric(text))
+                    return [QrSegment.makeAlphanumeric(text)];
+                else
+                    return [QrSegment.makeBytes(QrSegment.toUtf8ByteArray(text))];
+            };
+            // Returns a segment representing an Extended Channel Interpretation
+            // (ECI) designator with the given assignment value.
+            QrSegment.makeEci = function (assignVal) {
+                var bb = [];
+                if (assignVal < 0)
+                    throw new RangeError("ECI assignment value out of range");
+                else if (assignVal < (1 << 7))
+                    appendBits(assignVal, 8, bb);
+                else if (assignVal < (1 << 14)) {
+                    appendBits(2, 2, bb);
+                    appendBits(assignVal, 14, bb);
+                }
+                else if (assignVal < 1000000) {
+                    appendBits(6, 3, bb);
+                    appendBits(assignVal, 21, bb);
+                }
+                else
+                    throw new RangeError("ECI assignment value out of range");
+                return new QrSegment(QrSegment.Mode.ECI, 0, bb);
+            };
+            // Tests whether the given string can be encoded as a segment in numeric mode.
+            // A string is encodable iff each character is in the range 0 to 9.
+            QrSegment.isNumeric = function (text) {
+                return QrSegment.NUMERIC_REGEX.test(text);
+            };
+            // Tests whether the given string can be encoded as a segment in alphanumeric mode.
+            // A string is encodable iff each character is in the following set: 0 to 9, A to Z
+            // (uppercase only), space, dollar, percent, asterisk, plus, hyphen, period, slash, colon.
+            QrSegment.isAlphanumeric = function (text) {
+                return QrSegment.ALPHANUMERIC_REGEX.test(text);
+            };
+            /*-- Methods --*/
+            // Returns a new copy of the data bits of this segment.
+            QrSegment.prototype.getData = function () {
+                return this.bitData.slice(); // Make defensive copy
+            };
+            // (Package-private) Calculates and returns the number of bits needed to encode the given segments at
+            // the given version. The result is infinity if a segment has too many characters to fit its length field.
+            QrSegment.getTotalBits = function (segs, version) {
+                var result = 0;
+                for (var _i = 0, segs_2 = segs; _i < segs_2.length; _i++) {
+                    var seg = segs_2[_i];
+                    var ccbits = seg.mode.numCharCountBits(version);
+                    if (seg.numChars >= (1 << ccbits))
+                        return Infinity; // The segment's length doesn't fit the field's bit width
+                    result += 4 + ccbits + seg.bitData.length;
+                }
+                return result;
+            };
+            // Returns a new array of bytes representing the given string encoded in UTF-8.
+            QrSegment.toUtf8ByteArray = function (str) {
+                str = encodeURI(str);
+                var result = [];
+                for (var i = 0; i < str.length; i++) {
+                    if (str.charAt(i) != "%")
+                        result.push(str.charCodeAt(i));
+                    else {
+                        result.push(parseInt(str.substring(i + 1, i + 3), 16));
+                        i += 2;
+                    }
+                }
+                return result;
+            };
+            /*-- Constants --*/
+            // Describes precisely all strings that are encodable in numeric mode.
+            QrSegment.NUMERIC_REGEX = /^[0-9]*$/;
+            // Describes precisely all strings that are encodable in alphanumeric mode.
+            QrSegment.ALPHANUMERIC_REGEX = /^[A-Z0-9 $%*+.\/:-]*$/;
+            // The set of all legal characters in alphanumeric mode,
+            // where each character value maps to the index in the string.
+            QrSegment.ALPHANUMERIC_CHARSET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:";
+            return QrSegment;
+        }());
+        qrcodegen.QrSegment = QrSegment;
+    })(qrcodegen || (qrcodegen = {}));
+    /*---- Public helper enumeration ----*/
+    (function (qrcodegen) {
+        (function (QrCode) {
+            /*
+             * The error correction level in a QR Code symbol. Immutable.
+             */
+            var Ecc = /** @class */ (function () {
+                /*-- Constructor and fields --*/
+                function Ecc(
+                // In the range 0 to 3 (unsigned 2-bit integer).
+                ordinal, 
+                // (Package-private) In the range 0 to 3 (unsigned 2-bit integer).
+                formatBits) {
+                    this.ordinal = ordinal;
+                    this.formatBits = formatBits;
+                }
+                /*-- Constants --*/
+                Ecc.LOW = new Ecc(0, 1); // The QR Code can tolerate about  7% erroneous codewords
+                Ecc.MEDIUM = new Ecc(1, 0); // The QR Code can tolerate about 15% erroneous codewords
+                Ecc.QUARTILE = new Ecc(2, 3); // The QR Code can tolerate about 25% erroneous codewords
+                Ecc.HIGH = new Ecc(3, 2); // The QR Code can tolerate about 30% erroneous codewords
+                return Ecc;
+            }());
+            QrCode.Ecc = Ecc;
+        })(qrcodegen.QrCode || (qrcodegen.QrCode = {}));
+    })(qrcodegen || (qrcodegen = {}));
+    /*---- Public helper enumeration ----*/
+    (function (qrcodegen) {
+        (function (QrSegment) {
+            /*
+             * Describes how a segment's data bits are interpreted. Immutable.
+             */
+            var Mode = /** @class */ (function () {
+                /*-- Constructor and fields --*/
+                function Mode(
+                // The mode indicator bits, which is a uint4 value (range 0 to 15).
+                modeBits, 
+                // Number of character count bits for three different version ranges.
+                numBitsCharCount) {
+                    this.modeBits = modeBits;
+                    this.numBitsCharCount = numBitsCharCount;
+                }
+                /*-- Method --*/
+                // (Package-private) Returns the bit width of the character count field for a segment in
+                // this mode in a QR Code at the given version number. The result is in the range [0, 16].
+                Mode.prototype.numCharCountBits = function (ver) {
+                    return this.numBitsCharCount[Math.floor((ver + 7) / 17)];
+                };
+                /*-- Constants --*/
+                Mode.NUMERIC = new Mode(0x1, [10, 12, 14]);
+                Mode.ALPHANUMERIC = new Mode(0x2, [9, 11, 13]);
+                Mode.BYTE = new Mode(0x4, [8, 16, 16]);
+                Mode.KANJI = new Mode(0x8, [8, 10, 12]);
+                Mode.ECI = new Mode(0x7, [0, 0, 0]);
+                return Mode;
+            }());
+            QrSegment.Mode = Mode;
+        })(qrcodegen.QrSegment || (qrcodegen.QrSegment = {}));
+    })(qrcodegen || (qrcodegen = {}));
+    var QR = qrcodegen;
+
+    var defaultErrorCorrectLevel = 'H';
+    var ErrorCorrectLevelMap = {
+        L: QR.QrCode.Ecc.LOW,
+        M: QR.QrCode.Ecc.MEDIUM,
+        Q: QR.QrCode.Ecc.QUARTILE,
+        H: QR.QrCode.Ecc.HIGH,
     };
-    	
-    for (var i = 0; i < 8; i++) {
-    	QRMath.EXP_TABLE[i] = 1 << i;
-    }
-    for (var i = 8; i < 256; i++) {
-    	QRMath.EXP_TABLE[i] = QRMath.EXP_TABLE[i - 4]
-    		^ QRMath.EXP_TABLE[i - 5]
-    		^ QRMath.EXP_TABLE[i - 6]
-    		^ QRMath.EXP_TABLE[i - 8];
+    // Thanks the `qrcode.react`
+    var SUPPORTS_PATH2D = (function () {
+        try {
+            new Path2D().addPath(new Path2D());
+        }
+        catch (e) {
+            return false;
+        }
+        return true;
+    })();
+    function validErrorCorrectLevel(level) {
+        return level in ErrorCorrectLevelMap;
     }
-    for (var i = 0; i < 255; i++) {
-    	QRMath.LOG_TABLE[QRMath.EXP_TABLE[i] ] = i;
+    function generatePath(modules, margin) {
+        if (margin === void 0) { margin = 0; }
+        var ops = [];
+        modules.forEach(function (row, y) {
+            var start = null;
+            row.forEach(function (cell, x) {
+                if (!cell && start !== null) {
+                    // M0 0h7v1H0z injects the space with the move and drops the comma,
+                    // saving a char per operation
+                    ops.push("M".concat(start + margin, " ").concat(y + margin, "h").concat(x - start, "v1H").concat(start + margin, "z"));
+                    start = null;
+                    return;
+                }
+                // end of row, clean up or skip
+                if (x === row.length - 1) {
+                    if (!cell) {
+                        // We would have closed the op above already so this can only mean
+                        // 2+ light modules in a row.
+                        return;
+                    }
+                    if (start === null) {
+                        // Just a single dark module.
+                        ops.push("M".concat(x + margin, ",").concat(y + margin, " h1v1H").concat(x + margin, "z"));
+                    }
+                    else {
+                        // Otherwise finish the current line.
+                        ops.push("M".concat(start + margin, ",").concat(y + margin, " h").concat(x + 1 - start, "v1H").concat(start + margin, "z"));
+                    }
+                    return;
+                }
+                if (cell && start === null) {
+                    start = x;
+                }
+            });
+        });
+        return ops.join('');
     }
-
-    var math$2 = QRMath;
-
-    var math$1 = math$2;
-
-    function QRPolynomial(num, shift) {
-
-    	if (num.length == undefined) {
-    		throw new Error(num.length + "/" + shift);
-    	}
-
-    	var offset = 0;
-
-    	while (offset < num.length && num[offset] == 0) {
-    		offset++;
-    	}
-
-    	this.num = new Array(num.length - offset + shift);
-    	for (var i = 0; i < num.length - offset; i++) {
-    		this.num[i] = num[i + offset];
-    	}
-    }
-
-    QRPolynomial.prototype = {
-
-    	get : function(index) {
-    		return this.num[index];
-    	},
-    	
-    	getLength : function() {
-    		return this.num.length;
-    	},
-    	
-    	multiply : function(e) {
-    	
-    		var num = new Array(this.getLength() + e.getLength() - 1);
-    	
-    		for (var i = 0; i < this.getLength(); i++) {
-    			for (var j = 0; j < e.getLength(); j++) {
-    				num[i + j] ^= math$1.gexp(math$1.glog(this.get(i) ) + math$1.glog(e.get(j) ) );
-    			}
-    		}
-    	
-    		return new QRPolynomial(num, 0);
-    	},
-    	
-    	mod : function(e) {
-    	
-    		if (this.getLength() - e.getLength() < 0) {
-    			return this;
-    		}
-    	
-    		var ratio = math$1.glog(this.get(0) ) - math$1.glog(e.get(0) );
-    	
-    		var num = new Array(this.getLength() );
-    		
-    		for (var i = 0; i < this.getLength(); i++) {
-    			num[i] = this.get(i);
-    		}
-    		
-    		for (var i = 0; i < e.getLength(); i++) {
-    			num[i] ^= math$1.gexp(math$1.glog(e.get(i) ) + ratio);
-    		}
-    	
-    		// recursive call
-    		return new QRPolynomial(num, 0).mod(e);
-    	}
-    };
-
-    var Polynomial$2 = QRPolynomial;
-
-    var Mode = mode$1;
-    var Polynomial$1 = Polynomial$2;
-    var math = math$2;
-
-    var QRMaskPattern = {
-    	PATTERN000 : 0,
-    	PATTERN001 : 1,
-    	PATTERN010 : 2,
-    	PATTERN011 : 3,
-    	PATTERN100 : 4,
-    	PATTERN101 : 5,
-    	PATTERN110 : 6,
-    	PATTERN111 : 7
-    };
-
-    var QRUtil = {
-
-        PATTERN_POSITION_TABLE : [
-    	    [],
-    	    [6, 18],
-    	    [6, 22],
-    	    [6, 26],
-    	    [6, 30],
-    	    [6, 34],
-    	    [6, 22, 38],
-    	    [6, 24, 42],
-    	    [6, 26, 46],
-    	    [6, 28, 50],
-    	    [6, 30, 54],		
-    	    [6, 32, 58],
-    	    [6, 34, 62],
-    	    [6, 26, 46, 66],
-    	    [6, 26, 48, 70],
-    	    [6, 26, 50, 74],
-    	    [6, 30, 54, 78],
-    	    [6, 30, 56, 82],
-    	    [6, 30, 58, 86],
-    	    [6, 34, 62, 90],
-    	    [6, 28, 50, 72, 94],
-    	    [6, 26, 50, 74, 98],
-    	    [6, 30, 54, 78, 102],
-    	    [6, 28, 54, 80, 106],
-    	    [6, 32, 58, 84, 110],
-    	    [6, 30, 58, 86, 114],
-    	    [6, 34, 62, 90, 118],
-    	    [6, 26, 50, 74, 98, 122],
-    	    [6, 30, 54, 78, 102, 126],
-    	    [6, 26, 52, 78, 104, 130],
-    	    [6, 30, 56, 82, 108, 134],
-    	    [6, 34, 60, 86, 112, 138],
-    	    [6, 30, 58, 86, 114, 142],
-    	    [6, 34, 62, 90, 118, 146],
-    	    [6, 30, 54, 78, 102, 126, 150],
-    	    [6, 24, 50, 76, 102, 128, 154],
-    	    [6, 28, 54, 80, 106, 132, 158],
-    	    [6, 32, 58, 84, 110, 136, 162],
-    	    [6, 26, 54, 82, 110, 138, 166],
-    	    [6, 30, 58, 86, 114, 142, 170]
-        ],
-
-        G15 : (1 << 10) | (1 << 8) | (1 << 5) | (1 << 4) | (1 << 2) | (1 << 1) | (1 << 0),
-        G18 : (1 << 12) | (1 << 11) | (1 << 10) | (1 << 9) | (1 << 8) | (1 << 5) | (1 << 2) | (1 << 0),
-        G15_MASK : (1 << 14) | (1 << 12) | (1 << 10)	| (1 << 4) | (1 << 1),
-
-        getBCHTypeInfo : function(data) {
-    	    var d = data << 10;
-    	    while (QRUtil.getBCHDigit(d) - QRUtil.getBCHDigit(QRUtil.G15) >= 0) {
-    		    d ^= (QRUtil.G15 << (QRUtil.getBCHDigit(d) - QRUtil.getBCHDigit(QRUtil.G15) ) ); 	
-    	    }
-    	    return ( (data << 10) | d) ^ QRUtil.G15_MASK;
+    var QRCodeProps = {
+        value: {
+            type: String,
+            required: true,
+            default: '',
         },
-
-        getBCHTypeNumber : function(data) {
-    	    var d = data << 12;
-    	    while (QRUtil.getBCHDigit(d) - QRUtil.getBCHDigit(QRUtil.G18) >= 0) {
-    		    d ^= (QRUtil.G18 << (QRUtil.getBCHDigit(d) - QRUtil.getBCHDigit(QRUtil.G18) ) ); 	
-    	    }
-    	    return (data << 12) | d;
-        },
-
-        getBCHDigit : function(data) {
-
-    	    var digit = 0;
-
-    	    while (data != 0) {
-    		    digit++;
-    		    data >>>= 1;
-    	    }
-
-    	    return digit;
+        size: {
+            type: Number,
+            default: 100,
         },
-
-        getPatternPosition : function(typeNumber) {
-    	    return QRUtil.PATTERN_POSITION_TABLE[typeNumber - 1];
+        level: {
+            type: String,
+            default: defaultErrorCorrectLevel,
+            validator: function (l) { return validErrorCorrectLevel(l); },
         },
-
-        getMask : function(maskPattern, i, j) {
-    	    
-    	    switch (maskPattern) {
-    		    
-    	    case QRMaskPattern.PATTERN000 : return (i + j) % 2 == 0;
-    	    case QRMaskPattern.PATTERN001 : return i % 2 == 0;
-    	    case QRMaskPattern.PATTERN010 : return j % 3 == 0;
-    	    case QRMaskPattern.PATTERN011 : return (i + j) % 3 == 0;
-    	    case QRMaskPattern.PATTERN100 : return (Math.floor(i / 2) + Math.floor(j / 3) ) % 2 == 0;
-    	    case QRMaskPattern.PATTERN101 : return (i * j) % 2 + (i * j) % 3 == 0;
-    	    case QRMaskPattern.PATTERN110 : return ( (i * j) % 2 + (i * j) % 3) % 2 == 0;
-    	    case QRMaskPattern.PATTERN111 : return ( (i * j) % 3 + (i + j) % 2) % 2 == 0;
-
-    	    default :
-    		    throw new Error("bad maskPattern:" + maskPattern);
-    	    }
+        background: {
+            type: String,
+            default: '#fff',
         },
-
-        getErrorCorrectPolynomial : function(errorCorrectLength) {
-
-    	    var a = new Polynomial$1([1], 0);
-
-    	    for (var i = 0; i < errorCorrectLength; i++) {
-    		    a = a.multiply(new Polynomial$1([1, math.gexp(i)], 0) );
-    	    }
-
-    	    return a;
+        foreground: {
+            type: String,
+            default: '#000',
         },
-
-        getLengthInBits : function(mode, type) {
-
-    	    if (1 <= type && type < 10) {
-
-    		    // 1 - 9
-
-    		    switch(mode) {
-    		    case Mode.MODE_NUMBER 	: return 10;
-    		    case Mode.MODE_ALPHA_NUM 	: return 9;
-    		    case Mode.MODE_8BIT_BYTE	: return 8;
-    		    case Mode.MODE_KANJI  	: return 8;
-    		    default :
-    			    throw new Error("mode:" + mode);
-    		    }
-
-    	    } else if (type < 27) {
-
-    		    // 10 - 26
-
-    		    switch(mode) {
-    		    case Mode.MODE_NUMBER 	: return 12;
-    		    case Mode.MODE_ALPHA_NUM 	: return 11;
-    		    case Mode.MODE_8BIT_BYTE	: return 16;
-    		    case Mode.MODE_KANJI  	: return 10;
-    		    default :
-    			    throw new Error("mode:" + mode);
-    		    }
-
-    	    } else if (type < 41) {
-
-    		    // 27 - 40
-
-    		    switch(mode) {
-    		    case Mode.MODE_NUMBER 	: return 14;
-    		    case Mode.MODE_ALPHA_NUM	: return 13;
-    		    case Mode.MODE_8BIT_BYTE	: return 16;
-    		    case Mode.MODE_KANJI  	: return 12;
-    		    default :
-    			    throw new Error("mode:" + mode);
-    		    }
-
-    	    } else {
-    		    throw new Error("type:" + type);
-    	    }
+        margin: {
+            type: Number,
+            required: false,
+            default: 0,
         },
-
-        getLostPoint : function(qrCode) {
-    	    
-    	    var moduleCount = qrCode.getModuleCount();
-    	    
-    	    var lostPoint = 0;
-    	    
-    	    // LEVEL1
-    	    
-    	    for (var row = 0; row < moduleCount; row++) {
-
-    		    for (var col = 0; col < moduleCount; col++) {
-
-    			    var sameCount = 0;
-    			    var dark = qrCode.isDark(row, col);
-
-    				for (var r = -1; r <= 1; r++) {
-
-    				    if (row + r < 0 || moduleCount <= row + r) {
-    					    continue;
-    				    }
-
-    				    for (var c = -1; c <= 1; c++) {
-
-    					    if (col + c < 0 || moduleCount <= col + c) {
-    						    continue;
-    					    }
-
-    					    if (r == 0 && c == 0) {
-    						    continue;
-    					    }
-
-    					    if (dark == qrCode.isDark(row + r, col + c) ) {
-    						    sameCount++;
-    					    }
-    				    }
-    			    }
-
-    			    if (sameCount > 5) {
-    				    lostPoint += (3 + sameCount - 5);
-    			    }
-    		    }
-    	    }
-
-    	    // LEVEL2
-
-    	    for (var row = 0; row < moduleCount - 1; row++) {
-    		    for (var col = 0; col < moduleCount - 1; col++) {
-    			    var count = 0;
-    			    if (qrCode.isDark(row,     col    ) ) count++;
-    			    if (qrCode.isDark(row + 1, col    ) ) count++;
-    			    if (qrCode.isDark(row,     col + 1) ) count++;
-    			    if (qrCode.isDark(row + 1, col + 1) ) count++;
-    			    if (count == 0 || count == 4) {
-    				    lostPoint += 3;
-    			    }
-    		    }
-    	    }
-
-    	    // LEVEL3
-
-    	    for (var row = 0; row < moduleCount; row++) {
-    		    for (var col = 0; col < moduleCount - 6; col++) {
-    			    if (qrCode.isDark(row, col)
-    					    && !qrCode.isDark(row, col + 1)
-    					    &&  qrCode.isDark(row, col + 2)
-    					    &&  qrCode.isDark(row, col + 3)
-    					    &&  qrCode.isDark(row, col + 4)
-    					    && !qrCode.isDark(row, col + 5)
-    					    &&  qrCode.isDark(row, col + 6) ) {
-    				    lostPoint += 40;
-    			    }
-    		    }
-    	    }
-
-    	    for (var col = 0; col < moduleCount; col++) {
-    		    for (var row = 0; row < moduleCount - 6; row++) {
-    			    if (qrCode.isDark(row, col)
-    					    && !qrCode.isDark(row + 1, col)
-    					    &&  qrCode.isDark(row + 2, col)
-    					    &&  qrCode.isDark(row + 3, col)
-    					    &&  qrCode.isDark(row + 4, col)
-    					    && !qrCode.isDark(row + 5, col)
-    					    &&  qrCode.isDark(row + 6, col) ) {
-    				    lostPoint += 40;
-    			    }
-    		    }
-    	    }
-
-    	    // LEVEL4
-    	    
-    	    var darkCount = 0;
-
-    	    for (var col = 0; col < moduleCount; col++) {
-    		    for (var row = 0; row < moduleCount; row++) {
-    			    if (qrCode.isDark(row, col) ) {
-    				    darkCount++;
-    			    }
-    		    }
-    	    }
-    	    
-    	    var ratio = Math.abs(100 * darkCount / moduleCount / moduleCount - 50) / 5;
-    	    lostPoint += ratio * 10;
-
-    	    return lostPoint;		
-        }
-    };
-
-    var util$1 = QRUtil;
-
-    var BitByte = _8BitByte;
-    var RSBlock = RSBlock$1;
-    var BitBuffer = BitBuffer$1;
-    var util = util$1;
-    var Polynomial = Polynomial$2;
-
-    function QRCode$1(typeNumber, errorCorrectLevel) {
-    	this.typeNumber = typeNumber;
-    	this.errorCorrectLevel = errorCorrectLevel;
-    	this.modules = null;
-    	this.moduleCount = 0;
-    	this.dataCache = null;
-    	this.dataList = [];
-    }
-
-    // for client side minification
-    var proto = QRCode$1.prototype;
-
-    proto.addData = function(data) {
-    	var newData = new BitByte(data);
-    	this.dataList.push(newData);
-    	this.dataCache = null;
-    };
-
-    proto.isDark = function(row, col) {
-    	if (row < 0 || this.moduleCount <= row || col < 0 || this.moduleCount <= col) {
-    		throw new Error(row + "," + col);
-    	}
-    	return this.modules[row][col];
-    };
-
-    proto.getModuleCount = function() {
-    	return this.moduleCount;
-    };
-
-    proto.make = function() {
-    	// Calculate automatically typeNumber if provided is < 1
-    	if (this.typeNumber < 1 ){
-    		var typeNumber = 1;
-    		for (typeNumber = 1; typeNumber < 40; typeNumber++) {
-    			var rsBlocks = RSBlock.getRSBlocks(typeNumber, this.errorCorrectLevel);
-
-    			var buffer = new BitBuffer();
-    			var totalDataCount = 0;
-    			for (var i = 0; i < rsBlocks.length; i++) {
-    				totalDataCount += rsBlocks[i].dataCount;
-    			}
-
-    			for (var i = 0; i < this.dataList.length; i++) {
-    				var data = this.dataList[i];
-    				buffer.put(data.mode, 4);
-    				buffer.put(data.getLength(), util.getLengthInBits(data.mode, typeNumber) );
-    				data.write(buffer);
-    			}
-    			if (buffer.getLengthInBits() <= totalDataCount * 8)
-    				break;
-    		}
-    		this.typeNumber = typeNumber;
-    	}
-    	this.makeImpl(false, this.getBestMaskPattern() );
     };
-
-    proto.makeImpl = function(test, maskPattern) {
-    	
-    	this.moduleCount = this.typeNumber * 4 + 17;
-    	this.modules = new Array(this.moduleCount);
-    	
-    	for (var row = 0; row < this.moduleCount; row++) {
-    		
-    		this.modules[row] = new Array(this.moduleCount);
-    		
-    		for (var col = 0; col < this.moduleCount; col++) {
-    			this.modules[row][col] = null;//(col + row) % 3;
-    		}
-    	}
-
-    	this.setupPositionProbePattern(0, 0);
-    	this.setupPositionProbePattern(this.moduleCount - 7, 0);
-    	this.setupPositionProbePattern(0, this.moduleCount - 7);
-    	this.setupPositionAdjustPattern();
-    	this.setupTimingPattern();
-    	this.setupTypeInfo(test, maskPattern);
-    	
-    	if (this.typeNumber >= 7) {
-    		this.setupTypeNumber(test);
-    	}
-
-    	if (this.dataCache == null) {
-    		this.dataCache = QRCode$1.createData(this.typeNumber, this.errorCorrectLevel, this.dataList);
-    	}
-
-    	this.mapData(this.dataCache, maskPattern);
-    };
-
-    proto.setupPositionProbePattern = function(row, col)  {
-    	
-    	for (var r = -1; r <= 7; r++) {
-    		
-    		if (row + r <= -1 || this.moduleCount <= row + r) continue;
-    		
-    		for (var c = -1; c <= 7; c++) {
-    			
-    			if (col + c <= -1 || this.moduleCount <= col + c) continue;
-    			
-    			if ( (0 <= r && r <= 6 && (c == 0 || c == 6) )
-    					|| (0 <= c && c <= 6 && (r == 0 || r == 6) )
-    					|| (2 <= r && r <= 4 && 2 <= c && c <= 4) ) {
-    				this.modules[row + r][col + c] = true;
-    			} else {
-    				this.modules[row + r][col + c] = false;
-    			}
-    		}		
-    	}		
-    };
-
-    proto.getBestMaskPattern = function() {
-
-    	var minLostPoint = 0;
-    	var pattern = 0;
-
-    	for (var i = 0; i < 8; i++) {
-    		
-    		this.makeImpl(true, i);
-
-    		var lostPoint = util.getLostPoint(this);
-
-    		if (i == 0 || minLostPoint >  lostPoint) {
-    			minLostPoint = lostPoint;
-    			pattern = i;
-    		}
-    	}
-
-    	return pattern;
-    };
-
-    proto.createMovieClip = function(target_mc, instance_name, depth) {
-
-    	var qr_mc = target_mc.createEmptyMovieClip(instance_name, depth);
-    	var cs = 1;
-
-    	this.make();
-
-    	for (var row = 0; row < this.modules.length; row++) {
-    		
-    		var y = row * cs;
-    		
-    		for (var col = 0; col < this.modules[row].length; col++) {
-
-    			var x = col * cs;
-    			var dark = this.modules[row][col];
-    		
-    			if (dark) {
-    				qr_mc.beginFill(0, 100);
-    				qr_mc.moveTo(x, y);
-    				qr_mc.lineTo(x + cs, y);
-    				qr_mc.lineTo(x + cs, y + cs);
-    				qr_mc.lineTo(x, y + cs);
-    				qr_mc.endFill();
-    			}
-    		}
-    	}
-    	
-    	return qr_mc;
-    };
-
-    proto.setupTimingPattern = function() {
-    	
-    	for (var r = 8; r < this.moduleCount - 8; r++) {
-    		if (this.modules[r][6] != null) {
-    			continue;
-    		}
-    		this.modules[r][6] = (r % 2 == 0);
-    	}
-
-    	for (var c = 8; c < this.moduleCount - 8; c++) {
-    		if (this.modules[6][c] != null) {
-    			continue;
-    		}
-    		this.modules[6][c] = (c % 2 == 0);
-    	}
-    };
-
-    proto.setupPositionAdjustPattern = function() {
-
-    	var pos = util.getPatternPosition(this.typeNumber);
-    	
-    	for (var i = 0; i < pos.length; i++) {
-    	
-    		for (var j = 0; j < pos.length; j++) {
-    		
-    			var row = pos[i];
-    			var col = pos[j];
-    			
-    			if (this.modules[row][col] != null) {
-    				continue;
-    			}
-    			
-    			for (var r = -2; r <= 2; r++) {
-    			
-    				for (var c = -2; c <= 2; c++) {
-    				
-    					if (r == -2 || r == 2 || c == -2 || c == 2
-    							|| (r == 0 && c == 0) ) {
-    						this.modules[row + r][col + c] = true;
-    					} else {
-    						this.modules[row + r][col + c] = false;
-    					}
-    				}
-    			}
-    		}
-    	}
-    };
-
-    proto.setupTypeNumber = function(test) {
-
-    	var bits = util.getBCHTypeNumber(this.typeNumber);
-
-    	for (var i = 0; i < 18; i++) {
-    		var mod = (!test && ( (bits >> i) & 1) == 1);
-    		this.modules[Math.floor(i / 3)][i % 3 + this.moduleCount - 8 - 3] = mod;
-    	}
-
-    	for (var i = 0; i < 18; i++) {
-    		var mod = (!test && ( (bits >> i) & 1) == 1);
-    		this.modules[i % 3 + this.moduleCount - 8 - 3][Math.floor(i / 3)] = mod;
-    	}
-    };
-
-    proto.setupTypeInfo = function(test, maskPattern) {
-
-    	var data = (this.errorCorrectLevel << 3) | maskPattern;
-    	var bits = util.getBCHTypeInfo(data);
-
-    	// vertical		
-    	for (var i = 0; i < 15; i++) {
-
-    		var mod = (!test && ( (bits >> i) & 1) == 1);
-
-    		if (i < 6) {
-    			this.modules[i][8] = mod;
-    		} else if (i < 8) {
-    			this.modules[i + 1][8] = mod;
-    		} else {
-    			this.modules[this.moduleCount - 15 + i][8] = mod;
-    		}
-    	}
-
-    	// horizontal
-    	for (var i = 0; i < 15; i++) {
-
-    		var mod = (!test && ( (bits >> i) & 1) == 1);
-    		
-    		if (i < 8) {
-    			this.modules[8][this.moduleCount - i - 1] = mod;
-    		} else if (i < 9) {
-    			this.modules[8][15 - i - 1 + 1] = mod;
-    		} else {
-    			this.modules[8][15 - i - 1] = mod;
-    		}
-    	}
-
-    	// fixed module
-    	this.modules[this.moduleCount - 8][8] = (!test);
-    };
-
-    proto.mapData = function(data, maskPattern) {
-    	
-    	var inc = -1;
-    	var row = this.moduleCount - 1;
-    	var bitIndex = 7;
-    	var byteIndex = 0;
-    	
-    	for (var col = this.moduleCount - 1; col > 0; col -= 2) {
-
-    		if (col == 6) col--;
-
-    		while (true) {
-
-    			for (var c = 0; c < 2; c++) {
-    				
-    				if (this.modules[row][col - c] == null) {
-    					
-    					var dark = false;
-
-    					if (byteIndex < data.length) {
-    						dark = ( ( (data[byteIndex] >>> bitIndex) & 1) == 1);
-    					}
-
-    					var mask = util.getMask(maskPattern, row, col - c);
-
-    					if (mask) {
-    						dark = !dark;
-    					}
-    					
-    					this.modules[row][col - c] = dark;
-    					bitIndex--;
-
-    					if (bitIndex == -1) {
-    						byteIndex++;
-    						bitIndex = 7;
-    					}
-    				}
-    			}
-    							
-    			row += inc;
-
-    			if (row < 0 || this.moduleCount <= row) {
-    				row -= inc;
-    				inc = -inc;
-    				break;
-    			}
-    		}
-    	}
-    };
-
-    QRCode$1.PAD0 = 0xEC;
-    QRCode$1.PAD1 = 0x11;
-
-    QRCode$1.createData = function(typeNumber, errorCorrectLevel, dataList) {
-    	
-    	var rsBlocks = RSBlock.getRSBlocks(typeNumber, errorCorrectLevel);
-    	
-    	var buffer = new BitBuffer();
-    	
-    	for (var i = 0; i < dataList.length; i++) {
-    		var data = dataList[i];
-    		buffer.put(data.mode, 4);
-    		buffer.put(data.getLength(), util.getLengthInBits(data.mode, typeNumber) );
-    		data.write(buffer);
-    	}
-
-    	// calc num max data.
-    	var totalDataCount = 0;
-    	for (var i = 0; i < rsBlocks.length; i++) {
-    		totalDataCount += rsBlocks[i].dataCount;
-    	}
-
-    	if (buffer.getLengthInBits() > totalDataCount * 8) {
-    		throw new Error("code length overflow. ("
-    			+ buffer.getLengthInBits()
-    			+ ">"
-    			+  totalDataCount * 8
-    			+ ")");
-    	}
-
-    	// end code
-    	if (buffer.getLengthInBits() + 4 <= totalDataCount * 8) {
-    		buffer.put(0, 4);
-    	}
-
-    	// padding
-    	while (buffer.getLengthInBits() % 8 != 0) {
-    		buffer.putBit(false);
-    	}
-
-    	// padding
-    	while (true) {
-    		
-    		if (buffer.getLengthInBits() >= totalDataCount * 8) {
-    			break;
-    		}
-    		buffer.put(QRCode$1.PAD0, 8);
-    		
-    		if (buffer.getLengthInBits() >= totalDataCount * 8) {
-    			break;
-    		}
-    		buffer.put(QRCode$1.PAD1, 8);
-    	}
-
-    	return QRCode$1.createBytes(buffer, rsBlocks);
-    };
-
-    QRCode$1.createBytes = function(buffer, rsBlocks) {
-
-    	var offset = 0;
-    	
-    	var maxDcCount = 0;
-    	var maxEcCount = 0;
-    	
-    	var dcdata = new Array(rsBlocks.length);
-    	var ecdata = new Array(rsBlocks.length);
-    	
-    	for (var r = 0; r < rsBlocks.length; r++) {
-
-    		var dcCount = rsBlocks[r].dataCount;
-    		var ecCount = rsBlocks[r].totalCount - dcCount;
-
-    		maxDcCount = Math.max(maxDcCount, dcCount);
-    		maxEcCount = Math.max(maxEcCount, ecCount);
-    		
-    		dcdata[r] = new Array(dcCount);
-    		
-    		for (var i = 0; i < dcdata[r].length; i++) {
-    			dcdata[r][i] = 0xff & buffer.buffer[i + offset];
-    		}
-    		offset += dcCount;
-    		
-    		var rsPoly = util.getErrorCorrectPolynomial(ecCount);
-    		var rawPoly = new Polynomial(dcdata[r], rsPoly.getLength() - 1);
-
-    		var modPoly = rawPoly.mod(rsPoly);
-    		ecdata[r] = new Array(rsPoly.getLength() - 1);
-    		for (var i = 0; i < ecdata[r].length; i++) {
-                var modIndex = i + modPoly.getLength() - ecdata[r].length;
-    			ecdata[r][i] = (modIndex >= 0)? modPoly.get(modIndex) : 0;
-    		}
-
-    	}
-    	
-    	var totalCodeCount = 0;
-    	for (var i = 0; i < rsBlocks.length; i++) {
-    		totalCodeCount += rsBlocks[i].totalCount;
-    	}
-
-    	var data = new Array(totalCodeCount);
-    	var index = 0;
-
-    	for (var i = 0; i < maxDcCount; i++) {
-    		for (var r = 0; r < rsBlocks.length; r++) {
-    			if (i < dcdata[r].length) {
-    				data[index++] = dcdata[r][i];
-    			}
-    		}
-    	}
-
-    	for (var i = 0; i < maxEcCount; i++) {
-    		for (var r = 0; r < rsBlocks.length; r++) {
-    			if (i < ecdata[r].length) {
-    				data[index++] = ecdata[r][i];
-    			}
-    		}
-    	}
-
-    	return data;
-    };
-
-    var QRCode_1 = QRCode$1;
-
-    var defaultErrorCorrectLevel = 'H';
-    // Thanks the `qrcode.react`
-    var SUPPORTS_PATH2D = (function () {
-        try {
-            new Path2D().addPath(new Path2D());
-        }
-        catch (e) {
-            return false;
-        }
-        return true;
-    })();
-    function QRCode(data, level) {
-        var errorCorrectLevel = ErrorCorrectLevel[level];
-        // We'll use type===-1 to force QRCode to automatically pick the best type
-        var qrcode = new QRCode_1(-1, errorCorrectLevel);
-        qrcode.addData(toUTF8String(data));
-        qrcode.make();
-        return qrcode;
-    }
-    function validErrorCorrectLevel(level) {
-        return level in ErrorCorrectLevel;
-    }
-    /**
-     * Encode UTF16 to UTF8.
-     * See: http://jonisalonen.com/2012/from-utf-16-to-utf-8-in-javascript/
-     * @param str {string}
-     * @returns {string}
-     */
-    function toUTF8String(str) {
-        var utf8Str = '';
-        for (var i = 0; i < str.length; i++) {
-            var charCode = str.charCodeAt(i);
-            if (charCode < 0x0080) {
-                utf8Str += String.fromCharCode(charCode);
-            }
-            else if (charCode < 0x0800) {
-                utf8Str += String.fromCharCode(0xc0 | (charCode >> 6));
-                utf8Str += String.fromCharCode(0x80 | (charCode & 0x3f));
-            }
-            else if (charCode < 0xd800 || charCode >= 0xe000) {
-                utf8Str += String.fromCharCode(0xe0 | (charCode >> 12));
-                utf8Str += String.fromCharCode(0x80 | ((charCode >> 6) & 0x3f));
-                utf8Str += String.fromCharCode(0x80 | (charCode & 0x3f));
-            }
-            else {
-                // surrogate pair
-                i++;
-                // UTF-16 encodes 0x10000-0x10FFFF by
-                // subtracting 0x10000 and splitting the
-                // 20 bits of 0x0-0xFFFFF into two halves
-                charCode =
-                    0x10000 + (((charCode & 0x3ff) << 10) | (str.charCodeAt(i) & 0x3ff));
-                utf8Str += String.fromCharCode(0xf0 | (charCode >> 18));
-                utf8Str += String.fromCharCode(0x80 | ((charCode >> 12) & 0x3f));
-                utf8Str += String.fromCharCode(0x80 | ((charCode >> 6) & 0x3f));
-                utf8Str += String.fromCharCode(0x80 | (charCode & 0x3f));
-            }
-        }
-        return utf8Str;
-    }
-    function generatePath(modules, margin) {
-        if (margin === void 0) { margin = 0; }
-        var ops = [];
-        modules.forEach(function (row, y) {
-            var start = null;
-            row.forEach(function (cell, x) {
-                if (!cell && start !== null) {
-                    // M0 0h7v1H0z injects the space with the move and drops the comma,
-                    // saving a char per operation
-                    ops.push("M" + (start + margin) + " " + (y + margin) + "h" + (x - start) + "v1H" + (start + margin) + "z");
-                    start = null;
-                    return;
-                }
-                // end of row, clean up or skip
-                if (x === row.length - 1) {
-                    if (!cell) {
-                        // We would have closed the op above already so this can only mean
-                        // 2+ light modules in a row.
-                        return;
-                    }
-                    if (start === null) {
-                        // Just a single dark module.
-                        ops.push("M" + (x + margin) + "," + (y + margin) + " h1v1H" + (x + margin) + "z");
-                    }
-                    else {
-                        // Otherwise finish the current line.
-                        ops.push("M" + (start + margin) + "," + (y + margin) + " h" + (x + 1 - start) + "v1H" + (start + margin) + "z");
-                    }
-                    return;
-                }
-                if (cell && start === null) {
-                    start = x;
-                }
-            });
-        });
-        return ops.join('');
-    }
-    var QRCodeProps = {
-        value: {
-            type: String,
-            required: true,
-            "default": '',
-        },
-        size: {
-            type: Number,
-            "default": 100,
-        },
-        level: {
-            type: String,
-            "default": defaultErrorCorrectLevel,
-            validator: function (l) { return validErrorCorrectLevel(l); },
-        },
-        background: {
-            type: String,
-            "default": '#fff',
-        },
-        foreground: {
-            type: String,
-            "default": '#000',
-        },
-        margin: {
-            type: Number,
-            required: false,
-            "default": 0,
-        },
-    };
-    var QRCodeVueProps = __assign(__assign({}, QRCodeProps), { renderAs: {
-            type: String,
-            required: false,
-            "default": 'canvas',
-            validator: function (as) { return ['canvas', 'svg'].indexOf(as) > -1; },
-        } });
-    var QRCodeSvg = vue.defineComponent({
-        name: 'QRCodeSvg',
-        props: QRCodeProps,
-        setup: function (props) {
-            var numCells = vue.ref(0);
-            var fgPath = vue.ref('');
-            var generate = function () {
-                var value = props.value, level = props.level, margin = props.margin;
-                var cells = QRCode(value, level).modules;
-                numCells.value = cells.length + margin * 2;
-                // Drawing strategy: instead of a rect per module, we're going to create a
-                // single path for the dark modules and layer that on top of a light rect,
-                // for a total of 2 DOM nodes. We pay a bit more in string concat but that's
-                // way faster than DOM ops.
-                // For level 1, 441 nodes -> 2
-                // For level 40, 31329 -> 2
-                fgPath.value = generatePath(cells, margin);
-            };
-            generate();
-            vue.onUpdated(generate);
-            return function () { return vue.h('svg', {
-                width: props.size,
-                height: props.size,
-                'shape-rendering': "crispEdges",
-                xmlns: 'http://www.w3.org/2000/svg',
-                viewBox: "0 0 " + numCells.value + " " + numCells.value,
-            }, [
-                vue.h('path', {
-                    fill: props.background,
-                    d: "M0,0 h" + numCells.value + "v" + numCells.value + "H0z",
-                }),
-                vue.h('path', { fill: props.foreground, d: fgPath.value }),
-            ]); };
-        },
-    });
-    var QRCodeCanvas = vue.defineComponent({
-        name: 'QRCodeCanvas',
-        props: QRCodeProps,
-        setup: function (props) {
-            var canvasEl = vue.ref(null);
-            var generate = function () {
-                var value = props.value, level = props.level, size = props.size, margin = props.margin, background = props.background, foreground = props.foreground;
-                var cells = QRCode(value, level).modules;
-                var numCells = cells.length + margin * 2;
-                var canvas = canvasEl.value;
-                if (!canvas) {
-                    return;
-                }
-                var ctx = canvas.getContext('2d');
-                if (!ctx) {
-                    return;
-                }
-                var devicePixelRatio = window.devicePixelRatio || 1;
-                var scale = (size / numCells) * devicePixelRatio;
-                canvas.height = canvas.width = size * devicePixelRatio;
-                ctx.scale(scale, scale);
-                ctx.fillStyle = background;
-                ctx.fillRect(0, 0, numCells, numCells);
-                ctx.fillStyle = foreground;
-                if (SUPPORTS_PATH2D) {
-                    ctx.fill(new Path2D(generatePath(cells, margin)));
-                }
-                else {
-                    cells.forEach(function (row, rdx) {
-                        row.forEach(function (cell, cdx) {
-                            if (cell) {
-                                ctx.fillRect(cdx + margin, rdx + margin, 1, 1);
-                            }
-                        });
-                    });
-                }
-            };
-            vue.onMounted(generate);
-            vue.onUpdated(generate);
-            return function () { return vue.h('canvas', {
-                ref: canvasEl,
-                style: { width: props.size + "px", height: props.size + "px" },
-            }); };
-        },
-    });
-    var QrcodeVue = vue.defineComponent({
-        name: 'Qrcode',
-        render: function () {
-            var _a = this.$props, renderAs = _a.renderAs, value = _a.value, _size = _a.size, _margin = _a.margin, _level = _a.level, background = _a.background, foreground = _a.foreground;
-            var size = _size >>> 0;
-            var margin = _margin >>> 0;
-            var level = validErrorCorrectLevel(_level) ? _level : defaultErrorCorrectLevel;
-            return vue.h(renderAs === 'svg' ? QRCodeSvg : QRCodeCanvas, { value: value, size: size, margin: margin, level: level, background: background, foreground: foreground });
-        },
-        props: QRCodeVueProps,
+    var QRCodeVueProps = __assign(__assign({}, QRCodeProps), { renderAs: {
+            type: String,
+            required: false,
+            default: 'canvas',
+            validator: function (as) { return ['canvas', 'svg'].indexOf(as) > -1; },
+        } });
+    var QRCodeSvg = vue.defineComponent({
+        name: 'QRCodeSvg',
+        props: QRCodeProps,
+        setup: function (props) {
+            var numCells = vue.ref(0);
+            var fgPath = vue.ref('');
+            var generate = function () {
+                var value = props.value, level = props.level, margin = props.margin;
+                var cells = QR.QrCode.encodeText(value, ErrorCorrectLevelMap[level]).getModules();
+                numCells.value = cells.length + margin * 2;
+                // Drawing strategy: instead of a rect per module, we're going to create a
+                // single path for the dark modules and layer that on top of a light rect,
+                // for a total of 2 DOM nodes. We pay a bit more in string concat but that's
+                // way faster than DOM ops.
+                // For level 1, 441 nodes -> 2
+                // For level 40, 31329 -> 2
+                fgPath.value = generatePath(cells, margin);
+            };
+            generate();
+            vue.onUpdated(generate);
+            return function () { return vue.h('svg', {
+                width: props.size,
+                height: props.size,
+                'shape-rendering': "crispEdges",
+                xmlns: 'http://www.w3.org/2000/svg',
+                viewBox: "0 0 ".concat(numCells.value, " ").concat(numCells.value),
+            }, [
+                vue.h('path', {
+                    fill: props.background,
+                    d: "M0,0 h".concat(numCells.value, "v").concat(numCells.value, "H0z"),
+                }),
+                vue.h('path', { fill: props.foreground, d: fgPath.value }),
+            ]); };
+        },
+    });
+    var QRCodeCanvas = vue.defineComponent({
+        name: 'QRCodeCanvas',
+        props: QRCodeProps,
+        setup: function (props) {
+            var canvasEl = vue.ref(null);
+            var generate = function () {
+                var value = props.value, level = props.level, size = props.size, margin = props.margin, background = props.background, foreground = props.foreground;
+                var canvas = canvasEl.value;
+                if (!canvas) {
+                    return;
+                }
+                var ctx = canvas.getContext('2d');
+                if (!ctx) {
+                    return;
+                }
+                var cells = QR.QrCode.encodeText(value, ErrorCorrectLevelMap[level]).getModules();
+                var numCells = cells.length + margin * 2;
+                var devicePixelRatio = window.devicePixelRatio || 1;
+                var scale = (size / numCells) * devicePixelRatio;
+                canvas.height = canvas.width = size * devicePixelRatio;
+                ctx.scale(scale, scale);
+                ctx.fillStyle = background;
+                ctx.fillRect(0, 0, numCells, numCells);
+                ctx.fillStyle = foreground;
+                if (SUPPORTS_PATH2D) {
+                    ctx.fill(new Path2D(generatePath(cells, margin)));
+                }
+                else {
+                    cells.forEach(function (row, rdx) {
+                        row.forEach(function (cell, cdx) {
+                            if (cell) {
+                                ctx.fillRect(cdx + margin, rdx + margin, 1, 1);
+                            }
+                        });
+                    });
+                }
+            };
+            vue.onMounted(generate);
+            vue.onUpdated(generate);
+            return function () { return vue.h('canvas', {
+                ref: canvasEl,
+                style: { width: "".concat(props.size, "px"), height: "".concat(props.size, "px") },
+            }); };
+        },
+    });
+    var QrcodeVue = vue.defineComponent({
+        name: 'Qrcode',
+        render: function () {
+            var _a = this.$props, renderAs = _a.renderAs, value = _a.value, _size = _a.size, _margin = _a.margin, _level = _a.level, background = _a.background, foreground = _a.foreground;
+            var size = _size >>> 0;
+            var margin = _margin >>> 0;
+            var level = validErrorCorrectLevel(_level) ? _level : defaultErrorCorrectLevel;
+            return vue.h(renderAs === 'svg' ? QRCodeSvg : QRCodeCanvas, { value: value, size: size, margin: margin, level: level, background: background, foreground: foreground });
+        },
+        props: QRCodeVueProps,
     });
 
     return QrcodeVue;