@falcon-ui/falcon-ui 1.0.0

package/esm/components/qr-code/src/qr-code.vue.mjs

@@ -0,0 +1,1958 @@
+import { computed, createCommentVNode, createElementBlock, createElementVNode, defineComponent, mergeProps, normalizeStyle, onBeforeUnmount, onMounted, openBlock, ref, unref, useAttrs, watch } from "vue";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var require_can_promise = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = function() {
+		return typeof Promise === "function" && Promise.prototype && Promise.prototype.then;
+	};
+}));
+var require_utils$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var toSJISFunction;
+	var CODEWORDS_COUNT = [
+		0,
+		26,
+		44,
+		70,
+		100,
+		134,
+		172,
+		196,
+		242,
+		292,
+		346,
+		404,
+		466,
+		532,
+		581,
+		655,
+		733,
+		815,
+		901,
+		991,
+		1085,
+		1156,
+		1258,
+		1364,
+		1474,
+		1588,
+		1706,
+		1828,
+		1921,
+		2051,
+		2185,
+		2323,
+		2465,
+		2611,
+		2761,
+		2876,
+		3034,
+		3196,
+		3362,
+		3532,
+		3706
+	];
+	exports.getSymbolSize = function getSymbolSize$2(version) {
+		if (!version) throw new Error("\"version\" cannot be null or undefined");
+		if (version < 1 || version > 40) throw new Error("\"version\" should be in range from 1 to 40");
+		return version * 4 + 17;
+	};
+	exports.getSymbolTotalCodewords = function getSymbolTotalCodewords(version) {
+		return CODEWORDS_COUNT[version];
+	};
+	exports.getBCHDigit = function(data) {
+		let digit = 0;
+		while (data !== 0) {
+			digit++;
+			data >>>= 1;
+		}
+		return digit;
+	};
+	exports.setToSJISFunction = function setToSJISFunction(f) {
+		if (typeof f !== "function") throw new Error("\"toSJISFunc\" is not a valid function.");
+		toSJISFunction = f;
+	};
+	exports.isKanjiModeEnabled = function() {
+		return typeof toSJISFunction !== "undefined";
+	};
+	exports.toSJIS = function toSJIS(kanji$1) {
+		return toSJISFunction(kanji$1);
+	};
+}));
+var require_error_correction_level = /* @__PURE__ */ __commonJSMin(((exports) => {
+	exports.L = { bit: 1 };
+	exports.M = { bit: 0 };
+	exports.Q = { bit: 3 };
+	exports.H = { bit: 2 };
+	function fromString$1(string) {
+		if (typeof string !== "string") throw new Error("Param is not a string");
+		switch (string.toLowerCase()) {
+			case "l":
+			case "low": return exports.L;
+			case "m":
+			case "medium": return exports.M;
+			case "q":
+			case "quartile": return exports.Q;
+			case "h":
+			case "high": return exports.H;
+			default: throw new Error("Unknown EC Level: " + string);
+		}
+	}
+	exports.isValid = function isValid(level) {
+		return level && typeof level.bit !== "undefined" && level.bit >= 0 && level.bit < 4;
+	};
+	exports.from = function from(value, defaultValue) {
+		if (exports.isValid(value)) return value;
+		try {
+			return fromString$1(value);
+		} catch (e) {
+			return defaultValue;
+		}
+	};
+}));
+var require_bit_buffer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function BitBuffer$1() {
+		this.buffer = [];
+		this.length = 0;
+	}
+	BitBuffer$1.prototype = {
+		get: function(index) {
+			const bufIndex = Math.floor(index / 8);
+			return (this.buffer[bufIndex] >>> 7 - index % 8 & 1) === 1;
+		},
+		put: function(num, length) {
+			for (let i = 0; i < length; i++) this.putBit((num >>> length - i - 1 & 1) === 1);
+		},
+		getLengthInBits: function() {
+			return this.length;
+		},
+		putBit: function(bit) {
+			const bufIndex = Math.floor(this.length / 8);
+			if (this.buffer.length <= bufIndex) this.buffer.push(0);
+			if (bit) this.buffer[bufIndex] |= 128 >>> this.length % 8;
+			this.length++;
+		}
+	};
+	module.exports = BitBuffer$1;
+}));
+var require_bit_matrix = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function BitMatrix$1(size) {
+		if (!size || size < 1) throw new Error("BitMatrix size must be defined and greater than 0");
+		this.size = size;
+		this.data = new Uint8Array(size * size);
+		this.reservedBit = new Uint8Array(size * size);
+	}
+	BitMatrix$1.prototype.set = function(row, col, value, reserved) {
+		const index = row * this.size + col;
+		this.data[index] = value;
+		if (reserved) this.reservedBit[index] = true;
+	};
+	BitMatrix$1.prototype.get = function(row, col) {
+		return this.data[row * this.size + col];
+	};
+	BitMatrix$1.prototype.xor = function(row, col, value) {
+		this.data[row * this.size + col] ^= value;
+	};
+	BitMatrix$1.prototype.isReserved = function(row, col) {
+		return this.reservedBit[row * this.size + col];
+	};
+	module.exports = BitMatrix$1;
+}));
+var require_alignment_pattern = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var getSymbolSize$1 = require_utils$1().getSymbolSize;
+	exports.getRowColCoords = function getRowColCoords(version) {
+		if (version === 1) return [];
+		const posCount = Math.floor(version / 7) + 2;
+		const size = getSymbolSize$1(version);
+		const intervals = size === 145 ? 26 : Math.ceil((size - 13) / (2 * posCount - 2)) * 2;
+		const positions = [size - 7];
+		for (let i = 1; i < posCount - 1; i++) positions[i] = positions[i - 1] - intervals;
+		positions.push(6);
+		return positions.reverse();
+	};
+	exports.getPositions = function getPositions(version) {
+		const coords = [];
+		const pos = exports.getRowColCoords(version);
+		const posLength = pos.length;
+		for (let i = 0; i < posLength; i++) for (let j = 0; j < posLength; j++) {
+			if (i === 0 && j === 0 || i === 0 && j === posLength - 1 || i === posLength - 1 && j === 0) continue;
+			coords.push([pos[i], pos[j]]);
+		}
+		return coords;
+	};
+}));
+var require_finder_pattern = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var getSymbolSize = require_utils$1().getSymbolSize;
+	var FINDER_PATTERN_SIZE = 7;
+	exports.getPositions = function getPositions(version) {
+		const size = getSymbolSize(version);
+		return [
+			[0, 0],
+			[size - FINDER_PATTERN_SIZE, 0],
+			[0, size - FINDER_PATTERN_SIZE]
+		];
+	};
+}));
+var require_mask_pattern = /* @__PURE__ */ __commonJSMin(((exports) => {
+	exports.Patterns = {
+		PATTERN000: 0,
+		PATTERN001: 1,
+		PATTERN010: 2,
+		PATTERN011: 3,
+		PATTERN100: 4,
+		PATTERN101: 5,
+		PATTERN110: 6,
+		PATTERN111: 7
+	};
+	var PenaltyScores = {
+		N1: 3,
+		N2: 3,
+		N3: 40,
+		N4: 10
+	};
+	exports.isValid = function isValid(mask) {
+		return mask != null && mask !== "" && !isNaN(mask) && mask >= 0 && mask <= 7;
+	};
+	exports.from = function from(value) {
+		return exports.isValid(value) ? parseInt(value, 10) : void 0;
+	};
+	exports.getPenaltyN1 = function getPenaltyN1(data) {
+		const size = data.size;
+		let points = 0;
+		let sameCountCol = 0;
+		let sameCountRow = 0;
+		let lastCol = null;
+		let lastRow = null;
+		for (let row = 0; row < size; row++) {
+			sameCountCol = sameCountRow = 0;
+			lastCol = lastRow = null;
+			for (let col = 0; col < size; col++) {
+				let module$1 = data.get(row, col);
+				if (module$1 === lastCol) sameCountCol++;
+				else {
+					if (sameCountCol >= 5) points += PenaltyScores.N1 + (sameCountCol - 5);
+					lastCol = module$1;
+					sameCountCol = 1;
+				}
+				module$1 = data.get(col, row);
+				if (module$1 === lastRow) sameCountRow++;
+				else {
+					if (sameCountRow >= 5) points += PenaltyScores.N1 + (sameCountRow - 5);
+					lastRow = module$1;
+					sameCountRow = 1;
+				}
+			}
+			if (sameCountCol >= 5) points += PenaltyScores.N1 + (sameCountCol - 5);
+			if (sameCountRow >= 5) points += PenaltyScores.N1 + (sameCountRow - 5);
+		}
+		return points;
+	};
+	exports.getPenaltyN2 = function getPenaltyN2(data) {
+		const size = data.size;
+		let points = 0;
+		for (let row = 0; row < size - 1; row++) for (let col = 0; col < size - 1; col++) {
+			const last = data.get(row, col) + data.get(row, col + 1) + data.get(row + 1, col) + data.get(row + 1, col + 1);
+			if (last === 4 || last === 0) points++;
+		}
+		return points * PenaltyScores.N2;
+	};
+	exports.getPenaltyN3 = function getPenaltyN3(data) {
+		const size = data.size;
+		let points = 0;
+		let bitsCol = 0;
+		let bitsRow = 0;
+		for (let row = 0; row < size; row++) {
+			bitsCol = bitsRow = 0;
+			for (let col = 0; col < size; col++) {
+				bitsCol = bitsCol << 1 & 2047 | data.get(row, col);
+				if (col >= 10 && (bitsCol === 1488 || bitsCol === 93)) points++;
+				bitsRow = bitsRow << 1 & 2047 | data.get(col, row);
+				if (col >= 10 && (bitsRow === 1488 || bitsRow === 93)) points++;
+			}
+		}
+		return points * PenaltyScores.N3;
+	};
+	exports.getPenaltyN4 = function getPenaltyN4(data) {
+		let darkCount = 0;
+		const modulesCount = data.data.length;
+		for (let i = 0; i < modulesCount; i++) darkCount += data.data[i];
+		return Math.abs(Math.ceil(darkCount * 100 / modulesCount / 5) - 10) * PenaltyScores.N4;
+	};
+	function getMaskAt(maskPattern, i, j) {
+		switch (maskPattern) {
+			case exports.Patterns.PATTERN000: return (i + j) % 2 === 0;
+			case exports.Patterns.PATTERN001: return i % 2 === 0;
+			case exports.Patterns.PATTERN010: return j % 3 === 0;
+			case exports.Patterns.PATTERN011: return (i + j) % 3 === 0;
+			case exports.Patterns.PATTERN100: return (Math.floor(i / 2) + Math.floor(j / 3)) % 2 === 0;
+			case exports.Patterns.PATTERN101: return i * j % 2 + i * j % 3 === 0;
+			case exports.Patterns.PATTERN110: return (i * j % 2 + i * j % 3) % 2 === 0;
+			case exports.Patterns.PATTERN111: return (i * j % 3 + (i + j) % 2) % 2 === 0;
+			default: throw new Error("bad maskPattern:" + maskPattern);
+		}
+	}
+	exports.applyMask = function applyMask(pattern, data) {
+		const size = data.size;
+		for (let col = 0; col < size; col++) for (let row = 0; row < size; row++) {
+			if (data.isReserved(row, col)) continue;
+			data.xor(row, col, getMaskAt(pattern, row, col));
+		}
+	};
+	exports.getBestMask = function getBestMask(data, setupFormatFunc) {
+		const numPatterns = Object.keys(exports.Patterns).length;
+		let bestPattern = 0;
+		let lowerPenalty = Infinity;
+		for (let p = 0; p < numPatterns; p++) {
+			setupFormatFunc(p);
+			exports.applyMask(p, data);
+			const penalty = exports.getPenaltyN1(data) + exports.getPenaltyN2(data) + exports.getPenaltyN3(data) + exports.getPenaltyN4(data);
+			exports.applyMask(p, data);
+			if (penalty < lowerPenalty) {
+				lowerPenalty = penalty;
+				bestPattern = p;
+			}
+		}
+		return bestPattern;
+	};
+}));
+var require_error_correction_code = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var ECLevel$2 = require_error_correction_level();
+	var EC_BLOCKS_TABLE = [
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		2,
+		2,
+		1,
+		2,
+		2,
+		4,
+		1,
+		2,
+		4,
+		4,
+		2,
+		4,
+		4,
+		4,
+		2,
+		4,
+		6,
+		5,
+		2,
+		4,
+		6,
+		6,
+		2,
+		5,
+		8,
+		8,
+		4,
+		5,
+		8,
+		8,
+		4,
+		5,
+		8,
+		11,
+		4,
+		8,
+		10,
+		11,
+		4,
+		9,
+		12,
+		16,
+		4,
+		9,
+		16,
+		16,
+		6,
+		10,
+		12,
+		18,
+		6,
+		10,
+		17,
+		16,
+		6,
+		11,
+		16,
+		19,
+		6,
+		13,
+		18,
+		21,
+		7,
+		14,
+		21,
+		25,
+		8,
+		16,
+		20,
+		25,
+		8,
+		17,
+		23,
+		25,
+		9,
+		17,
+		23,
+		34,
+		9,
+		18,
+		25,
+		30,
+		10,
+		20,
+		27,
+		32,
+		12,
+		21,
+		29,
+		35,
+		12,
+		23,
+		34,
+		37,
+		12,
+		25,
+		34,
+		40,
+		13,
+		26,
+		35,
+		42,
+		14,
+		28,
+		38,
+		45,
+		15,
+		29,
+		40,
+		48,
+		16,
+		31,
+		43,
+		51,
+		17,
+		33,
+		45,
+		54,
+		18,
+		35,
+		48,
+		57,
+		19,
+		37,
+		51,
+		60,
+		19,
+		38,
+		53,
+		63,
+		20,
+		40,
+		56,
+		66,
+		21,
+		43,
+		59,
+		70,
+		22,
+		45,
+		62,
+		74,
+		24,
+		47,
+		65,
+		77,
+		25,
+		49,
+		68,
+		81
+	];
+	var EC_CODEWORDS_TABLE = [
+		7,
+		10,
+		13,
+		17,
+		10,
+		16,
+		22,
+		28,
+		15,
+		26,
+		36,
+		44,
+		20,
+		36,
+		52,
+		64,
+		26,
+		48,
+		72,
+		88,
+		36,
+		64,
+		96,
+		112,
+		40,
+		72,
+		108,
+		130,
+		48,
+		88,
+		132,
+		156,
+		60,
+		110,
+		160,
+		192,
+		72,
+		130,
+		192,
+		224,
+		80,
+		150,
+		224,
+		264,
+		96,
+		176,
+		260,
+		308,
+		104,
+		198,
+		288,
+		352,
+		120,
+		216,
+		320,
+		384,
+		132,
+		240,
+		360,
+		432,
+		144,
+		280,
+		408,
+		480,
+		168,
+		308,
+		448,
+		532,
+		180,
+		338,
+		504,
+		588,
+		196,
+		364,
+		546,
+		650,
+		224,
+		416,
+		600,
+		700,
+		224,
+		442,
+		644,
+		750,
+		252,
+		476,
+		690,
+		816,
+		270,
+		504,
+		750,
+		900,
+		300,
+		560,
+		810,
+		960,
+		312,
+		588,
+		870,
+		1050,
+		336,
+		644,
+		952,
+		1110,
+		360,
+		700,
+		1020,
+		1200,
+		390,
+		728,
+		1050,
+		1260,
+		420,
+		784,
+		1140,
+		1350,
+		450,
+		812,
+		1200,
+		1440,
+		480,
+		868,
+		1290,
+		1530,
+		510,
+		924,
+		1350,
+		1620,
+		540,
+		980,
+		1440,
+		1710,
+		570,
+		1036,
+		1530,
+		1800,
+		570,
+		1064,
+		1590,
+		1890,
+		600,
+		1120,
+		1680,
+		1980,
+		630,
+		1204,
+		1770,
+		2100,
+		660,
+		1260,
+		1860,
+		2220,
+		720,
+		1316,
+		1950,
+		2310,
+		750,
+		1372,
+		2040,
+		2430
+	];
+	exports.getBlocksCount = function getBlocksCount(version, errorCorrectionLevel) {
+		switch (errorCorrectionLevel) {
+			case ECLevel$2.L: return EC_BLOCKS_TABLE[(version - 1) * 4 + 0];
+			case ECLevel$2.M: return EC_BLOCKS_TABLE[(version - 1) * 4 + 1];
+			case ECLevel$2.Q: return EC_BLOCKS_TABLE[(version - 1) * 4 + 2];
+			case ECLevel$2.H: return EC_BLOCKS_TABLE[(version - 1) * 4 + 3];
+			default: return;
+		}
+	};
+	exports.getTotalCodewordsCount = function getTotalCodewordsCount(version, errorCorrectionLevel) {
+		switch (errorCorrectionLevel) {
+			case ECLevel$2.L: return EC_CODEWORDS_TABLE[(version - 1) * 4 + 0];
+			case ECLevel$2.M: return EC_CODEWORDS_TABLE[(version - 1) * 4 + 1];
+			case ECLevel$2.Q: return EC_CODEWORDS_TABLE[(version - 1) * 4 + 2];
+			case ECLevel$2.H: return EC_CODEWORDS_TABLE[(version - 1) * 4 + 3];
+			default: return;
+		}
+	};
+}));
+var require_galois_field = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var EXP_TABLE = new Uint8Array(512);
+	var LOG_TABLE = new Uint8Array(256);
+	(function initTables() {
+		let x = 1;
+		for (let i = 0; i < 255; i++) {
+			EXP_TABLE[i] = x;
+			LOG_TABLE[x] = i;
+			x <<= 1;
+			if (x & 256) x ^= 285;
+		}
+		for (let i = 255; i < 512; i++) EXP_TABLE[i] = EXP_TABLE[i - 255];
+	})();
+	exports.log = function log(n) {
+		if (n < 1) throw new Error("log(" + n + ")");
+		return LOG_TABLE[n];
+	};
+	exports.exp = function exp(n) {
+		return EXP_TABLE[n];
+	};
+	exports.mul = function mul(x, y) {
+		if (x === 0 || y === 0) return 0;
+		return EXP_TABLE[LOG_TABLE[x] + LOG_TABLE[y]];
+	};
+}));
+var require_polynomial = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var GF = require_galois_field();
+	exports.mul = function mul(p1, p2) {
+		const coeff = new Uint8Array(p1.length + p2.length - 1);
+		for (let i = 0; i < p1.length; i++) for (let j = 0; j < p2.length; j++) coeff[i + j] ^= GF.mul(p1[i], p2[j]);
+		return coeff;
+	};
+	exports.mod = function mod(divident, divisor) {
+		let result = new Uint8Array(divident);
+		while (result.length - divisor.length >= 0) {
+			const coeff = result[0];
+			for (let i = 0; i < divisor.length; i++) result[i] ^= GF.mul(divisor[i], coeff);
+			let offset = 0;
+			while (offset < result.length && result[offset] === 0) offset++;
+			result = result.slice(offset);
+		}
+		return result;
+	};
+	exports.generateECPolynomial = function generateECPolynomial(degree) {
+		let poly = new Uint8Array([1]);
+		for (let i = 0; i < degree; i++) poly = exports.mul(poly, new Uint8Array([1, GF.exp(i)]));
+		return poly;
+	};
+}));
+var require_reed_solomon_encoder = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Polynomial = require_polynomial();
+	function ReedSolomonEncoder$1(degree) {
+		this.genPoly = void 0;
+		this.degree = degree;
+		if (this.degree) this.initialize(this.degree);
+	}
+	ReedSolomonEncoder$1.prototype.initialize = function initialize(degree) {
+		this.degree = degree;
+		this.genPoly = Polynomial.generateECPolynomial(this.degree);
+	};
+	ReedSolomonEncoder$1.prototype.encode = function encode(data) {
+		if (!this.genPoly) throw new Error("Encoder not initialized");
+		const paddedData = new Uint8Array(data.length + this.degree);
+		paddedData.set(data);
+		const remainder = Polynomial.mod(paddedData, this.genPoly);
+		const start = this.degree - remainder.length;
+		if (start > 0) {
+			const buff = new Uint8Array(this.degree);
+			buff.set(remainder, start);
+			return buff;
+		}
+		return remainder;
+	};
+	module.exports = ReedSolomonEncoder$1;
+}));
+var require_version_check = /* @__PURE__ */ __commonJSMin(((exports) => {
+	exports.isValid = function isValid(version) {
+		return !isNaN(version) && version >= 1 && version <= 40;
+	};
+}));
+var require_regex = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var numeric = "[0-9]+";
+	var alphanumeric = "[A-Z $%*+\\-./:]+";
+	var kanji = "(?:[u3000-u303F]|[u3040-u309F]|[u30A0-u30FF]|[uFF00-uFFEF]|[u4E00-u9FAF]|[u2605-u2606]|[u2190-u2195]|u203B|[u2010u2015u2018u2019u2025u2026u201Cu201Du2225u2260]|[u0391-u0451]|[u00A7u00A8u00B1u00B4u00D7u00F7])+";
+	kanji = kanji.replace(/u/g, "\\u");
+	var byte = "(?:(?![A-Z0-9 $%*+\\-./:]|" + kanji + ")(?:.|[\r\n]))+";
+	exports.KANJI = new RegExp(kanji, "g");
+	exports.BYTE_KANJI = new RegExp("[^A-Z0-9 $%*+\\-./:]+", "g");
+	exports.BYTE = new RegExp(byte, "g");
+	exports.NUMERIC = new RegExp(numeric, "g");
+	exports.ALPHANUMERIC = new RegExp(alphanumeric, "g");
+	var TEST_KANJI = /* @__PURE__ */ new RegExp("^" + kanji + "$");
+	var TEST_NUMERIC = /* @__PURE__ */ new RegExp("^" + numeric + "$");
+	var TEST_ALPHANUMERIC = /* @__PURE__ */ new RegExp("^[A-Z0-9 $%*+\\-./:]+$");
+	exports.testKanji = function testKanji(str) {
+		return TEST_KANJI.test(str);
+	};
+	exports.testNumeric = function testNumeric(str) {
+		return TEST_NUMERIC.test(str);
+	};
+	exports.testAlphanumeric = function testAlphanumeric(str) {
+		return TEST_ALPHANUMERIC.test(str);
+	};
+}));
+var require_mode = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var VersionCheck$1 = require_version_check();
+	var Regex$1 = require_regex();
+	exports.NUMERIC = {
+		id: "Numeric",
+		bit: 1,
+		ccBits: [
+			10,
+			12,
+			14
+		]
+	};
+	exports.ALPHANUMERIC = {
+		id: "Alphanumeric",
+		bit: 2,
+		ccBits: [
+			9,
+			11,
+			13
+		]
+	};
+	exports.BYTE = {
+		id: "Byte",
+		bit: 4,
+		ccBits: [
+			8,
+			16,
+			16
+		]
+	};
+	exports.KANJI = {
+		id: "Kanji",
+		bit: 8,
+		ccBits: [
+			8,
+			10,
+			12
+		]
+	};
+	exports.MIXED = { bit: -1 };
+	exports.getCharCountIndicator = function getCharCountIndicator(mode, version) {
+		if (!mode.ccBits) throw new Error("Invalid mode: " + mode);
+		if (!VersionCheck$1.isValid(version)) throw new Error("Invalid version: " + version);
+		if (version >= 1 && version < 10) return mode.ccBits[0];
+		else if (version < 27) return mode.ccBits[1];
+		return mode.ccBits[2];
+	};
+	exports.getBestModeForData = function getBestModeForData(dataStr) {
+		if (Regex$1.testNumeric(dataStr)) return exports.NUMERIC;
+		else if (Regex$1.testAlphanumeric(dataStr)) return exports.ALPHANUMERIC;
+		else if (Regex$1.testKanji(dataStr)) return exports.KANJI;
+		else return exports.BYTE;
+	};
+	exports.toString = function toString(mode) {
+		if (mode && mode.id) return mode.id;
+		throw new Error("Invalid mode");
+	};
+	exports.isValid = function isValid(mode) {
+		return mode && mode.bit && mode.ccBits;
+	};
+	function fromString(string) {
+		if (typeof string !== "string") throw new Error("Param is not a string");
+		switch (string.toLowerCase()) {
+			case "numeric": return exports.NUMERIC;
+			case "alphanumeric": return exports.ALPHANUMERIC;
+			case "kanji": return exports.KANJI;
+			case "byte": return exports.BYTE;
+			default: throw new Error("Unknown mode: " + string);
+		}
+	}
+	exports.from = function from(value, defaultValue) {
+		if (exports.isValid(value)) return value;
+		try {
+			return fromString(value);
+		} catch (e) {
+			return defaultValue;
+		}
+	};
+}));
+var require_version = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var Utils$6 = require_utils$1();
+	var ECCode$1 = require_error_correction_code();
+	var ECLevel$1 = require_error_correction_level();
+	var Mode$6 = require_mode();
+	var VersionCheck = require_version_check();
+	var G18 = 7973;
+	var G18_BCH = Utils$6.getBCHDigit(G18);
+	function getBestVersionForDataLength(mode, length, errorCorrectionLevel) {
+		for (let currentVersion = 1; currentVersion <= 40; currentVersion++) if (length <= exports.getCapacity(currentVersion, errorCorrectionLevel, mode)) return currentVersion;
+	}
+	function getReservedBitsCount(mode, version) {
+		return Mode$6.getCharCountIndicator(mode, version) + 4;
+	}
+	function getTotalBitsFromDataArray(segments, version) {
+		let totalBits = 0;
+		segments.forEach(function(data) {
+			const reservedBits = getReservedBitsCount(data.mode, version);
+			totalBits += reservedBits + data.getBitsLength();
+		});
+		return totalBits;
+	}
+	function getBestVersionForMixedData(segments, errorCorrectionLevel) {
+		for (let currentVersion = 1; currentVersion <= 40; currentVersion++) if (getTotalBitsFromDataArray(segments, currentVersion) <= exports.getCapacity(currentVersion, errorCorrectionLevel, Mode$6.MIXED)) return currentVersion;
+	}
+	exports.from = function from(value, defaultValue) {
+		if (VersionCheck.isValid(value)) return parseInt(value, 10);
+		return defaultValue;
+	};
+	exports.getCapacity = function getCapacity(version, errorCorrectionLevel, mode) {
+		if (!VersionCheck.isValid(version)) throw new Error("Invalid QR Code version");
+		if (typeof mode === "undefined") mode = Mode$6.BYTE;
+		const dataTotalCodewordsBits = (Utils$6.getSymbolTotalCodewords(version) - ECCode$1.getTotalCodewordsCount(version, errorCorrectionLevel)) * 8;
+		if (mode === Mode$6.MIXED) return dataTotalCodewordsBits;
+		const usableBits = dataTotalCodewordsBits - getReservedBitsCount(mode, version);
+		switch (mode) {
+			case Mode$6.NUMERIC: return Math.floor(usableBits / 10 * 3);
+			case Mode$6.ALPHANUMERIC: return Math.floor(usableBits / 11 * 2);
+			case Mode$6.KANJI: return Math.floor(usableBits / 13);
+			case Mode$6.BYTE:
+			default: return Math.floor(usableBits / 8);
+		}
+	};
+	exports.getBestVersionForData = function getBestVersionForData(data, errorCorrectionLevel) {
+		let seg;
+		const ecl = ECLevel$1.from(errorCorrectionLevel, ECLevel$1.M);
+		if (Array.isArray(data)) {
+			if (data.length > 1) return getBestVersionForMixedData(data, ecl);
+			if (data.length === 0) return 1;
+			seg = data[0];
+		} else seg = data;
+		return getBestVersionForDataLength(seg.mode, seg.getLength(), ecl);
+	};
+	exports.getEncodedBits = function getEncodedBits(version) {
+		if (!VersionCheck.isValid(version) || version < 7) throw new Error("Invalid QR Code version");
+		let d = version << 12;
+		while (Utils$6.getBCHDigit(d) - G18_BCH >= 0) d ^= G18 << Utils$6.getBCHDigit(d) - G18_BCH;
+		return version << 12 | d;
+	};
+}));
+var require_format_info = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var Utils$5 = require_utils$1();
+	var G15 = 1335;
+	var G15_MASK = 21522;
+	var G15_BCH = Utils$5.getBCHDigit(G15);
+	exports.getEncodedBits = function getEncodedBits(errorCorrectionLevel, mask) {
+		const data = errorCorrectionLevel.bit << 3 | mask;
+		let d = data << 10;
+		while (Utils$5.getBCHDigit(d) - G15_BCH >= 0) d ^= G15 << Utils$5.getBCHDigit(d) - G15_BCH;
+		return (data << 10 | d) ^ G15_MASK;
+	};
+}));
+var require_numeric_data = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Mode$5 = require_mode();
+	function NumericData$1(data) {
+		this.mode = Mode$5.NUMERIC;
+		this.data = data.toString();
+	}
+	NumericData$1.getBitsLength = function getBitsLength(length) {
+		return 10 * Math.floor(length / 3) + (length % 3 ? length % 3 * 3 + 1 : 0);
+	};
+	NumericData$1.prototype.getLength = function getLength() {
+		return this.data.length;
+	};
+	NumericData$1.prototype.getBitsLength = function getBitsLength() {
+		return NumericData$1.getBitsLength(this.data.length);
+	};
+	NumericData$1.prototype.write = function write(bitBuffer) {
+		let i, group, value;
+		for (i = 0; i + 3 <= this.data.length; i += 3) {
+			group = this.data.substr(i, 3);
+			value = parseInt(group, 10);
+			bitBuffer.put(value, 10);
+		}
+		const remainingNum = this.data.length - i;
+		if (remainingNum > 0) {
+			group = this.data.substr(i);
+			value = parseInt(group, 10);
+			bitBuffer.put(value, remainingNum * 3 + 1);
+		}
+	};
+	module.exports = NumericData$1;
+}));
+var require_alphanumeric_data = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Mode$4 = require_mode();
+	var ALPHA_NUM_CHARS = [
+		"0",
+		"1",
+		"2",
+		"3",
+		"4",
+		"5",
+		"6",
+		"7",
+		"8",
+		"9",
+		"A",
+		"B",
+		"C",
+		"D",
+		"E",
+		"F",
+		"G",
+		"H",
+		"I",
+		"J",
+		"K",
+		"L",
+		"M",
+		"N",
+		"O",
+		"P",
+		"Q",
+		"R",
+		"S",
+		"T",
+		"U",
+		"V",
+		"W",
+		"X",
+		"Y",
+		"Z",
+		" ",
+		"$",
+		"%",
+		"*",
+		"+",
+		"-",
+		".",
+		"/",
+		":"
+	];
+	function AlphanumericData$1(data) {
+		this.mode = Mode$4.ALPHANUMERIC;
+		this.data = data;
+	}
+	AlphanumericData$1.getBitsLength = function getBitsLength(length) {
+		return 11 * Math.floor(length / 2) + 6 * (length % 2);
+	};
+	AlphanumericData$1.prototype.getLength = function getLength() {
+		return this.data.length;
+	};
+	AlphanumericData$1.prototype.getBitsLength = function getBitsLength() {
+		return AlphanumericData$1.getBitsLength(this.data.length);
+	};
+	AlphanumericData$1.prototype.write = function write(bitBuffer) {
+		let i;
+		for (i = 0; i + 2 <= this.data.length; i += 2) {
+			let value = ALPHA_NUM_CHARS.indexOf(this.data[i]) * 45;
+			value += ALPHA_NUM_CHARS.indexOf(this.data[i + 1]);
+			bitBuffer.put(value, 11);
+		}
+		if (this.data.length % 2) bitBuffer.put(ALPHA_NUM_CHARS.indexOf(this.data[i]), 6);
+	};
+	module.exports = AlphanumericData$1;
+}));
+var require_byte_data = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Mode$3 = require_mode();
+	function ByteData$1(data) {
+		this.mode = Mode$3.BYTE;
+		if (typeof data === "string") this.data = new TextEncoder().encode(data);
+		else this.data = new Uint8Array(data);
+	}
+	ByteData$1.getBitsLength = function getBitsLength(length) {
+		return length * 8;
+	};
+	ByteData$1.prototype.getLength = function getLength() {
+		return this.data.length;
+	};
+	ByteData$1.prototype.getBitsLength = function getBitsLength() {
+		return ByteData$1.getBitsLength(this.data.length);
+	};
+	ByteData$1.prototype.write = function(bitBuffer) {
+		for (let i = 0, l = this.data.length; i < l; i++) bitBuffer.put(this.data[i], 8);
+	};
+	module.exports = ByteData$1;
+}));
+var require_kanji_data = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Mode$2 = require_mode();
+	var Utils$4 = require_utils$1();
+	function KanjiData$1(data) {
+		this.mode = Mode$2.KANJI;
+		this.data = data;
+	}
+	KanjiData$1.getBitsLength = function getBitsLength(length) {
+		return length * 13;
+	};
+	KanjiData$1.prototype.getLength = function getLength() {
+		return this.data.length;
+	};
+	KanjiData$1.prototype.getBitsLength = function getBitsLength() {
+		return KanjiData$1.getBitsLength(this.data.length);
+	};
+	KanjiData$1.prototype.write = function(bitBuffer) {
+		let i;
+		for (i = 0; i < this.data.length; i++) {
+			let value = Utils$4.toSJIS(this.data[i]);
+			if (value >= 33088 && value <= 40956) value -= 33088;
+			else if (value >= 57408 && value <= 60351) value -= 49472;
+			else throw new Error("Invalid SJIS character: " + this.data[i] + "\nMake sure your charset is UTF-8");
+			value = (value >>> 8 & 255) * 192 + (value & 255);
+			bitBuffer.put(value, 13);
+		}
+	};
+	module.exports = KanjiData$1;
+}));
+var require_dijkstra = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var dijkstra$1 = {
+		single_source_shortest_paths: function(graph, s, d) {
+			var predecessors = {};
+			var costs = {};
+			costs[s] = 0;
+			var open = dijkstra$1.PriorityQueue.make();
+			open.push(s, 0);
+			var closest, u, v, cost_of_s_to_u, adjacent_nodes, cost_of_e, cost_of_s_to_u_plus_cost_of_e, cost_of_s_to_v, first_visit;
+			while (!open.empty()) {
+				closest = open.pop();
+				u = closest.value;
+				cost_of_s_to_u = closest.cost;
+				adjacent_nodes = graph[u] || {};
+				for (v in adjacent_nodes) if (adjacent_nodes.hasOwnProperty(v)) {
+					cost_of_e = adjacent_nodes[v];
+					cost_of_s_to_u_plus_cost_of_e = cost_of_s_to_u + cost_of_e;
+					cost_of_s_to_v = costs[v];
+					first_visit = typeof costs[v] === "undefined";
+					if (first_visit || cost_of_s_to_v > cost_of_s_to_u_plus_cost_of_e) {
+						costs[v] = cost_of_s_to_u_plus_cost_of_e;
+						open.push(v, cost_of_s_to_u_plus_cost_of_e);
+						predecessors[v] = u;
+					}
+				}
+			}
+			if (typeof d !== "undefined" && typeof costs[d] === "undefined") {
+				var msg = [
+					"Could not find a path from ",
+					s,
+					" to ",
+					d,
+					"."
+				].join("");
+				throw new Error(msg);
+			}
+			return predecessors;
+		},
+		extract_shortest_path_from_predecessor_list: function(predecessors, d) {
+			var nodes = [];
+			var u = d;
+			while (u) {
+				nodes.push(u);
+				predecessors[u];
+				u = predecessors[u];
+			}
+			nodes.reverse();
+			return nodes;
+		},
+		find_path: function(graph, s, d) {
+			var predecessors = dijkstra$1.single_source_shortest_paths(graph, s, d);
+			return dijkstra$1.extract_shortest_path_from_predecessor_list(predecessors, d);
+		},
+		PriorityQueue: {
+			make: function(opts) {
+				var T = dijkstra$1.PriorityQueue, t = {}, key;
+				opts = opts || {};
+				for (key in T) if (T.hasOwnProperty(key)) t[key] = T[key];
+				t.queue = [];
+				t.sorter = opts.sorter || T.default_sorter;
+				return t;
+			},
+			default_sorter: function(a, b) {
+				return a.cost - b.cost;
+			},
+			push: function(value, cost) {
+				var item = {
+					value,
+					cost
+				};
+				this.queue.push(item);
+				this.queue.sort(this.sorter);
+			},
+			pop: function() {
+				return this.queue.shift();
+			},
+			empty: function() {
+				return this.queue.length === 0;
+			}
+		}
+	};
+	if (typeof module !== "undefined") module.exports = dijkstra$1;
+}));
+var require_segments = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var Mode$1 = require_mode();
+	var NumericData = require_numeric_data();
+	var AlphanumericData = require_alphanumeric_data();
+	var ByteData = require_byte_data();
+	var KanjiData = require_kanji_data();
+	var Regex = require_regex();
+	var Utils$3 = require_utils$1();
+	var dijkstra = require_dijkstra();
+	function getStringByteLength(str) {
+		return unescape(encodeURIComponent(str)).length;
+	}
+	function getSegments(regex, mode, str) {
+		const segments = [];
+		let result;
+		while ((result = regex.exec(str)) !== null) segments.push({
+			data: result[0],
+			index: result.index,
+			mode,
+			length: result[0].length
+		});
+		return segments;
+	}
+	function getSegmentsFromString(dataStr) {
+		const numSegs = getSegments(Regex.NUMERIC, Mode$1.NUMERIC, dataStr);
+		const alphaNumSegs = getSegments(Regex.ALPHANUMERIC, Mode$1.ALPHANUMERIC, dataStr);
+		let byteSegs;
+		let kanjiSegs;
+		if (Utils$3.isKanjiModeEnabled()) {
+			byteSegs = getSegments(Regex.BYTE, Mode$1.BYTE, dataStr);
+			kanjiSegs = getSegments(Regex.KANJI, Mode$1.KANJI, dataStr);
+		} else {
+			byteSegs = getSegments(Regex.BYTE_KANJI, Mode$1.BYTE, dataStr);
+			kanjiSegs = [];
+		}
+		return numSegs.concat(alphaNumSegs, byteSegs, kanjiSegs).sort(function(s1, s2) {
+			return s1.index - s2.index;
+		}).map(function(obj) {
+			return {
+				data: obj.data,
+				mode: obj.mode,
+				length: obj.length
+			};
+		});
+	}
+	function getSegmentBitsLength(length, mode) {
+		switch (mode) {
+			case Mode$1.NUMERIC: return NumericData.getBitsLength(length);
+			case Mode$1.ALPHANUMERIC: return AlphanumericData.getBitsLength(length);
+			case Mode$1.KANJI: return KanjiData.getBitsLength(length);
+			case Mode$1.BYTE: return ByteData.getBitsLength(length);
+		}
+	}
+	function mergeSegments(segs) {
+		return segs.reduce(function(acc, curr) {
+			const prevSeg = acc.length - 1 >= 0 ? acc[acc.length - 1] : null;
+			if (prevSeg && prevSeg.mode === curr.mode) {
+				acc[acc.length - 1].data += curr.data;
+				return acc;
+			}
+			acc.push(curr);
+			return acc;
+		}, []);
+	}
+	function buildNodes(segs) {
+		const nodes = [];
+		for (let i = 0; i < segs.length; i++) {
+			const seg = segs[i];
+			switch (seg.mode) {
+				case Mode$1.NUMERIC:
+					nodes.push([
+						seg,
+						{
+							data: seg.data,
+							mode: Mode$1.ALPHANUMERIC,
+							length: seg.length
+						},
+						{
+							data: seg.data,
+							mode: Mode$1.BYTE,
+							length: seg.length
+						}
+					]);
+					break;
+				case Mode$1.ALPHANUMERIC:
+					nodes.push([seg, {
+						data: seg.data,
+						mode: Mode$1.BYTE,
+						length: seg.length
+					}]);
+					break;
+				case Mode$1.KANJI:
+					nodes.push([seg, {
+						data: seg.data,
+						mode: Mode$1.BYTE,
+						length: getStringByteLength(seg.data)
+					}]);
+					break;
+				case Mode$1.BYTE: nodes.push([{
+					data: seg.data,
+					mode: Mode$1.BYTE,
+					length: getStringByteLength(seg.data)
+				}]);
+			}
+		}
+		return nodes;
+	}
+	function buildGraph(nodes, version) {
+		const table = {};
+		const graph = { start: {} };
+		let prevNodeIds = ["start"];
+		for (let i = 0; i < nodes.length; i++) {
+			const nodeGroup = nodes[i];
+			const currentNodeIds = [];
+			for (let j = 0; j < nodeGroup.length; j++) {
+				const node = nodeGroup[j];
+				const key = "" + i + j;
+				currentNodeIds.push(key);
+				table[key] = {
+					node,
+					lastCount: 0
+				};
+				graph[key] = {};
+				for (let n = 0; n < prevNodeIds.length; n++) {
+					const prevNodeId = prevNodeIds[n];
+					if (table[prevNodeId] && table[prevNodeId].node.mode === node.mode) {
+						graph[prevNodeId][key] = getSegmentBitsLength(table[prevNodeId].lastCount + node.length, node.mode) - getSegmentBitsLength(table[prevNodeId].lastCount, node.mode);
+						table[prevNodeId].lastCount += node.length;
+					} else {
+						if (table[prevNodeId]) table[prevNodeId].lastCount = node.length;
+						graph[prevNodeId][key] = getSegmentBitsLength(node.length, node.mode) + 4 + Mode$1.getCharCountIndicator(node.mode, version);
+					}
+				}
+			}
+			prevNodeIds = currentNodeIds;
+		}
+		for (let n = 0; n < prevNodeIds.length; n++) graph[prevNodeIds[n]].end = 0;
+		return {
+			map: graph,
+			table
+		};
+	}
+	function buildSingleSegment(data, modesHint) {
+		let mode;
+		const bestMode = Mode$1.getBestModeForData(data);
+		mode = Mode$1.from(modesHint, bestMode);
+		if (mode !== Mode$1.BYTE && mode.bit < bestMode.bit) throw new Error("\"" + data + "\" cannot be encoded with mode " + Mode$1.toString(mode) + ".\n Suggested mode is: " + Mode$1.toString(bestMode));
+		if (mode === Mode$1.KANJI && !Utils$3.isKanjiModeEnabled()) mode = Mode$1.BYTE;
+		switch (mode) {
+			case Mode$1.NUMERIC: return new NumericData(data);
+			case Mode$1.ALPHANUMERIC: return new AlphanumericData(data);
+			case Mode$1.KANJI: return new KanjiData(data);
+			case Mode$1.BYTE: return new ByteData(data);
+		}
+	}
+	exports.fromArray = function fromArray(array) {
+		return array.reduce(function(acc, seg) {
+			if (typeof seg === "string") acc.push(buildSingleSegment(seg, null));
+			else if (seg.data) acc.push(buildSingleSegment(seg.data, seg.mode));
+			return acc;
+		}, []);
+	};
+	exports.fromString = function fromString$2(data, version) {
+		const graph = buildGraph(buildNodes(getSegmentsFromString(data, Utils$3.isKanjiModeEnabled())), version);
+		const path = dijkstra.find_path(graph.map, "start", "end");
+		const optimizedSegs = [];
+		for (let i = 1; i < path.length - 1; i++) optimizedSegs.push(graph.table[path[i]].node);
+		return exports.fromArray(mergeSegments(optimizedSegs));
+	};
+	exports.rawSplit = function rawSplit(data) {
+		return exports.fromArray(getSegmentsFromString(data, Utils$3.isKanjiModeEnabled()));
+	};
+}));
+var require_qrcode = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var Utils$2 = require_utils$1();
+	var ECLevel = require_error_correction_level();
+	var BitBuffer = require_bit_buffer();
+	var BitMatrix = require_bit_matrix();
+	var AlignmentPattern = require_alignment_pattern();
+	var FinderPattern = require_finder_pattern();
+	var MaskPattern = require_mask_pattern();
+	var ECCode = require_error_correction_code();
+	var ReedSolomonEncoder = require_reed_solomon_encoder();
+	var Version = require_version();
+	var FormatInfo = require_format_info();
+	var Mode = require_mode();
+	var Segments = require_segments();
+	function setupFinderPattern(matrix, version) {
+		const size = matrix.size;
+		const pos = FinderPattern.getPositions(version);
+		for (let i = 0; i < pos.length; i++) {
+			const row = pos[i][0];
+			const col = pos[i][1];
+			for (let r = -1; r <= 7; r++) {
+				if (row + r <= -1 || size <= row + r) continue;
+				for (let c = -1; c <= 7; c++) {
+					if (col + c <= -1 || size <= col + c) continue;
+					if (r >= 0 && r <= 6 && (c === 0 || c === 6) || c >= 0 && c <= 6 && (r === 0 || r === 6) || r >= 2 && r <= 4 && c >= 2 && c <= 4) matrix.set(row + r, col + c, true, true);
+					else matrix.set(row + r, col + c, false, true);
+				}
+			}
+		}
+	}
+	function setupTimingPattern(matrix) {
+		const size = matrix.size;
+		for (let r = 8; r < size - 8; r++) {
+			const value = r % 2 === 0;
+			matrix.set(r, 6, value, true);
+			matrix.set(6, r, value, true);
+		}
+	}
+	function setupAlignmentPattern(matrix, version) {
+		const pos = AlignmentPattern.getPositions(version);
+		for (let i = 0; i < pos.length; i++) {
+			const row = pos[i][0];
+			const col = pos[i][1];
+			for (let r = -2; r <= 2; r++) for (let c = -2; c <= 2; c++) if (r === -2 || r === 2 || c === -2 || c === 2 || r === 0 && c === 0) matrix.set(row + r, col + c, true, true);
+			else matrix.set(row + r, col + c, false, true);
+		}
+	}
+	function setupVersionInfo(matrix, version) {
+		const size = matrix.size;
+		const bits = Version.getEncodedBits(version);
+		let row, col, mod;
+		for (let i = 0; i < 18; i++) {
+			row = Math.floor(i / 3);
+			col = i % 3 + size - 8 - 3;
+			mod = (bits >> i & 1) === 1;
+			matrix.set(row, col, mod, true);
+			matrix.set(col, row, mod, true);
+		}
+	}
+	function setupFormatInfo(matrix, errorCorrectionLevel, maskPattern) {
+		const size = matrix.size;
+		const bits = FormatInfo.getEncodedBits(errorCorrectionLevel, maskPattern);
+		let i, mod;
+		for (i = 0; i < 15; i++) {
+			mod = (bits >> i & 1) === 1;
+			if (i < 6) matrix.set(i, 8, mod, true);
+			else if (i < 8) matrix.set(i + 1, 8, mod, true);
+			else matrix.set(size - 15 + i, 8, mod, true);
+			if (i < 8) matrix.set(8, size - i - 1, mod, true);
+			else if (i < 9) matrix.set(8, 15 - i - 1 + 1, mod, true);
+			else matrix.set(8, 15 - i - 1, mod, true);
+		}
+		matrix.set(size - 8, 8, 1, true);
+	}
+	function setupData(matrix, data) {
+		const size = matrix.size;
+		let inc = -1;
+		let row = size - 1;
+		let bitIndex = 7;
+		let byteIndex = 0;
+		for (let col = size - 1; col > 0; col -= 2) {
+			if (col === 6) col--;
+			while (true) {
+				for (let c = 0; c < 2; c++) if (!matrix.isReserved(row, col - c)) {
+					let dark = false;
+					if (byteIndex < data.length) dark = (data[byteIndex] >>> bitIndex & 1) === 1;
+					matrix.set(row, col - c, dark);
+					bitIndex--;
+					if (bitIndex === -1) {
+						byteIndex++;
+						bitIndex = 7;
+					}
+				}
+				row += inc;
+				if (row < 0 || size <= row) {
+					row -= inc;
+					inc = -inc;
+					break;
+				}
+			}
+		}
+	}
+	function createData(version, errorCorrectionLevel, segments) {
+		const buffer = new BitBuffer();
+		segments.forEach(function(data) {
+			buffer.put(data.mode.bit, 4);
+			buffer.put(data.getLength(), Mode.getCharCountIndicator(data.mode, version));
+			data.write(buffer);
+		});
+		const dataTotalCodewordsBits = (Utils$2.getSymbolTotalCodewords(version) - ECCode.getTotalCodewordsCount(version, errorCorrectionLevel)) * 8;
+		if (buffer.getLengthInBits() + 4 <= dataTotalCodewordsBits) buffer.put(0, 4);
+		while (buffer.getLengthInBits() % 8 !== 0) buffer.putBit(0);
+		const remainingByte = (dataTotalCodewordsBits - buffer.getLengthInBits()) / 8;
+		for (let i = 0; i < remainingByte; i++) buffer.put(i % 2 ? 17 : 236, 8);
+		return createCodewords(buffer, version, errorCorrectionLevel);
+	}
+	function createCodewords(bitBuffer, version, errorCorrectionLevel) {
+		const totalCodewords = Utils$2.getSymbolTotalCodewords(version);
+		const dataTotalCodewords = totalCodewords - ECCode.getTotalCodewordsCount(version, errorCorrectionLevel);
+		const ecTotalBlocks = ECCode.getBlocksCount(version, errorCorrectionLevel);
+		const blocksInGroup1 = ecTotalBlocks - totalCodewords % ecTotalBlocks;
+		const totalCodewordsInGroup1 = Math.floor(totalCodewords / ecTotalBlocks);
+		const dataCodewordsInGroup1 = Math.floor(dataTotalCodewords / ecTotalBlocks);
+		const dataCodewordsInGroup2 = dataCodewordsInGroup1 + 1;
+		const ecCount = totalCodewordsInGroup1 - dataCodewordsInGroup1;
+		const rs = new ReedSolomonEncoder(ecCount);
+		let offset = 0;
+		const dcData = new Array(ecTotalBlocks);
+		const ecData = new Array(ecTotalBlocks);
+		let maxDataSize = 0;
+		const buffer = new Uint8Array(bitBuffer.buffer);
+		for (let b = 0; b < ecTotalBlocks; b++) {
+			const dataSize = b < blocksInGroup1 ? dataCodewordsInGroup1 : dataCodewordsInGroup2;
+			dcData[b] = buffer.slice(offset, offset + dataSize);
+			ecData[b] = rs.encode(dcData[b]);
+			offset += dataSize;
+			maxDataSize = Math.max(maxDataSize, dataSize);
+		}
+		const data = new Uint8Array(totalCodewords);
+		let index = 0;
+		let i, r;
+		for (i = 0; i < maxDataSize; i++) for (r = 0; r < ecTotalBlocks; r++) if (i < dcData[r].length) data[index++] = dcData[r][i];
+		for (i = 0; i < ecCount; i++) for (r = 0; r < ecTotalBlocks; r++) data[index++] = ecData[r][i];
+		return data;
+	}
+	function createSymbol(data, version, errorCorrectionLevel, maskPattern) {
+		let segments;
+		if (Array.isArray(data)) segments = Segments.fromArray(data);
+		else if (typeof data === "string") {
+			let estimatedVersion = version;
+			if (!estimatedVersion) {
+				const rawSegments = Segments.rawSplit(data);
+				estimatedVersion = Version.getBestVersionForData(rawSegments, errorCorrectionLevel);
+			}
+			segments = Segments.fromString(data, estimatedVersion || 40);
+		} else throw new Error("Invalid data");
+		const bestVersion = Version.getBestVersionForData(segments, errorCorrectionLevel);
+		if (!bestVersion) throw new Error("The amount of data is too big to be stored in a QR Code");
+		if (!version) version = bestVersion;
+		else if (version < bestVersion) throw new Error("\nThe chosen QR Code version cannot contain this amount of data.\nMinimum version required to store current data is: " + bestVersion + ".\n");
+		const dataBits = createData(version, errorCorrectionLevel, segments);
+		const modules = new BitMatrix(Utils$2.getSymbolSize(version));
+		setupFinderPattern(modules, version);
+		setupTimingPattern(modules);
+		setupAlignmentPattern(modules, version);
+		setupFormatInfo(modules, errorCorrectionLevel, 0);
+		if (version >= 7) setupVersionInfo(modules, version);
+		setupData(modules, dataBits);
+		if (isNaN(maskPattern)) maskPattern = MaskPattern.getBestMask(modules, setupFormatInfo.bind(null, modules, errorCorrectionLevel));
+		MaskPattern.applyMask(maskPattern, modules);
+		setupFormatInfo(modules, errorCorrectionLevel, maskPattern);
+		return {
+			modules,
+			version,
+			errorCorrectionLevel,
+			maskPattern,
+			segments
+		};
+	}
+	exports.create = function create(data, options) {
+		if (typeof data === "undefined" || data === "") throw new Error("No input text");
+		let errorCorrectionLevel = ECLevel.M;
+		let version;
+		let mask;
+		if (typeof options !== "undefined") {
+			errorCorrectionLevel = ECLevel.from(options.errorCorrectionLevel, ECLevel.M);
+			version = Version.from(options.version);
+			mask = MaskPattern.from(options.maskPattern);
+			if (options.toSJISFunc) Utils$2.setToSJISFunction(options.toSJISFunc);
+		}
+		return createSymbol(data, version, errorCorrectionLevel, mask);
+	};
+}));
+var require_utils = /* @__PURE__ */ __commonJSMin(((exports) => {
+	function hex2rgba(hex) {
+		if (typeof hex === "number") hex = hex.toString();
+		if (typeof hex !== "string") throw new Error("Color should be defined as hex string");
+		let hexCode = hex.slice().replace("#", "").split("");
+		if (hexCode.length < 3 || hexCode.length === 5 || hexCode.length > 8) throw new Error("Invalid hex color: " + hex);
+		if (hexCode.length === 3 || hexCode.length === 4) hexCode = Array.prototype.concat.apply([], hexCode.map(function(c) {
+			return [c, c];
+		}));
+		if (hexCode.length === 6) hexCode.push("F", "F");
+		const hexValue = parseInt(hexCode.join(""), 16);
+		return {
+			r: hexValue >> 24 & 255,
+			g: hexValue >> 16 & 255,
+			b: hexValue >> 8 & 255,
+			a: hexValue & 255,
+			hex: "#" + hexCode.slice(0, 6).join("")
+		};
+	}
+	exports.getOptions = function getOptions(options) {
+		if (!options) options = {};
+		if (!options.color) options.color = {};
+		const margin = typeof options.margin === "undefined" || options.margin === null || options.margin < 0 ? 4 : options.margin;
+		const width = options.width && options.width >= 21 ? options.width : void 0;
+		const scale = options.scale || 4;
+		return {
+			width,
+			scale: width ? 4 : scale,
+			margin,
+			color: {
+				dark: hex2rgba(options.color.dark || "#000000ff"),
+				light: hex2rgba(options.color.light || "#ffffffff")
+			},
+			type: options.type,
+			rendererOpts: options.rendererOpts || {}
+		};
+	};
+	exports.getScale = function getScale(qrSize, opts) {
+		return opts.width && opts.width >= qrSize + opts.margin * 2 ? opts.width / (qrSize + opts.margin * 2) : opts.scale;
+	};
+	exports.getImageWidth = function getImageWidth(qrSize, opts) {
+		const scale = exports.getScale(qrSize, opts);
+		return Math.floor((qrSize + opts.margin * 2) * scale);
+	};
+	exports.qrToImageData = function qrToImageData(imgData, qr, opts) {
+		const size = qr.modules.size;
+		const data = qr.modules.data;
+		const scale = exports.getScale(size, opts);
+		const symbolSize = Math.floor((size + opts.margin * 2) * scale);
+		const scaledMargin = opts.margin * scale;
+		const palette = [opts.color.light, opts.color.dark];
+		for (let i = 0; i < symbolSize; i++) for (let j = 0; j < symbolSize; j++) {
+			let posDst = (i * symbolSize + j) * 4;
+			let pxColor = opts.color.light;
+			if (i >= scaledMargin && j >= scaledMargin && i < symbolSize - scaledMargin && j < symbolSize - scaledMargin) {
+				const iSrc = Math.floor((i - scaledMargin) / scale);
+				const jSrc = Math.floor((j - scaledMargin) / scale);
+				pxColor = palette[data[iSrc * size + jSrc] ? 1 : 0];
+			}
+			imgData[posDst++] = pxColor.r;
+			imgData[posDst++] = pxColor.g;
+			imgData[posDst++] = pxColor.b;
+			imgData[posDst] = pxColor.a;
+		}
+	};
+}));
+var require_canvas = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var Utils$1 = require_utils();
+	function clearCanvas(ctx, canvas, size) {
+		ctx.clearRect(0, 0, canvas.width, canvas.height);
+		if (!canvas.style) canvas.style = {};
+		canvas.height = size;
+		canvas.width = size;
+		canvas.style.height = size + "px";
+		canvas.style.width = size + "px";
+	}
+	function getCanvasElement() {
+		try {
+			return document.createElement("canvas");
+		} catch (e) {
+			throw new Error("You need to specify a canvas element");
+		}
+	}
+	exports.render = function render(qrData, canvas, options) {
+		let opts = options;
+		let canvasEl = canvas;
+		if (typeof opts === "undefined" && (!canvas || !canvas.getContext)) {
+			opts = canvas;
+			canvas = void 0;
+		}
+		if (!canvas) canvasEl = getCanvasElement();
+		opts = Utils$1.getOptions(opts);
+		const size = Utils$1.getImageWidth(qrData.modules.size, opts);
+		const ctx = canvasEl.getContext("2d");
+		const image = ctx.createImageData(size, size);
+		Utils$1.qrToImageData(image.data, qrData, opts);
+		clearCanvas(ctx, canvasEl, size);
+		ctx.putImageData(image, 0, 0);
+		return canvasEl;
+	};
+	exports.renderToDataURL = function renderToDataURL(qrData, canvas, options) {
+		let opts = options;
+		if (typeof opts === "undefined" && (!canvas || !canvas.getContext)) {
+			opts = canvas;
+			canvas = void 0;
+		}
+		if (!opts) opts = {};
+		const canvasEl = exports.render(qrData, canvas, opts);
+		const type = opts.type || "image/png";
+		const rendererOpts = opts.rendererOpts || {};
+		return canvasEl.toDataURL(type, rendererOpts.quality);
+	};
+}));
+var require_svg_tag = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var Utils = require_utils();
+	function getColorAttrib(color, attrib) {
+		const alpha = color.a / 255;
+		const str = attrib + "=\"" + color.hex + "\"";
+		return alpha < 1 ? str + " " + attrib + "-opacity=\"" + alpha.toFixed(2).slice(1) + "\"" : str;
+	}
+	function svgCmd(cmd, x, y) {
+		let str = cmd + x;
+		if (typeof y !== "undefined") str += " " + y;
+		return str;
+	}
+	function qrToPath(data, size, margin) {
+		let path = "";
+		let moveBy = 0;
+		let newRow = false;
+		let lineLength = 0;
+		for (let i = 0; i < data.length; i++) {
+			const col = Math.floor(i % size);
+			const row = Math.floor(i / size);
+			if (!col && !newRow) newRow = true;
+			if (data[i]) {
+				lineLength++;
+				if (!(i > 0 && col > 0 && data[i - 1])) {
+					path += newRow ? svgCmd("M", col + margin, .5 + row + margin) : svgCmd("m", moveBy, 0);
+					moveBy = 0;
+					newRow = false;
+				}
+				if (!(col + 1 < size && data[i + 1])) {
+					path += svgCmd("h", lineLength);
+					lineLength = 0;
+				}
+			} else moveBy++;
+		}
+		return path;
+	}
+	exports.render = function render(qrData, options, cb) {
+		const opts = Utils.getOptions(options);
+		const size = qrData.modules.size;
+		const data = qrData.modules.data;
+		const qrcodesize = size + opts.margin * 2;
+		const bg = !opts.color.light.a ? "" : "<path " + getColorAttrib(opts.color.light, "fill") + " d=\"M0 0h" + qrcodesize + "v" + qrcodesize + "H0z\"/>";
+		const path = "<path " + getColorAttrib(opts.color.dark, "stroke") + " d=\"" + qrToPath(data, size, opts.margin) + "\"/>";
+		const viewBox = "viewBox=\"0 0 " + qrcodesize + " " + qrcodesize + "\"";
+		const svgTag = "<svg xmlns=\"http://www.w3.org/2000/svg\" " + (!opts.width ? "" : "width=\"" + opts.width + "\" height=\"" + opts.width + "\" ") + viewBox + " shape-rendering=\"crispEdges\">" + bg + path + "</svg>\n";
+		if (typeof cb === "function") cb(null, svgTag);
+		return svgTag;
+	};
+}));
+var import_browser = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports) => {
+	var canPromise = require_can_promise();
+	var QRCode = require_qrcode();
+	var CanvasRenderer = require_canvas();
+	var SvgRenderer = require_svg_tag();
+	function renderCanvas(renderFunc, canvas, text, opts, cb) {
+		const args = [].slice.call(arguments, 1);
+		const argsNum = args.length;
+		const isLastArgCb = typeof args[argsNum - 1] === "function";
+		if (!isLastArgCb && !canPromise()) throw new Error("Callback required as last argument");
+		if (isLastArgCb) {
+			if (argsNum < 2) throw new Error("Too few arguments provided");
+			if (argsNum === 2) {
+				cb = text;
+				text = canvas;
+				canvas = opts = void 0;
+			} else if (argsNum === 3) if (canvas.getContext && typeof cb === "undefined") {
+				cb = opts;
+				opts = void 0;
+			} else {
+				cb = opts;
+				opts = text;
+				text = canvas;
+				canvas = void 0;
+			}
+		} else {
+			if (argsNum < 1) throw new Error("Too few arguments provided");
+			if (argsNum === 1) {
+				text = canvas;
+				canvas = opts = void 0;
+			} else if (argsNum === 2 && !canvas.getContext) {
+				opts = text;
+				text = canvas;
+				canvas = void 0;
+			}
+			return new Promise(function(resolve, reject) {
+				try {
+					resolve(renderFunc(QRCode.create(text, opts), canvas, opts));
+				} catch (e) {
+					reject(e);
+				}
+			});
+		}
+		try {
+			const data = QRCode.create(text, opts);
+			cb(null, renderFunc(data, canvas, opts));
+		} catch (e) {
+			cb(e);
+		}
+	}
+	exports.create = QRCode.create;
+	exports.toCanvas = renderCanvas.bind(null, CanvasRenderer.render);
+	exports.toDataURL = renderCanvas.bind(null, CanvasRenderer.renderToDataURL);
+	exports.toString = renderCanvas.bind(null, function(data, _, opts) {
+		return SvgRenderer.render(data, opts);
+	});
+})))());
+const flQrCodeErrorCorrectionLevels = [
+	"L",
+	"M",
+	"Q",
+	"H"
+];
+const flQrCodeTypes = ["canvas", "svg"];
+const flQrCodeProps = {
+	value: {
+		type: String,
+		default: ""
+	},
+	size: {
+		type: Number,
+		default: 100
+	},
+	color: {
+		type: String,
+		default: "#000000"
+	},
+	backgroundColor: {
+		type: String,
+		default: "#ffffff"
+	},
+	padding: {
+		type: Number,
+		default: 12
+	},
+	errorCorrectionLevel: {
+		type: String,
+		default: "M",
+		validator: (value) => flQrCodeErrorCorrectionLevels.includes(value)
+	},
+	iconSrc: {
+		type: String,
+		default: ""
+	},
+	iconSize: {
+		type: Number,
+		default: 24
+	},
+	iconBackgroundColor: {
+		type: String,
+		default: "#ffffff"
+	},
+	iconBorderRadius: {
+		type: Number,
+		default: 4
+	},
+	type: {
+		type: String,
+		default: "canvas",
+		validator: (value) => flQrCodeTypes.includes(value)
+	}
+};
+var _hoisted_1 = ["src"];
+var qr_code_default = /* @__PURE__ */ defineComponent({
+	name: "FlQrCode",
+	inheritAttrs: false,
+	__name: "qr-code",
+	props: flQrCodeProps,
+	setup(__props) {
+		const props = __props;
+		const attrs = useAttrs();
+		const renderRef = ref(null);
+		const isMounted = ref(false);
+		const hasRendered = ref(false);
+		let renderToken = 0;
+		const resolvedSize = computed(() => Number.isFinite(props.size) && props.size > 0 ? Math.trunc(props.size) : 0);
+		const resolvedPadding = computed(() => Number.isFinite(props.padding) && props.padding >= 0 ? Math.trunc(props.padding) : -1);
+		const resolvedRenderSize = computed(() => resolvedSize.value - resolvedPadding.value * 2);
+		const resolvedIconSize = computed(() => Number.isFinite(props.iconSize) && props.iconSize > 0 ? Math.trunc(props.iconSize) : 0);
+		const rootStyle = computed(() => ({
+			width: `${resolvedSize.value}px`,
+			height: `${resolvedSize.value}px`,
+			position: "relative",
+			display: "inline-block",
+			overflow: "hidden",
+			backgroundColor: props.backgroundColor
+		}));
+		const renderStyle = computed(() => ({
+			position: "absolute",
+			inset: `${resolvedPadding.value}px`,
+			width: "auto",
+			height: "auto"
+		}));
+		const shouldShowIcon = computed(() => hasRendered.value && Boolean(props.iconSrc));
+		const iconWrapStyle = computed(() => ({
+			position: "absolute",
+			left: "50%",
+			top: "50%",
+			width: `${resolvedIconSize.value}px`,
+			height: `${resolvedIconSize.value}px`,
+			transform: "translate(-50%, -50%)",
+			overflow: "hidden",
+			borderRadius: `${props.iconBorderRadius}px`,
+			backgroundColor: props.iconBackgroundColor,
+			display: "flex",
+			alignItems: "center",
+			justifyContent: "center",
+			pointerEvents: "none"
+		}));
+		const iconImageStyle = computed(() => ({
+			width: "100%",
+			height: "100%",
+			display: "block",
+			objectFit: "cover"
+		}));
+		const clearRender = () => {
+			const container = renderRef.value;
+			if (!container) return;
+			container.innerHTML = "";
+			hasRendered.value = false;
+		};
+		const buildRenderOptions = () => ({
+			width: resolvedRenderSize.value,
+			margin: 0,
+			errorCorrectionLevel: props.errorCorrectionLevel,
+			color: {
+				dark: props.color,
+				light: props.backgroundColor
+			}
+		});
+		const renderCanvas$1 = async (token) => {
+			const container = renderRef.value;
+			if (!container) return;
+			container.innerHTML = "";
+			const canvas = document.createElement("canvas");
+			container.appendChild(canvas);
+			await import_browser.toCanvas(canvas, props.value, buildRenderOptions());
+			if (token !== renderToken) return;
+			hasRendered.value = true;
+		};
+		const renderSvg = async (token) => {
+			const container = renderRef.value;
+			if (!container) return;
+			const svg = await import_browser.toString(props.value, {
+				...buildRenderOptions(),
+				type: "svg"
+			});
+			if (token !== renderToken) return;
+			container.innerHTML = svg;
+			hasRendered.value = true;
+		};
+		const renderCurrent = async () => {
+			if (!isMounted.value) return;
+			const token = ++renderToken;
+			if (!renderRef.value) return;
+			clearRender();
+			if (!props.value) return;
+			if (resolvedSize.value <= 0) throw new RangeError("Invalid size");
+			if (resolvedPadding.value < 0) throw new RangeError("Invalid padding");
+			if (resolvedPadding.value * 2 >= resolvedSize.value) throw new RangeError("Padding is too large");
+			if (props.type === "canvas") await renderCanvas$1(token);
+			else await renderSvg(token);
+		};
+		watch(() => [
+			props.value,
+			props.size,
+			props.color,
+			props.backgroundColor,
+			props.padding,
+			props.errorCorrectionLevel,
+			props.type
+		], () => {
+			if (!isMounted.value) return;
+			renderCurrent();
+		}, { flush: "post" });
+		onMounted(() => {
+			isMounted.value = true;
+			renderCurrent();
+		});
+		onBeforeUnmount(() => {
+			renderToken += 1;
+			clearRender();
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", mergeProps({ class: "fl-qr-code" }, unref(attrs), {
+				style: rootStyle.value,
+				role: "img"
+			}), [createElementVNode("div", {
+				ref_key: "renderRef",
+				ref: renderRef,
+				class: "fl-qr-code__render",
+				style: normalizeStyle(renderStyle.value)
+			}, null, 4), shouldShowIcon.value ? (openBlock(), createElementBlock("div", {
+				key: 0,
+				class: "fl-qr-code__icon",
+				style: normalizeStyle(iconWrapStyle.value)
+			}, [createElementVNode("img", {
+				src: props.iconSrc,
+				alt: "",
+				class: "fl-qr-code__icon-image",
+				style: normalizeStyle(iconImageStyle.value)
+			}, null, 12, _hoisted_1)], 4)) : createCommentVNode("v-if", true)], 16);
+		};
+	}
+});
+export { qr_code_default as default };
+
+//# sourceMappingURL=qr-code.vue.mjs.map