@incodetech/web 0.0.0-dev-20260608-c8c427ca → 0.0.0-dev-20260609-11ba3e8a

package/dist/redirect-to-mobile/redirect-to-mobile.es.js

@@ -1,79 +1,93 @@
-import { t as e } from "../rolldown-runtime-CYMK-g2i.js";
-import { n as t, t as n } from "../i18n-Kzzvkz94.js";
-import { S as r, _ as i, h as a, l as o, p as s, v as c } from "../vendor-preact-D6SntenC.js";
-import { c as l, o as u } from "../hooks-MxHtZWTS.js";
-import { t as d } from "../incodeComponent-BoFhgK7G.js";
-import { r as f } from "../loadingIcon-BN5YRQUb.js";
-import { t as p } from "../incode-logo-DX016usY.js";
-import { n as m, t as h } from "../verifiedByIncode-DpbxzO0y.js";
-import { t as g } from "../transitionSpinner-Di3bOyOu.js";
-import { t as _ } from "../button-DcCUEn2n.js";
-import "../icons-9I5g9-_1.js";
-import { t as v } from "../successIcon-SlKgTSty.js";
-import { t as y } from "../autoFocusTitle-BpYdaSUM.js";
-import { r as b, t as x } from "../phoneInputComposed-CjAxk2Gj.js";
-import { t as S } from "../registerIncodeElement-BHWOwdSS.js";
-import { t as C } from "../snackbar-CQiiWO4p.js";
-import { t as w } from "../tabs-D7lGst3Q.js";
-import { createRedirectToMobileManager as T } from "@incodetech/core/redirect-to-mobile";
+import { t as __commonJSMin } from "../rolldown-runtime--E5BIlTp.js";
+import { n as useTranslation, t as Trans } from "../i18n-gTHArCl9.js";
+import { S as k, _ as y, h as q, l as A, p as d, v as u } from "../vendor-preact-BH7vOa2r.js";
+import { c as useManager, o as useModuleTerminalCallbacks } from "../hooks-BtgmGvba.js";
+import { t as IncodeComponent } from "../incodeComponent-CDJxFZvS.js";
+import { r as Spacer } from "../loadingIcon-DN62ugKs.js";
+import { t as incode_logo_default } from "../incode-logo-57XFniXU.js";
+import { n as usePageUiConfig, t as VerifiedByIncodeLogo } from "../verifiedByIncode-8QBn-kgZ.js";
+import { t as TransitionSpinner } from "../transitionSpinner-CWhGcr7c.js";
+import { t as Button } from "../button-B-qlr4iI.js";
+import "../icons-DKY3xDkf.js";
+import { t as SuccessIcon } from "../successIcon-rmzr-pxu.js";
+import { t as AutoFocusTitle } from "../autoFocusTitle-DM6PvgcP.js";
+import { r as getCountryByCallingCode, t as PhoneInputComposed } from "../phoneInputComposed-D_IabWKJ.js";
+import { t as registerIncodeElement } from "../registerIncodeElement-BJJGzVdq.js";
+import { t as Snackbar } from "../snackbar-Dz9crm39.js";
+import { t as Tabs } from "../tabs--UMd6eEB.js";
+import { createRedirectToMobileManager } from "@incodetech/core/redirect-to-mobile";
 //#region src/modules/redirect-to-mobile/redirectHeader.tsx
-var E = ({ logoSrc: e }) => {
-	let { t: n } = t();
-	return /* @__PURE__ */ c("header", {
+var RedirectHeader = ({ logoSrc }) => {
+	const { t } = useTranslation();
+	return /* @__PURE__ */ u("header", {
 		class: "IncodeRedirectHeader",
 		children: [
-			/* @__PURE__ */ c("div", {
+			/* @__PURE__ */ u("div", {
 				class: "IncodeRedirectLogoWrapper",
-				children: /* @__PURE__ */ c("img", {
-					src: e,
+				children: /* @__PURE__ */ u("img", {
+					src: logoSrc,
 					alt: "",
 					"aria-hidden": "true",
 					class: "IncodeRedirectLogo"
 				})
 			}),
-			/* @__PURE__ */ c(f, { size: 24 }),
-			/* @__PURE__ */ c(y, {
+			/* @__PURE__ */ u(Spacer, { size: 24 }),
+			/* @__PURE__ */ u(AutoFocusTitle, {
 				className: "IncodeRedirectTitle",
-				children: n("v2.redirectToMobile.title")
+				children: t("v2.redirectToMobile.title")
 			}),
-			/* @__PURE__ */ c(f, { size: 12 }),
-			/* @__PURE__ */ c("p", {
+			/* @__PURE__ */ u(Spacer, { size: 12 }),
+			/* @__PURE__ */ u("p", {
 				class: "IncodeRedirectSubtitle",
-				children: n("v2.redirectToMobile.subtitle")
+				children: t("v2.redirectToMobile.subtitle")
 			})
 		]
 	});
-}, D = ({ addContinueToDesktop: e, onContinueOnDesktop: n }) => {
-	let { t: r } = t();
-	return /* @__PURE__ */ c("footer", {
+};
+//#endregion
+//#region src/modules/redirect-to-mobile/redirectFooter.tsx
+var RedirectFooter = ({ addContinueToDesktop, onContinueOnDesktop }) => {
+	const { t } = useTranslation();
+	return /* @__PURE__ */ u("footer", {
 		class: "IncodeRedirectBottomNav",
-		children: [e ? /* @__PURE__ */ c("div", {
+		children: [addContinueToDesktop ? /* @__PURE__ */ u("div", {
 			class: "IncodeRedirectFooterContent",
-			children: [/* @__PURE__ */ c("span", {
+			children: [/* @__PURE__ */ u("span", {
 				class: "IncodeRedirectFooterContentText",
-				children: r("idv2.permissions.or")
-			}), /* @__PURE__ */ c(_, {
+				children: t("idv2.permissions.or")
+			}), /* @__PURE__ */ u(Button, {
 				variant: "secondary",
-				onClick: n,
-				children: r("redirect.continueOnDesktop")
+				onClick: onContinueOnDesktop,
+				children: t("redirect.continueOnDesktop")
 			})]
-		}) : null, /* @__PURE__ */ c(h, {})]
+		}) : null, /* @__PURE__ */ u(VerifiedByIncodeLogo, {})]
 	});
-}, O = ({ visible: e }) => {
-	let { t: n } = t();
-	return e ? /* @__PURE__ */ c("div", {
+};
+//#endregion
+//#region src/modules/redirect-to-mobile/resendToast.tsx
+var ResendToast = ({ visible }) => {
+	const { t } = useTranslation();
+	if (!visible) return null;
+	return /* @__PURE__ */ u("div", {
 		class: "IncodeRedirectToast",
-		children: /* @__PURE__ */ c(C, {
+		children: /* @__PURE__ */ u(Snackbar, {
 			variant: "positive",
-			children: n("redirect.linkResent")
+			children: t("redirect.linkResent")
 		})
-	}) : null;
-}, k = /* @__PURE__ */ e(((e, t) => {
-	t.exports = function() {
-		return typeof Promise == "function" && Promise.prototype && Promise.prototype.then;
+	});
+};
+//#endregion
+//#region ../../node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/can-promise.js
+var require_can_promise = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = function() {
+		return typeof Promise === "function" && Promise.prototype && Promise.prototype.then;
 	};
-})), A = /* @__PURE__ */ e(((e) => {
-	var t, n = [
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/core/utils.js
+var require_utils$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var toSJISFunction;
+	var CODEWORDS_COUNT = [
 		0,
 		26,
 		44,
@@ -116,109 +130,269 @@ var E = ({ logoSrc: e }) => {
 		3532,
 		3706
 	];
-	e.getSymbolSize = function(e) {
-		if (!e) throw Error("\"version\" cannot be null or undefined");
-		if (e < 1 || e > 40) throw Error("\"version\" should be in range from 1 to 40");
-		return e * 4 + 17;
-	}, e.getSymbolTotalCodewords = function(e) {
-		return n[e];
-	}, e.getBCHDigit = function(e) {
-		let t = 0;
-		for (; e !== 0;) t++, e >>>= 1;
-		return t;
-	}, e.setToSJISFunction = function(e) {
-		if (typeof e != "function") throw Error("\"toSJISFunc\" is not a valid function.");
-		t = e;
-	}, e.isKanjiModeEnabled = function() {
-		return t !== void 0;
-	}, e.toSJIS = function(e) {
-		return t(e);
-	};
-})), j = /* @__PURE__ */ e(((e) => {
-	e.L = { bit: 1 }, e.M = { bit: 0 }, e.Q = { bit: 3 }, e.H = { bit: 2 };
-	function t(t) {
-		if (typeof t != "string") throw Error("Param is not a string");
-		switch (t.toLowerCase()) {
+	/**
+	* Returns the QR Code size for the specified version
+	*
+	* @param  {Number} version QR Code version
+	* @return {Number}         size of QR code
+	*/
+	exports.getSymbolSize = function getSymbolSize(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;
+	};
+	/**
+	* Returns the total number of codewords used to store data and EC information.
+	*
+	* @param  {Number} version QR Code version
+	* @return {Number}         Data length in bits
+	*/
+	exports.getSymbolTotalCodewords = function getSymbolTotalCodewords(version) {
+		return CODEWORDS_COUNT[version];
+	};
+	/**
+	* Encode data with Bose-Chaudhuri-Hocquenghem
+	*
+	* @param  {Number} data Value to encode
+	* @return {Number}      Encoded value
+	*/
+	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) {
+		return toSJISFunction(kanji);
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/core/error-correction-level.js
+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(string) {
+		if (typeof string !== "string") throw new Error("Param is not a string");
+		switch (string.toLowerCase()) {
 			case "l":
-			case "low": return e.L;
+			case "low": return exports.L;
 			case "m":
-			case "medium": return e.M;
+			case "medium": return exports.M;
 			case "q":
-			case "quartile": return e.Q;
+			case "quartile": return exports.Q;
 			case "h":
-			case "high": return e.H;
-			default: throw Error("Unknown EC Level: " + t);
+			case "high": return exports.H;
+			default: throw new Error("Unknown EC Level: " + string);
 		}
 	}
-	e.isValid = function(e) {
-		return e && e.bit !== void 0 && e.bit >= 0 && e.bit < 4;
-	}, e.from = function(n, r) {
-		if (e.isValid(n)) return n;
+	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 t(n);
-		} catch {
-			return r;
+			return fromString(value);
+		} catch (e) {
+			return defaultValue;
 		}
 	};
-})), M = /* @__PURE__ */ e(((e, t) => {
-	function n() {
-		this.buffer = [], this.length = 0;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/core/bit-buffer.js
+var require_bit_buffer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function BitBuffer() {
+		this.buffer = [];
+		this.length = 0;
 	}
-	n.prototype = {
-		get: function(e) {
-			let t = Math.floor(e / 8);
-			return (this.buffer[t] >>> 7 - e % 8 & 1) == 1;
+	BitBuffer.prototype = {
+		get: function(index) {
+			const bufIndex = Math.floor(index / 8);
+			return (this.buffer[bufIndex] >>> 7 - index % 8 & 1) === 1;
 		},
-		put: function(e, t) {
-			for (let n = 0; n < t; n++) this.putBit((e >>> t - n - 1 & 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(e) {
-			let t = Math.floor(this.length / 8);
-			this.buffer.length <= t && this.buffer.push(0), e && (this.buffer[t] |= 128 >>> this.length % 8), 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++;
 		}
-	}, t.exports = n;
-})), ee = /* @__PURE__ */ e(((e, t) => {
-	function n(e) {
-		if (!e || e < 1) throw Error("BitMatrix size must be defined and greater than 0");
-		this.size = e, this.data = new Uint8Array(e * e), this.reservedBit = new Uint8Array(e * e);
+	};
+	module.exports = BitBuffer;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/core/bit-matrix.js
+var require_bit_matrix = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Helper class to handle QR Code symbol modules
+	*
+	* @param {Number} size Symbol size
+	*/
+	function BitMatrix(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);
 	}
-	n.prototype.set = function(e, t, n, r) {
-		let i = e * this.size + t;
-		this.data[i] = n, r && (this.reservedBit[i] = !0);
-	}, n.prototype.get = function(e, t) {
-		return this.data[e * this.size + t];
-	}, n.prototype.xor = function(e, t, n) {
-		this.data[e * this.size + t] ^= n;
-	}, n.prototype.isReserved = function(e, t) {
-		return this.reservedBit[e * this.size + t];
-	}, t.exports = n;
-})), te = /* @__PURE__ */ e(((e) => {
-	var t = A().getSymbolSize;
-	e.getRowColCoords = function(e) {
-		if (e === 1) return [];
-		let n = Math.floor(e / 7) + 2, r = t(e), i = r === 145 ? 26 : Math.ceil((r - 13) / (2 * n - 2)) * 2, a = [r - 7];
-		for (let e = 1; e < n - 1; e++) a[e] = a[e - 1] - i;
-		return a.push(6), a.reverse();
-	}, e.getPositions = function(t) {
-		let n = [], r = e.getRowColCoords(t), i = r.length;
-		for (let e = 0; e < i; e++) for (let t = 0; t < i; t++) e === 0 && t === 0 || e === 0 && t === i - 1 || e === i - 1 && t === 0 || n.push([r[e], r[t]]);
-		return n;
-	};
-})), ne = /* @__PURE__ */ e(((e) => {
-	var t = A().getSymbolSize, n = 7;
-	e.getPositions = function(e) {
-		let r = t(e);
+	/**
+	* Set bit value at specified location
+	* If reserved flag is set, this bit will be ignored during masking process
+	*
+	* @param {Number}  row
+	* @param {Number}  col
+	* @param {Boolean} value
+	* @param {Boolean} reserved
+	*/
+	BitMatrix.prototype.set = function(row, col, value, reserved) {
+		const index = row * this.size + col;
+		this.data[index] = value;
+		if (reserved) this.reservedBit[index] = true;
+	};
+	/**
+	* Returns bit value at specified location
+	*
+	* @param  {Number}  row
+	* @param  {Number}  col
+	* @return {Boolean}
+	*/
+	BitMatrix.prototype.get = function(row, col) {
+		return this.data[row * this.size + col];
+	};
+	/**
+	* Applies xor operator at specified location
+	* (used during masking process)
+	*
+	* @param {Number}  row
+	* @param {Number}  col
+	* @param {Boolean} value
+	*/
+	BitMatrix.prototype.xor = function(row, col, value) {
+		this.data[row * this.size + col] ^= value;
+	};
+	/**
+	* Check if bit at specified location is reserved
+	*
+	* @param {Number}   row
+	* @param {Number}   col
+	* @return {Boolean}
+	*/
+	BitMatrix.prototype.isReserved = function(row, col) {
+		return this.reservedBit[row * this.size + col];
+	};
+	module.exports = BitMatrix;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/core/alignment-pattern.js
+var require_alignment_pattern = /* @__PURE__ */ __commonJSMin(((exports) => {
+	/**
+	* Alignment pattern are fixed reference pattern in defined positions
+	* in a matrix symbology, which enables the decode software to re-synchronise
+	* the coordinate mapping of the image modules in the event of moderate amounts
+	* of distortion of the image.
+	*
+	* Alignment patterns are present only in QR Code symbols of version 2 or larger
+	* and their number depends on the symbol version.
+	*/
+	var getSymbolSize = require_utils$1().getSymbolSize;
+	/**
+	* Calculate the row/column coordinates of the center module of each alignment pattern
+	* for the specified QR Code version.
+	*
+	* The alignment patterns are positioned symmetrically on either side of the diagonal
+	* running from the top left corner of the symbol to the bottom right corner.
+	*
+	* Since positions are simmetrical only half of the coordinates are returned.
+	* Each item of the array will represent in turn the x and y coordinate.
+	* @see {@link getPositions}
+	*
+	* @param  {Number} version QR Code version
+	* @return {Array}          Array of coordinate
+	*/
+	exports.getRowColCoords = function getRowColCoords(version) {
+		if (version === 1) return [];
+		const posCount = Math.floor(version / 7) + 2;
+		const size = getSymbolSize(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();
+	};
+	/**
+	* Returns an array containing the positions of each alignment pattern.
+	* Each array's element represent the center point of the pattern as (x, y) coordinates
+	*
+	* Coordinates are calculated expanding the row/column coordinates returned by {@link getRowColCoords}
+	* and filtering out the items that overlaps with finder pattern
+	*
+	* @example
+	* For a Version 7 symbol {@link getRowColCoords} returns values 6, 22 and 38.
+	* The alignment patterns, therefore, are to be centered on (row, column)
+	* positions (6,22), (22,6), (22,22), (22,38), (38,22), (38,38).
+	* Note that the coordinates (6,6), (6,38), (38,6) are occupied by finder patterns
+	* and are not therefore used for alignment patterns.
+	*
+	* let pos = getPositions(7)
+	* // [[6,22], [22,6], [22,22], [22,38], [38,22], [38,38]]
+	*
+	* @param  {Number} version QR Code version
+	* @return {Array}          Array of coordinates
+	*/
+	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;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/core/finder-pattern.js
+var require_finder_pattern = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var getSymbolSize = require_utils$1().getSymbolSize;
+	var FINDER_PATTERN_SIZE = 7;
+	/**
+	* Returns an array containing the positions of each finder pattern.
+	* Each array's element represent the top-left point of the pattern as (x, y) coordinates
+	*
+	* @param  {Number} version QR Code version
+	* @return {Array}          Array of coordinates
+	*/
+	exports.getPositions = function getPositions(version) {
+		const size = getSymbolSize(version);
 		return [
 			[0, 0],
-			[r - n, 0],
-			[0, r - n]
+			[size - FINDER_PATTERN_SIZE, 0],
+			[0, size - FINDER_PATTERN_SIZE]
 		];
 	};
-})), N = /* @__PURE__ */ e(((e) => {
-	e.Patterns = {
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/core/mask-pattern.js
+var require_mask_pattern = /* @__PURE__ */ __commonJSMin(((exports) => {
+	/**
+	* Data mask pattern reference
+	* @type {Object}
+	*/
+	exports.Patterns = {
 		PATTERN000: 0,
 		PATTERN001: 1,
 		PATTERN010: 2,
@@ -228,73 +402,185 @@ var E = ({ logoSrc: e }) => {
 		PATTERN110: 6,
 		PATTERN111: 7
 	};
-	var t = {
+	/**
+	* Weighted penalty scores for the undesirable features
+	* @type {Object}
+	*/
+	var PenaltyScores = {
 		N1: 3,
 		N2: 3,
 		N3: 40,
 		N4: 10
 	};
-	e.isValid = function(e) {
-		return e != null && e !== "" && !isNaN(e) && e >= 0 && e <= 7;
-	}, e.from = function(t) {
-		return e.isValid(t) ? parseInt(t, 10) : void 0;
-	}, e.getPenaltyN1 = function(e) {
-		let n = e.size, r = 0, i = 0, a = 0, o = null, s = null;
-		for (let c = 0; c < n; c++) {
-			i = a = 0, o = s = null;
-			for (let l = 0; l < n; l++) {
-				let n = e.get(c, l);
-				n === o ? i++ : (i >= 5 && (r += t.N1 + (i - 5)), o = n, i = 1), n = e.get(l, c), n === s ? a++ : (a >= 5 && (r += t.N1 + (a - 5)), s = n, a = 1);
+	/**
+	* Check if mask pattern value is valid
+	*
+	* @param  {Number}  mask    Mask pattern
+	* @return {Boolean}         true if valid, false otherwise
+	*/
+	exports.isValid = function isValid(mask) {
+		return mask != null && mask !== "" && !isNaN(mask) && mask >= 0 && mask <= 7;
+	};
+	/**
+	* Returns mask pattern from a value.
+	* If value is not valid, returns undefined
+	*
+	* @param  {Number|String} value        Mask pattern value
+	* @return {Number}                     Valid mask pattern or undefined
+	*/
+	exports.from = function from(value) {
+		return exports.isValid(value) ? parseInt(value, 10) : void 0;
+	};
+	/**
+	* Find adjacent modules in row/column with the same color
+	* and assign a penalty value.
+	*
+	* Points: N1 + i
+	* i is the amount by which the number of adjacent modules of the same color exceeds 5
+	*/
+	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;
+				}
 			}
-			i >= 5 && (r += t.N1 + (i - 5)), a >= 5 && (r += t.N1 + (a - 5));
+			if (sameCountCol >= 5) points += PenaltyScores.N1 + (sameCountCol - 5);
+			if (sameCountRow >= 5) points += PenaltyScores.N1 + (sameCountRow - 5);
 		}
-		return r;
-	}, e.getPenaltyN2 = function(e) {
-		let n = e.size, r = 0;
-		for (let t = 0; t < n - 1; t++) for (let i = 0; i < n - 1; i++) {
-			let n = e.get(t, i) + e.get(t, i + 1) + e.get(t + 1, i) + e.get(t + 1, i + 1);
-			(n === 4 || n === 0) && r++;
+		return points;
+	};
+	/**
+	* Find 2x2 blocks with the same color and assign a penalty value
+	*
+	* Points: N2 * (m - 1) * (n - 1)
+	*/
+	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 r * t.N2;
-	}, e.getPenaltyN3 = function(e) {
-		let n = e.size, r = 0, i = 0, a = 0;
-		for (let t = 0; t < n; t++) {
-			i = a = 0;
-			for (let o = 0; o < n; o++) i = i << 1 & 2047 | e.get(t, o), o >= 10 && (i === 1488 || i === 93) && r++, a = a << 1 & 2047 | e.get(o, t), o >= 10 && (a === 1488 || a === 93) && r++;
+		return points * PenaltyScores.N2;
+	};
+	/**
+	* Find 1:1:3:1:1 ratio (dark:light:dark:light:dark) pattern in row/column,
+	* preceded or followed by light area 4 modules wide
+	*
+	* Points: N3 * number of pattern found
+	*/
+	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 r * t.N3;
-	}, e.getPenaltyN4 = function(e) {
-		let n = 0, r = e.data.length;
-		for (let t = 0; t < r; t++) n += e.data[t];
-		return Math.abs(Math.ceil(n * 100 / r / 5) - 10) * t.N4;
-	};
-	function n(t, n, r) {
-		switch (t) {
-			case e.Patterns.PATTERN000: return (n + r) % 2 == 0;
-			case e.Patterns.PATTERN001: return n % 2 == 0;
-			case e.Patterns.PATTERN010: return r % 3 == 0;
-			case e.Patterns.PATTERN011: return (n + r) % 3 == 0;
-			case e.Patterns.PATTERN100: return (Math.floor(n / 2) + Math.floor(r / 3)) % 2 == 0;
-			case e.Patterns.PATTERN101: return n * r % 2 + n * r % 3 == 0;
-			case e.Patterns.PATTERN110: return (n * r % 2 + n * r % 3) % 2 == 0;
-			case e.Patterns.PATTERN111: return (n * r % 3 + (n + r) % 2) % 2 == 0;
-			default: throw Error("bad maskPattern:" + t);
+		return points * PenaltyScores.N3;
+	};
+	/**
+	* Calculate proportion of dark modules in entire symbol
+	*
+	* Points: N4 * k
+	*
+	* k is the rating of the deviation of the proportion of dark modules
+	* in the symbol from 50% in steps of 5%
+	*/
+	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;
+	};
+	/**
+	* Return mask value at given position
+	*
+	* @param  {Number} maskPattern Pattern reference value
+	* @param  {Number} i           Row
+	* @param  {Number} j           Column
+	* @return {Boolean}            Mask value
+	*/
+	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);
 		}
 	}
-	e.applyMask = function(e, t) {
-		let r = t.size;
-		for (let i = 0; i < r; i++) for (let a = 0; a < r; a++) t.isReserved(a, i) || t.xor(a, i, n(e, a, i));
-	}, e.getBestMask = function(t, n) {
-		let r = Object.keys(e.Patterns).length, i = 0, a = Infinity;
-		for (let o = 0; o < r; o++) {
-			n(o), e.applyMask(o, t);
-			let r = e.getPenaltyN1(t) + e.getPenaltyN2(t) + e.getPenaltyN3(t) + e.getPenaltyN4(t);
-			e.applyMask(o, t), r < a && (a = r, i = o);
+	/**
+	* Apply a mask pattern to a BitMatrix
+	*
+	* @param  {Number}    pattern Pattern reference number
+	* @param  {BitMatrix} data    BitMatrix data
+	*/
+	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));
+		}
+	};
+	/**
+	* Returns the best mask pattern for data
+	*
+	* @param  {BitMatrix} data
+	* @return {Number} Mask pattern reference number
+	*/
+	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 i;
+		return bestPattern;
 	};
-})), P = /* @__PURE__ */ e(((e) => {
-	var t = j(), n = [
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/core/error-correction-code.js
+var require_error_correction_code = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var ECLevel = require_error_correction_level();
+	var EC_BLOCKS_TABLE = [
 		1,
 		1,
 		1,
@@ -455,7 +741,8 @@ var E = ({ logoSrc: e }) => {
 		49,
 		68,
 		81
-	], r = [
+	];
+	var EC_CODEWORDS_TABLE = [
 		7,
 		10,
 		13,
@@ -617,96 +904,226 @@ var E = ({ logoSrc: e }) => {
 		2040,
 		2430
 	];
-	e.getBlocksCount = function(e, r) {
-		switch (r) {
-			case t.L: return n[(e - 1) * 4 + 0];
-			case t.M: return n[(e - 1) * 4 + 1];
-			case t.Q: return n[(e - 1) * 4 + 2];
-			case t.H: return n[(e - 1) * 4 + 3];
+	/**
+	* Returns the number of error correction block that the QR Code should contain
+	* for the specified version and error correction level.
+	*
+	* @param  {Number} version              QR Code version
+	* @param  {Number} errorCorrectionLevel Error correction level
+	* @return {Number}                      Number of error correction blocks
+	*/
+	exports.getBlocksCount = function getBlocksCount(version, errorCorrectionLevel) {
+		switch (errorCorrectionLevel) {
+			case ECLevel.L: return EC_BLOCKS_TABLE[(version - 1) * 4 + 0];
+			case ECLevel.M: return EC_BLOCKS_TABLE[(version - 1) * 4 + 1];
+			case ECLevel.Q: return EC_BLOCKS_TABLE[(version - 1) * 4 + 2];
+			case ECLevel.H: return EC_BLOCKS_TABLE[(version - 1) * 4 + 3];
 			default: return;
 		}
-	}, e.getTotalCodewordsCount = function(e, n) {
-		switch (n) {
-			case t.L: return r[(e - 1) * 4 + 0];
-			case t.M: return r[(e - 1) * 4 + 1];
-			case t.Q: return r[(e - 1) * 4 + 2];
-			case t.H: return r[(e - 1) * 4 + 3];
+	};
+	/**
+	* Returns the number of error correction codewords to use for the specified
+	* version and error correction level.
+	*
+	* @param  {Number} version              QR Code version
+	* @param  {Number} errorCorrectionLevel Error correction level
+	* @return {Number}                      Number of error correction codewords
+	*/
+	exports.getTotalCodewordsCount = function getTotalCodewordsCount(version, errorCorrectionLevel) {
+		switch (errorCorrectionLevel) {
+			case ECLevel.L: return EC_CODEWORDS_TABLE[(version - 1) * 4 + 0];
+			case ECLevel.M: return EC_CODEWORDS_TABLE[(version - 1) * 4 + 1];
+			case ECLevel.Q: return EC_CODEWORDS_TABLE[(version - 1) * 4 + 2];
+			case ECLevel.H: return EC_CODEWORDS_TABLE[(version - 1) * 4 + 3];
 			default: return;
 		}
 	};
-})), F = /* @__PURE__ */ e(((e) => {
-	var t = new Uint8Array(512), n = new Uint8Array(256);
-	(function() {
-		let e = 1;
-		for (let r = 0; r < 255; r++) t[r] = e, n[e] = r, e <<= 1, e & 256 && (e ^= 285);
-		for (let e = 255; e < 512; e++) t[e] = t[e - 255];
-	})(), e.log = function(e) {
-		if (e < 1) throw Error("log(" + e + ")");
-		return n[e];
-	}, e.exp = function(e) {
-		return t[e];
-	}, e.mul = function(e, r) {
-		return e === 0 || r === 0 ? 0 : t[n[e] + n[r]];
-	};
-})), I = /* @__PURE__ */ e(((e) => {
-	var t = F();
-	e.mul = function(e, n) {
-		let r = new Uint8Array(e.length + n.length - 1);
-		for (let i = 0; i < e.length; i++) for (let a = 0; a < n.length; a++) r[i + a] ^= t.mul(e[i], n[a]);
-		return r;
-	}, e.mod = function(e, n) {
-		let r = new Uint8Array(e);
-		for (; r.length - n.length >= 0;) {
-			let e = r[0];
-			for (let i = 0; i < n.length; i++) r[i] ^= t.mul(n[i], e);
-			let i = 0;
-			for (; i < r.length && r[i] === 0;) i++;
-			r = r.slice(i);
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/core/galois-field.js
+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];
+	})();
+	/**
+	* Returns log value of n inside Galois Field
+	*
+	* @param  {Number} n
+	* @return {Number}
+	*/
+	exports.log = function log(n) {
+		if (n < 1) throw new Error("log(" + n + ")");
+		return LOG_TABLE[n];
+	};
+	/**
+	* Returns anti-log value of n inside Galois Field
+	*
+	* @param  {Number} n
+	* @return {Number}
+	*/
+	exports.exp = function exp(n) {
+		return EXP_TABLE[n];
+	};
+	/**
+	* Multiplies two number inside Galois Field
+	*
+	* @param  {Number} x
+	* @param  {Number} y
+	* @return {Number}
+	*/
+	exports.mul = function mul(x, y) {
+		if (x === 0 || y === 0) return 0;
+		return EXP_TABLE[LOG_TABLE[x] + LOG_TABLE[y]];
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/core/polynomial.js
+var require_polynomial = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var GF = require_galois_field();
+	/**
+	* Multiplies two polynomials inside Galois Field
+	*
+	* @param  {Uint8Array} p1 Polynomial
+	* @param  {Uint8Array} p2 Polynomial
+	* @return {Uint8Array}    Product of p1 and p2
+	*/
+	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;
+	};
+	/**
+	* Calculate the remainder of polynomials division
+	*
+	* @param  {Uint8Array} divident Polynomial
+	* @param  {Uint8Array} divisor  Polynomial
+	* @return {Uint8Array}          Remainder
+	*/
+	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 r;
-	}, e.generateECPolynomial = function(n) {
-		let r = new Uint8Array([1]);
-		for (let i = 0; i < n; i++) r = e.mul(r, new Uint8Array([1, t.exp(i)]));
-		return r;
-	};
-})), L = /* @__PURE__ */ e(((e, t) => {
-	var n = I();
-	function r(e) {
-		this.genPoly = void 0, this.degree = e, this.degree && this.initialize(this.degree);
+		return result;
+	};
+	/**
+	* Generate an irreducible generator polynomial of specified degree
+	* (used by Reed-Solomon encoder)
+	*
+	* @param  {Number} degree Degree of the generator polynomial
+	* @return {Uint8Array}    Buffer containing polynomial coefficients
+	*/
+	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;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/core/reed-solomon-encoder.js
+var require_reed_solomon_encoder = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Polynomial = require_polynomial();
+	function ReedSolomonEncoder(degree) {
+		this.genPoly = void 0;
+		this.degree = degree;
+		if (this.degree) this.initialize(this.degree);
 	}
-	r.prototype.initialize = function(e) {
-		this.degree = e, this.genPoly = n.generateECPolynomial(this.degree);
-	}, r.prototype.encode = function(e) {
-		if (!this.genPoly) throw Error("Encoder not initialized");
-		let t = new Uint8Array(e.length + this.degree);
-		t.set(e);
-		let r = n.mod(t, this.genPoly), i = this.degree - r.length;
-		if (i > 0) {
-			let e = new Uint8Array(this.degree);
-			return e.set(r, i), e;
+	/**
+	* Initialize the encoder.
+	* The input param should correspond to the number of error correction codewords.
+	*
+	* @param  {Number} degree
+	*/
+	ReedSolomonEncoder.prototype.initialize = function initialize(degree) {
+		this.degree = degree;
+		this.genPoly = Polynomial.generateECPolynomial(this.degree);
+	};
+	/**
+	* Encodes a chunk of data
+	*
+	* @param  {Uint8Array} data Buffer containing input data
+	* @return {Uint8Array}      Buffer containing encoded data
+	*/
+	ReedSolomonEncoder.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 r;
-	}, t.exports = r;
-})), R = /* @__PURE__ */ e(((e) => {
-	e.isValid = function(e) {
-		return !isNaN(e) && e >= 1 && e <= 40;
-	};
-})), z = /* @__PURE__ */ e(((e) => {
-	var t = "[0-9]+", n = "[A-Z $%*+\\-./:]+", r = "(?:[u3000-u303F]|[u3040-u309F]|[u30A0-u30FF]|[uFF00-uFFEF]|[u4E00-u9FAF]|[u2605-u2606]|[u2190-u2195]|u203B|[u2010u2015u2018u2019u2025u2026u201Cu201Du2225u2260]|[u0391-u0451]|[u00A7u00A8u00B1u00B4u00D7u00F7])+";
-	r = r.replace(/u/g, "\\u");
-	var i = "(?:(?![A-Z0-9 $%*+\\-./:]|" + r + ")(?:.|[\r\n]))+";
-	e.KANJI = new RegExp(r, "g"), e.BYTE_KANJI = /* @__PURE__ */ RegExp("[^A-Z0-9 $%*+\\-./:]+", "g"), e.BYTE = new RegExp(i, "g"), e.NUMERIC = new RegExp(t, "g"), e.ALPHANUMERIC = new RegExp(n, "g");
-	var a = RegExp("^" + r + "$"), o = RegExp("^" + t + "$"), s = /* @__PURE__ */ RegExp("^[A-Z0-9 $%*+\\-./:]+$");
-	e.testKanji = function(e) {
-		return a.test(e);
-	}, e.testNumeric = function(e) {
-		return o.test(e);
-	}, e.testAlphanumeric = function(e) {
-		return s.test(e);
-	};
-})), B = /* @__PURE__ */ e(((e) => {
-	var t = R(), n = z();
-	e.NUMERIC = {
+		return remainder;
+	};
+	module.exports = ReedSolomonEncoder;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/core/version-check.js
+var require_version_check = /* @__PURE__ */ __commonJSMin(((exports) => {
+	/**
+	* Check if QR Code version is valid
+	*
+	* @param  {Number}  version QR Code version
+	* @return {Boolean}         true if valid version, false otherwise
+	*/
+	exports.isValid = function isValid(version) {
+		return !isNaN(version) && version >= 1 && version <= 40;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/core/regex.js
+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 = /* @__PURE__ */ 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 = new RegExp("^" + kanji + "$");
+	var TEST_NUMERIC = 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);
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/core/mode.js
+var require_mode = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var VersionCheck = require_version_check();
+	var Regex = require_regex();
+	/**
+	* Numeric mode encodes data from the decimal digit set (0 - 9)
+	* (byte values 30HEX to 39HEX).
+	* Normally, 3 data characters are represented by 10 bits.
+	*
+	* @type {Object}
+	*/
+	exports.NUMERIC = {
 		id: "Numeric",
 		bit: 1,
 		ccBits: [
@@ -714,7 +1131,17 @@ var E = ({ logoSrc: e }) => {
 			12,
 			14
 		]
-	}, e.ALPHANUMERIC = {
+	};
+	/**
+	* Alphanumeric mode encodes data from a set of 45 characters,
+	* i.e. 10 numeric digits (0 - 9),
+	*      26 alphabetic characters (A - Z),
+	*   and 9 symbols (SP, $, %, *, +, -, ., /, :).
+	* Normally, two input characters are represented by 11 bits.
+	*
+	* @type {Object}
+	*/
+	exports.ALPHANUMERIC = {
 		id: "Alphanumeric",
 		bit: 2,
 		ccBits: [
@@ -722,7 +1149,13 @@ var E = ({ logoSrc: e }) => {
 			11,
 			13
 		]
-	}, e.BYTE = {
+	};
+	/**
+	* In byte mode, data is encoded at 8 bits per character.
+	*
+	* @type {Object}
+	*/
+	exports.BYTE = {
 		id: "Byte",
 		bit: 4,
 		ccBits: [
@@ -730,7 +1163,17 @@ var E = ({ logoSrc: e }) => {
 			16,
 			16
 		]
-	}, e.KANJI = {
+	};
+	/**
+	* The Kanji mode efficiently encodes Kanji characters in accordance with
+	* the Shift JIS system based on JIS X 0208.
+	* The Shift JIS values are shifted from the JIS X 0208 values.
+	* JIS X 0208 gives details of the shift coded representation.
+	* Each two-byte character value is compacted to a 13-bit binary codeword.
+	*
+	* @type {Object}
+	*/
+	exports.KANJI = {
 		id: "Kanji",
 		bit: 8,
 		ccBits: [
@@ -738,204 +1181,480 @@ var E = ({ logoSrc: e }) => {
 			10,
 			12
 		]
-	}, e.MIXED = { bit: -1 }, e.getCharCountIndicator = function(e, n) {
-		if (!e.ccBits) throw Error("Invalid mode: " + e);
-		if (!t.isValid(n)) throw Error("Invalid version: " + n);
-		return n >= 1 && n < 10 ? e.ccBits[0] : n < 27 ? e.ccBits[1] : e.ccBits[2];
-	}, e.getBestModeForData = function(t) {
-		return n.testNumeric(t) ? e.NUMERIC : n.testAlphanumeric(t) ? e.ALPHANUMERIC : n.testKanji(t) ? e.KANJI : e.BYTE;
-	}, e.toString = function(e) {
-		if (e && e.id) return e.id;
-		throw Error("Invalid mode");
-	}, e.isValid = function(e) {
-		return e && e.bit && e.ccBits;
-	};
-	function r(t) {
-		if (typeof t != "string") throw Error("Param is not a string");
-		switch (t.toLowerCase()) {
-			case "numeric": return e.NUMERIC;
-			case "alphanumeric": return e.ALPHANUMERIC;
-			case "kanji": return e.KANJI;
-			case "byte": return e.BYTE;
-			default: throw Error("Unknown mode: " + t);
+	};
+	/**
+	* Mixed mode will contain a sequences of data in a combination of any of
+	* the modes described above
+	*
+	* @type {Object}
+	*/
+	exports.MIXED = { bit: -1 };
+	/**
+	* Returns the number of bits needed to store the data length
+	* according to QR Code specifications.
+	*
+	* @param  {Mode}   mode    Data mode
+	* @param  {Number} version QR Code version
+	* @return {Number}         Number of bits
+	*/
+	exports.getCharCountIndicator = function getCharCountIndicator(mode, version) {
+		if (!mode.ccBits) throw new Error("Invalid mode: " + mode);
+		if (!VersionCheck.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];
+	};
+	/**
+	* Returns the most efficient mode to store the specified data
+	*
+	* @param  {String} dataStr Input data string
+	* @return {Mode}           Best mode
+	*/
+	exports.getBestModeForData = function getBestModeForData(dataStr) {
+		if (Regex.testNumeric(dataStr)) return exports.NUMERIC;
+		else if (Regex.testAlphanumeric(dataStr)) return exports.ALPHANUMERIC;
+		else if (Regex.testKanji(dataStr)) return exports.KANJI;
+		else return exports.BYTE;
+	};
+	/**
+	* Return mode name as string
+	*
+	* @param {Mode} mode Mode object
+	* @returns {String}  Mode name
+	*/
+	exports.toString = function toString(mode) {
+		if (mode && mode.id) return mode.id;
+		throw new Error("Invalid mode");
+	};
+	/**
+	* Check if input param is a valid mode object
+	*
+	* @param   {Mode}    mode Mode object
+	* @returns {Boolean} True if valid mode, false otherwise
+	*/
+	exports.isValid = function isValid(mode) {
+		return mode && mode.bit && mode.ccBits;
+	};
+	/**
+	* Get mode object from its name
+	*
+	* @param   {String} string Mode name
+	* @returns {Mode}          Mode object
+	*/
+	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);
 		}
 	}
-	e.from = function(t, n) {
-		if (e.isValid(t)) return t;
+	/**
+	* Returns mode from a value.
+	* If value is not a valid mode, returns defaultValue
+	*
+	* @param  {Mode|String} value        Encoding mode
+	* @param  {Mode}        defaultValue Fallback value
+	* @return {Mode}                     Encoding mode
+	*/
+	exports.from = function from(value, defaultValue) {
+		if (exports.isValid(value)) return value;
 		try {
-			return r(t);
-		} catch {
-			return n;
+			return fromString(value);
+		} catch (e) {
+			return defaultValue;
 		}
 	};
-})), V = /* @__PURE__ */ e(((e) => {
-	var t = A(), n = P(), r = j(), i = B(), a = R(), o = 7973, s = t.getBCHDigit(o);
-	function c(t, n, r) {
-		for (let i = 1; i <= 40; i++) if (n <= e.getCapacity(i, r, t)) return i;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/core/version.js
+var require_version = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var Utils = require_utils$1();
+	var ECCode = require_error_correction_code();
+	var ECLevel = require_error_correction_level();
+	var Mode = require_mode();
+	var VersionCheck = require_version_check();
+	var G18 = 7973;
+	var G18_BCH = Utils.getBCHDigit(G18);
+	function getBestVersionForDataLength(mode, length, errorCorrectionLevel) {
+		for (let currentVersion = 1; currentVersion <= 40; currentVersion++) if (length <= exports.getCapacity(currentVersion, errorCorrectionLevel, mode)) return currentVersion;
 	}
-	function l(e, t) {
-		return i.getCharCountIndicator(e, t) + 4;
+	function getReservedBitsCount(mode, version) {
+		return Mode.getCharCountIndicator(mode, version) + 4;
 	}
-	function u(e, t) {
-		let n = 0;
-		return e.forEach(function(e) {
-			let r = l(e.mode, t);
-			n += r + e.getBitsLength();
-		}), n;
+	function getTotalBitsFromDataArray(segments, version) {
+		let totalBits = 0;
+		segments.forEach(function(data) {
+			const reservedBits = getReservedBitsCount(data.mode, version);
+			totalBits += reservedBits + data.getBitsLength();
+		});
+		return totalBits;
 	}
-	function d(t, n) {
-		for (let r = 1; r <= 40; r++) if (u(t, r) <= e.getCapacity(r, n, i.MIXED)) return r;
+	function getBestVersionForMixedData(segments, errorCorrectionLevel) {
+		for (let currentVersion = 1; currentVersion <= 40; currentVersion++) if (getTotalBitsFromDataArray(segments, currentVersion) <= exports.getCapacity(currentVersion, errorCorrectionLevel, Mode.MIXED)) return currentVersion;
 	}
-	e.from = function(e, t) {
-		return a.isValid(e) ? parseInt(e, 10) : t;
-	}, e.getCapacity = function(e, r, o) {
-		if (!a.isValid(e)) throw Error("Invalid QR Code version");
-		o === void 0 && (o = i.BYTE);
-		let s = (t.getSymbolTotalCodewords(e) - n.getTotalCodewordsCount(e, r)) * 8;
-		if (o === i.MIXED) return s;
-		let c = s - l(o, e);
-		switch (o) {
-			case i.NUMERIC: return Math.floor(c / 10 * 3);
-			case i.ALPHANUMERIC: return Math.floor(c / 11 * 2);
-			case i.KANJI: return Math.floor(c / 13);
-			case i.BYTE:
-			default: return Math.floor(c / 8);
+	/**
+	* Returns version number from a value.
+	* If value is not a valid version, returns defaultValue
+	*
+	* @param  {Number|String} value        QR Code version
+	* @param  {Number}        defaultValue Fallback value
+	* @return {Number}                     QR Code version number
+	*/
+	exports.from = function from(value, defaultValue) {
+		if (VersionCheck.isValid(value)) return parseInt(value, 10);
+		return defaultValue;
+	};
+	/**
+	* Returns how much data can be stored with the specified QR code version
+	* and error correction level
+	*
+	* @param  {Number} version              QR Code version (1-40)
+	* @param  {Number} errorCorrectionLevel Error correction level
+	* @param  {Mode}   mode                 Data mode
+	* @return {Number}                      Quantity of storable data
+	*/
+	exports.getCapacity = function getCapacity(version, errorCorrectionLevel, mode) {
+		if (!VersionCheck.isValid(version)) throw new Error("Invalid QR Code version");
+		if (typeof mode === "undefined") mode = Mode.BYTE;
+		const dataTotalCodewordsBits = (Utils.getSymbolTotalCodewords(version) - ECCode.getTotalCodewordsCount(version, errorCorrectionLevel)) * 8;
+		if (mode === Mode.MIXED) return dataTotalCodewordsBits;
+		const usableBits = dataTotalCodewordsBits - getReservedBitsCount(mode, version);
+		switch (mode) {
+			case Mode.NUMERIC: return Math.floor(usableBits / 10 * 3);
+			case Mode.ALPHANUMERIC: return Math.floor(usableBits / 11 * 2);
+			case Mode.KANJI: return Math.floor(usableBits / 13);
+			case Mode.BYTE:
+			default: return Math.floor(usableBits / 8);
 		}
-	}, e.getBestVersionForData = function(e, t) {
-		let n, i = r.from(t, r.M);
-		if (Array.isArray(e)) {
-			if (e.length > 1) return d(e, i);
-			if (e.length === 0) return 1;
-			n = e[0];
-		} else n = e;
-		return c(n.mode, n.getLength(), i);
-	}, e.getEncodedBits = function(e) {
-		if (!a.isValid(e) || e < 7) throw Error("Invalid QR Code version");
-		let n = e << 12;
-		for (; t.getBCHDigit(n) - s >= 0;) n ^= o << t.getBCHDigit(n) - s;
-		return e << 12 | n;
-	};
-})), H = /* @__PURE__ */ e(((e) => {
-	var t = A(), n = 1335, r = 21522, i = t.getBCHDigit(n);
-	e.getEncodedBits = function(e, a) {
-		let o = e.bit << 3 | a, s = o << 10;
-		for (; t.getBCHDigit(s) - i >= 0;) s ^= n << t.getBCHDigit(s) - i;
-		return (o << 10 | s) ^ r;
-	};
-})), U = /* @__PURE__ */ e(((e, t) => {
-	var n = B();
-	function r(e) {
-		this.mode = n.NUMERIC, this.data = e.toString();
+	};
+	/**
+	* Returns the minimum version needed to contain the amount of data
+	*
+	* @param  {Segment} data                    Segment of data
+	* @param  {Number} [errorCorrectionLevel=H] Error correction level
+	* @param  {Mode} mode                       Data mode
+	* @return {Number}                          QR Code version
+	*/
+	exports.getBestVersionForData = function getBestVersionForData(data, errorCorrectionLevel) {
+		let seg;
+		const ecl = ECLevel.from(errorCorrectionLevel, ECLevel.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);
+	};
+	/**
+	* Returns version information with relative error correction bits
+	*
+	* The version information is included in QR Code symbols of version 7 or larger.
+	* It consists of an 18-bit sequence containing 6 data bits,
+	* with 12 error correction bits calculated using the (18, 6) Golay code.
+	*
+	* @param  {Number} version QR Code version
+	* @return {Number}         Encoded version info bits
+	*/
+	exports.getEncodedBits = function getEncodedBits(version) {
+		if (!VersionCheck.isValid(version) || version < 7) throw new Error("Invalid QR Code version");
+		let d = version << 12;
+		while (Utils.getBCHDigit(d) - G18_BCH >= 0) d ^= G18 << Utils.getBCHDigit(d) - G18_BCH;
+		return version << 12 | d;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/core/format-info.js
+var require_format_info = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var Utils = require_utils$1();
+	var G15 = 1335;
+	var G15_MASK = 21522;
+	var G15_BCH = Utils.getBCHDigit(G15);
+	/**
+	* Returns format information with relative error correction bits
+	*
+	* The format information is a 15-bit sequence containing 5 data bits,
+	* with 10 error correction bits calculated using the (15, 5) BCH code.
+	*
+	* @param  {Number} errorCorrectionLevel Error correction level
+	* @param  {Number} mask                 Mask pattern
+	* @return {Number}                      Encoded format information bits
+	*/
+	exports.getEncodedBits = function getEncodedBits(errorCorrectionLevel, mask) {
+		const data = errorCorrectionLevel.bit << 3 | mask;
+		let d = data << 10;
+		while (Utils.getBCHDigit(d) - G15_BCH >= 0) d ^= G15 << Utils.getBCHDigit(d) - G15_BCH;
+		return (data << 10 | d) ^ G15_MASK;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/core/numeric-data.js
+var require_numeric_data = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Mode = require_mode();
+	function NumericData(data) {
+		this.mode = Mode.NUMERIC;
+		this.data = data.toString();
 	}
-	r.getBitsLength = function(e) {
-		return 10 * Math.floor(e / 3) + (e % 3 ? e % 3 * 3 + 1 : 0);
-	}, r.prototype.getLength = function() {
+	NumericData.getBitsLength = function getBitsLength(length) {
+		return 10 * Math.floor(length / 3) + (length % 3 ? length % 3 * 3 + 1 : 0);
+	};
+	NumericData.prototype.getLength = function getLength() {
 		return this.data.length;
-	}, r.prototype.getBitsLength = function() {
-		return r.getBitsLength(this.data.length);
-	}, r.prototype.write = function(e) {
-		let t, n, r;
-		for (t = 0; t + 3 <= this.data.length; t += 3) n = this.data.substr(t, 3), r = parseInt(n, 10), e.put(r, 10);
-		let i = this.data.length - t;
-		i > 0 && (n = this.data.substr(t), r = parseInt(n, 10), e.put(r, i * 3 + 1));
-	}, t.exports = r;
-})), W = /* @__PURE__ */ e(((e, t) => {
-	var n = B(), r = /* @__PURE__ */ "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:".split("");
-	function i(e) {
-		this.mode = n.ALPHANUMERIC, this.data = e;
+	};
+	NumericData.prototype.getBitsLength = function getBitsLength() {
+		return NumericData.getBitsLength(this.data.length);
+	};
+	NumericData.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;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/core/alphanumeric-data.js
+var require_alphanumeric_data = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Mode = require_mode();
+	/**
+	* Array of characters available in alphanumeric mode
+	*
+	* As per QR Code specification, to each character
+	* is assigned a value from 0 to 44 which in this case coincides
+	* with the array index
+	*
+	* @type {Array}
+	*/
+	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(data) {
+		this.mode = Mode.ALPHANUMERIC;
+		this.data = data;
 	}
-	i.getBitsLength = function(e) {
-		return 11 * Math.floor(e / 2) + e % 2 * 6;
-	}, i.prototype.getLength = function() {
+	AlphanumericData.getBitsLength = function getBitsLength(length) {
+		return 11 * Math.floor(length / 2) + 6 * (length % 2);
+	};
+	AlphanumericData.prototype.getLength = function getLength() {
 		return this.data.length;
-	}, i.prototype.getBitsLength = function() {
-		return i.getBitsLength(this.data.length);
-	}, i.prototype.write = function(e) {
-		let t;
-		for (t = 0; t + 2 <= this.data.length; t += 2) {
-			let n = r.indexOf(this.data[t]) * 45;
-			n += r.indexOf(this.data[t + 1]), e.put(n, 11);
+	};
+	AlphanumericData.prototype.getBitsLength = function getBitsLength() {
+		return AlphanumericData.getBitsLength(this.data.length);
+	};
+	AlphanumericData.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);
 		}
-		this.data.length % 2 && e.put(r.indexOf(this.data[t]), 6);
-	}, t.exports = i;
-})), G = /* @__PURE__ */ e(((e, t) => {
-	var n = B();
-	function r(e) {
-		this.mode = n.BYTE, typeof e == "string" ? this.data = new TextEncoder().encode(e) : this.data = new Uint8Array(e);
+		if (this.data.length % 2) bitBuffer.put(ALPHA_NUM_CHARS.indexOf(this.data[i]), 6);
+	};
+	module.exports = AlphanumericData;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/core/byte-data.js
+var require_byte_data = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Mode = require_mode();
+	function ByteData(data) {
+		this.mode = Mode.BYTE;
+		if (typeof data === "string") this.data = new TextEncoder().encode(data);
+		else this.data = new Uint8Array(data);
 	}
-	r.getBitsLength = function(e) {
-		return e * 8;
-	}, r.prototype.getLength = function() {
+	ByteData.getBitsLength = function getBitsLength(length) {
+		return length * 8;
+	};
+	ByteData.prototype.getLength = function getLength() {
 		return this.data.length;
-	}, r.prototype.getBitsLength = function() {
-		return r.getBitsLength(this.data.length);
-	}, r.prototype.write = function(e) {
-		for (let t = 0, n = this.data.length; t < n; t++) e.put(this.data[t], 8);
-	}, t.exports = r;
-})), K = /* @__PURE__ */ e(((e, t) => {
-	var n = B(), r = A();
-	function i(e) {
-		this.mode = n.KANJI, this.data = e;
+	};
+	ByteData.prototype.getBitsLength = function getBitsLength() {
+		return ByteData.getBitsLength(this.data.length);
+	};
+	ByteData.prototype.write = function(bitBuffer) {
+		for (let i = 0, l = this.data.length; i < l; i++) bitBuffer.put(this.data[i], 8);
+	};
+	module.exports = ByteData;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/core/kanji-data.js
+var require_kanji_data = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Mode = require_mode();
+	var Utils = require_utils$1();
+	function KanjiData(data) {
+		this.mode = Mode.KANJI;
+		this.data = data;
 	}
-	i.getBitsLength = function(e) {
-		return e * 13;
-	}, i.prototype.getLength = function() {
+	KanjiData.getBitsLength = function getBitsLength(length) {
+		return length * 13;
+	};
+	KanjiData.prototype.getLength = function getLength() {
 		return this.data.length;
-	}, i.prototype.getBitsLength = function() {
-		return i.getBitsLength(this.data.length);
-	}, i.prototype.write = function(e) {
-		let t;
-		for (t = 0; t < this.data.length; t++) {
-			let n = r.toSJIS(this.data[t]);
-			if (n >= 33088 && n <= 40956) n -= 33088;
-			else if (n >= 57408 && n <= 60351) n -= 49472;
-			else throw Error("Invalid SJIS character: " + this.data[t] + "\nMake sure your charset is UTF-8");
-			n = (n >>> 8 & 255) * 192 + (n & 255), e.put(n, 13);
+	};
+	KanjiData.prototype.getBitsLength = function getBitsLength() {
+		return KanjiData.getBitsLength(this.data.length);
+	};
+	KanjiData.prototype.write = function(bitBuffer) {
+		let i;
+		for (i = 0; i < this.data.length; i++) {
+			let value = Utils.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);
 		}
-	}, t.exports = i;
-})), q = /* @__PURE__ */ e(((e, t) => {
-	var n = {
-		single_source_shortest_paths: function(e, t, r) {
-			var i = {}, a = {};
-			a[t] = 0;
-			var o = n.PriorityQueue.make();
-			o.push(t, 0);
-			for (var s, c, l, u, d, f, p, m, h; !o.empty();) for (l in s = o.pop(), c = s.value, u = s.cost, d = e[c] || {}, d) d.hasOwnProperty(l) && (f = d[l], p = u + f, m = a[l], h = a[l] === void 0, (h || m > p) && (a[l] = p, o.push(l, p), i[l] = c));
-			if (r !== void 0 && a[r] === void 0) {
-				var g = [
+	};
+	module.exports = KanjiData;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/dijkstrajs@1.0.3/node_modules/dijkstrajs/dijkstra.js
+var require_dijkstra = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/******************************************************************************
+	* Created 2008-08-19.
+	*
+	* Dijkstra path-finding functions. Adapted from the Dijkstar Python project.
+	*
+	* Copyright (C) 2008
+	*   Wyatt Baldwin <self@wyattbaldwin.com>
+	*   All rights reserved
+	*
+	* Licensed under the MIT license.
+	*
+	*   http://www.opensource.org/licenses/mit-license.php
+	*
+	* 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 dijkstra = {
+		single_source_shortest_paths: function(graph, s, d) {
+			var predecessors = {};
+			var costs = {};
+			costs[s] = 0;
+			var open = dijkstra.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 ",
-					t,
+					s,
 					" to ",
-					r,
+					d,
 					"."
 				].join("");
-				throw Error(g);
+				throw new Error(msg);
 			}
-			return i;
+			return predecessors;
 		},
-		extract_shortest_path_from_predecessor_list: function(e, t) {
-			for (var n = [], r = t; r;) n.push(r), e[r], r = e[r];
-			return n.reverse(), n;
+		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(e, t, r) {
-			var i = n.single_source_shortest_paths(e, t, r);
-			return n.extract_shortest_path_from_predecessor_list(i, r);
+		find_path: function(graph, s, d) {
+			var predecessors = dijkstra.single_source_shortest_paths(graph, s, d);
+			return dijkstra.extract_shortest_path_from_predecessor_list(predecessors, d);
 		},
 		PriorityQueue: {
-			make: function(e) {
-				var t = n.PriorityQueue, r = {}, i;
-				for (i in e ||= {}, t) t.hasOwnProperty(i) && (r[i] = t[i]);
-				return r.queue = [], r.sorter = e.sorter || t.default_sorter, r;
+			make: function(opts) {
+				var T = dijkstra.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(e, t) {
-				return e.cost - t.cost;
+			default_sorter: function(a, b) {
+				return a.cost - b.cost;
 			},
-			push: function(e, t) {
-				var n = {
-					value: e,
-					cost: t
+			push: function(value, cost) {
+				var item = {
+					value,
+					cost
 				};
-				this.queue.push(n), this.queue.sort(this.sorter);
+				this.queue.push(item);
+				this.queue.sort(this.sorter);
 			},
 			pop: function() {
 				return this.queue.shift();
@@ -945,585 +1664,1106 @@ var E = ({ logoSrc: e }) => {
 			}
 		}
 	};
-	t !== void 0 && (t.exports = n);
-})), J = /* @__PURE__ */ e(((e) => {
-	var t = B(), n = U(), r = W(), i = G(), a = K(), o = z(), s = A(), c = q();
-	function l(e) {
-		return unescape(encodeURIComponent(e)).length;
+	if (typeof module !== "undefined") module.exports = dijkstra;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/core/segments.js
+var require_segments = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var Mode = 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 = require_utils$1();
+	var dijkstra = require_dijkstra();
+	/**
+	* Returns UTF8 byte length
+	*
+	* @param  {String} str Input string
+	* @return {Number}     Number of byte
+	*/
+	function getStringByteLength(str) {
+		return unescape(encodeURIComponent(str)).length;
 	}
-	function u(e, t, n) {
-		let r = [], i;
-		for (; (i = e.exec(n)) !== null;) r.push({
-			data: i[0],
-			index: i.index,
-			mode: t,
-			length: i[0].length
+	/**
+	* Get a list of segments of the specified mode
+	* from a string
+	*
+	* @param  {Mode}   mode Segment mode
+	* @param  {String} str  String to process
+	* @return {Array}       Array of object with segments data
+	*/
+	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 r;
+		return segments;
 	}
-	function d(e) {
-		let n = u(o.NUMERIC, t.NUMERIC, e), r = u(o.ALPHANUMERIC, t.ALPHANUMERIC, e), i, a;
-		return s.isKanjiModeEnabled() ? (i = u(o.BYTE, t.BYTE, e), a = u(o.KANJI, t.KANJI, e)) : (i = u(o.BYTE_KANJI, t.BYTE, e), a = []), n.concat(r, i, a).sort(function(e, t) {
-			return e.index - t.index;
-		}).map(function(e) {
+	/**
+	* Extracts a series of segments with the appropriate
+	* modes from a string
+	*
+	* @param  {String} dataStr Input string
+	* @return {Array}          Array of object with segments data
+	*/
+	function getSegmentsFromString(dataStr) {
+		const numSegs = getSegments(Regex.NUMERIC, Mode.NUMERIC, dataStr);
+		const alphaNumSegs = getSegments(Regex.ALPHANUMERIC, Mode.ALPHANUMERIC, dataStr);
+		let byteSegs;
+		let kanjiSegs;
+		if (Utils.isKanjiModeEnabled()) {
+			byteSegs = getSegments(Regex.BYTE, Mode.BYTE, dataStr);
+			kanjiSegs = getSegments(Regex.KANJI, Mode.KANJI, dataStr);
+		} else {
+			byteSegs = getSegments(Regex.BYTE_KANJI, Mode.BYTE, dataStr);
+			kanjiSegs = [];
+		}
+		return numSegs.concat(alphaNumSegs, byteSegs, kanjiSegs).sort(function(s1, s2) {
+			return s1.index - s2.index;
+		}).map(function(obj) {
 			return {
-				data: e.data,
-				mode: e.mode,
-				length: e.length
+				data: obj.data,
+				mode: obj.mode,
+				length: obj.length
 			};
 		});
 	}
-	function f(e, o) {
-		switch (o) {
-			case t.NUMERIC: return n.getBitsLength(e);
-			case t.ALPHANUMERIC: return r.getBitsLength(e);
-			case t.KANJI: return a.getBitsLength(e);
-			case t.BYTE: return i.getBitsLength(e);
+	/**
+	* Returns how many bits are needed to encode a string of
+	* specified length with the specified mode
+	*
+	* @param  {Number} length String length
+	* @param  {Mode} mode     Segment mode
+	* @return {Number}        Bit length
+	*/
+	function getSegmentBitsLength(length, mode) {
+		switch (mode) {
+			case Mode.NUMERIC: return NumericData.getBitsLength(length);
+			case Mode.ALPHANUMERIC: return AlphanumericData.getBitsLength(length);
+			case Mode.KANJI: return KanjiData.getBitsLength(length);
+			case Mode.BYTE: return ByteData.getBitsLength(length);
 		}
 	}
-	function p(e) {
-		return e.reduce(function(e, t) {
-			let n = e.length - 1 >= 0 ? e[e.length - 1] : null;
-			return n && n.mode === t.mode ? (e[e.length - 1].data += t.data, e) : (e.push(t), e);
+	/**
+	* Merges adjacent segments which have the same mode
+	*
+	* @param  {Array} segs Array of object with segments data
+	* @return {Array}      Array of object with segments data
+	*/
+	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 m(e) {
-		let n = [];
-		for (let r = 0; r < e.length; r++) {
-			let i = e[r];
-			switch (i.mode) {
-				case t.NUMERIC:
-					n.push([
-						i,
+	/**
+	* Generates a list of all possible nodes combination which
+	* will be used to build a segments graph.
+	*
+	* Nodes are divided by groups. Each group will contain a list of all the modes
+	* in which is possible to encode the given text.
+	*
+	* For example the text '12345' can be encoded as Numeric, Alphanumeric or Byte.
+	* The group for '12345' will contain then 3 objects, one for each
+	* possible encoding mode.
+	*
+	* Each node represents a possible segment.
+	*
+	* @param  {Array} segs Array of object with segments data
+	* @return {Array}      Array of object with segments data
+	*/
+	function buildNodes(segs) {
+		const nodes = [];
+		for (let i = 0; i < segs.length; i++) {
+			const seg = segs[i];
+			switch (seg.mode) {
+				case Mode.NUMERIC:
+					nodes.push([
+						seg,
 						{
-							data: i.data,
-							mode: t.ALPHANUMERIC,
-							length: i.length
+							data: seg.data,
+							mode: Mode.ALPHANUMERIC,
+							length: seg.length
 						},
 						{
-							data: i.data,
-							mode: t.BYTE,
-							length: i.length
+							data: seg.data,
+							mode: Mode.BYTE,
+							length: seg.length
 						}
 					]);
 					break;
-				case t.ALPHANUMERIC:
-					n.push([i, {
-						data: i.data,
-						mode: t.BYTE,
-						length: i.length
+				case Mode.ALPHANUMERIC:
+					nodes.push([seg, {
+						data: seg.data,
+						mode: Mode.BYTE,
+						length: seg.length
 					}]);
 					break;
-				case t.KANJI:
-					n.push([i, {
-						data: i.data,
-						mode: t.BYTE,
-						length: l(i.data)
+				case Mode.KANJI:
+					nodes.push([seg, {
+						data: seg.data,
+						mode: Mode.BYTE,
+						length: getStringByteLength(seg.data)
 					}]);
 					break;
-				case t.BYTE: n.push([{
-					data: i.data,
-					mode: t.BYTE,
-					length: l(i.data)
+				case Mode.BYTE: nodes.push([{
+					data: seg.data,
+					mode: Mode.BYTE,
+					length: getStringByteLength(seg.data)
 				}]);
 			}
 		}
-		return n;
+		return nodes;
 	}
-	function h(e, n) {
-		let r = {}, i = { start: {} }, a = ["start"];
-		for (let o = 0; o < e.length; o++) {
-			let s = e[o], c = [];
-			for (let e = 0; e < s.length; e++) {
-				let l = s[e], u = "" + o + e;
-				c.push(u), r[u] = {
-					node: l,
+	/**
+	* Builds a graph from a list of nodes.
+	* All segments in each node group will be connected with all the segments of
+	* the next group and so on.
+	*
+	* At each connection will be assigned a weight depending on the
+	* segment's byte length.
+	*
+	* @param  {Array} nodes    Array of object with segments data
+	* @param  {Number} version QR Code version
+	* @return {Object}         Graph of all possible segments
+	*/
+	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
-				}, i[u] = {};
-				for (let e = 0; e < a.length; e++) {
-					let o = a[e];
-					r[o] && r[o].node.mode === l.mode ? (i[o][u] = f(r[o].lastCount + l.length, l.mode) - f(r[o].lastCount, l.mode), r[o].lastCount += l.length) : (r[o] && (r[o].lastCount = l.length), i[o][u] = f(l.length, l.mode) + 4 + t.getCharCountIndicator(l.mode, n));
+				};
+				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.getCharCountIndicator(node.mode, version);
+					}
 				}
 			}
-			a = c;
+			prevNodeIds = currentNodeIds;
 		}
-		for (let e = 0; e < a.length; e++) i[a[e]].end = 0;
+		for (let n = 0; n < prevNodeIds.length; n++) graph[prevNodeIds[n]].end = 0;
 		return {
-			map: i,
-			table: r
+			map: graph,
+			table
 		};
 	}
-	function g(e, o) {
-		let c, l = t.getBestModeForData(e);
-		if (c = t.from(o, l), c !== t.BYTE && c.bit < l.bit) throw Error("\"" + e + "\" cannot be encoded with mode " + t.toString(c) + ".\n Suggested mode is: " + t.toString(l));
-		switch (c === t.KANJI && !s.isKanjiModeEnabled() && (c = t.BYTE), c) {
-			case t.NUMERIC: return new n(e);
-			case t.ALPHANUMERIC: return new r(e);
-			case t.KANJI: return new a(e);
-			case t.BYTE: return new i(e);
+	/**
+	* Builds a segment from a specified data and mode.
+	* If a mode is not specified, the more suitable will be used.
+	*
+	* @param  {String} data             Input data
+	* @param  {Mode | String} modesHint Data mode
+	* @return {Segment}                 Segment
+	*/
+	function buildSingleSegment(data, modesHint) {
+		let mode;
+		const bestMode = Mode.getBestModeForData(data);
+		mode = Mode.from(modesHint, bestMode);
+		if (mode !== Mode.BYTE && mode.bit < bestMode.bit) throw new Error("\"" + data + "\" cannot be encoded with mode " + Mode.toString(mode) + ".\n Suggested mode is: " + Mode.toString(bestMode));
+		if (mode === Mode.KANJI && !Utils.isKanjiModeEnabled()) mode = Mode.BYTE;
+		switch (mode) {
+			case Mode.NUMERIC: return new NumericData(data);
+			case Mode.ALPHANUMERIC: return new AlphanumericData(data);
+			case Mode.KANJI: return new KanjiData(data);
+			case Mode.BYTE: return new ByteData(data);
 		}
 	}
-	e.fromArray = function(e) {
-		return e.reduce(function(e, t) {
-			return typeof t == "string" ? e.push(g(t, null)) : t.data && e.push(g(t.data, t.mode)), e;
+	/**
+	* Builds a list of segments from an array.
+	* Array can contain Strings or Objects with segment's info.
+	*
+	* For each item which is a string, will be generated a segment with the given
+	* string and the more appropriate encoding mode.
+	*
+	* For each item which is an object, will be generated a segment with the given
+	* data and mode.
+	* Objects must contain at least the property "data".
+	* If property "mode" is not present, the more suitable mode will be used.
+	*
+	* @param  {Array} array Array of objects with segments data
+	* @return {Array}       Array of Segments
+	*/
+	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;
 		}, []);
-	}, e.fromString = function(t, n) {
-		let r = h(m(d(t, s.isKanjiModeEnabled())), n), i = c.find_path(r.map, "start", "end"), a = [];
-		for (let e = 1; e < i.length - 1; e++) a.push(r.table[i[e]].node);
-		return e.fromArray(p(a));
-	}, e.rawSplit = function(t) {
-		return e.fromArray(d(t, s.isKanjiModeEnabled()));
-	};
-})), Y = /* @__PURE__ */ e(((e) => {
-	var t = A(), n = j(), r = M(), i = ee(), a = te(), o = ne(), s = N(), c = P(), l = L(), u = V(), d = H(), f = B(), p = J();
-	function m(e, t) {
-		let n = e.size, r = o.getPositions(t);
-		for (let t = 0; t < r.length; t++) {
-			let i = r[t][0], a = r[t][1];
-			for (let t = -1; t <= 7; t++) if (!(i + t <= -1 || n <= i + t)) for (let r = -1; r <= 7; r++) a + r <= -1 || n <= a + r || (t >= 0 && t <= 6 && (r === 0 || r === 6) || r >= 0 && r <= 6 && (t === 0 || t === 6) || t >= 2 && t <= 4 && r >= 2 && r <= 4 ? e.set(i + t, a + r, !0, !0) : e.set(i + t, a + r, !1, !0));
+	};
+	/**
+	* Builds an optimized sequence of segments from a string,
+	* which will produce the shortest possible bitstream.
+	*
+	* @param  {String} data    Input string
+	* @param  {Number} version QR Code version
+	* @return {Array}          Array of segments
+	*/
+	exports.fromString = function fromString(data, version) {
+		const graph = buildGraph(buildNodes(getSegmentsFromString(data, Utils.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));
+	};
+	/**
+	* Splits a string in various segments with the modes which
+	* best represent their content.
+	* The produced segments are far from being optimized.
+	* The output of this function is only used to estimate a QR Code version
+	* which may contain the data.
+	*
+	* @param  {string} data Input string
+	* @return {Array}       Array of segments
+	*/
+	exports.rawSplit = function rawSplit(data) {
+		return exports.fromArray(getSegmentsFromString(data, Utils.isKanjiModeEnabled()));
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/core/qrcode.js
+var require_qrcode = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var Utils = 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();
+	/**
+	* QRCode for JavaScript
+	*
+	* modified by Ryan Day for nodejs support
+	* Copyright (c) 2011 Ryan Day
+	*
+	* Licensed under the MIT license:
+	*   http://www.opensource.org/licenses/mit-license.php
+	*
+	//---------------------------------------------------------------------
+	// QRCode for JavaScript
+	//
+	// Copyright (c) 2009 Kazuhiko Arase
+	//
+	// URL: http://www.d-project.com/
+	//
+	// Licensed under the MIT license:
+	//   http://www.opensource.org/licenses/mit-license.php
+	//
+	// The word "QR Code" is registered trademark of
+	// DENSO WAVE INCORPORATED
+	//   http://www.denso-wave.com/qrcode/faqpatent-e.html
+	//
+	//---------------------------------------------------------------------
+	*/
+	/**
+	* Add finder patterns bits to matrix
+	*
+	* @param  {BitMatrix} matrix  Modules matrix
+	* @param  {Number}    version QR Code version
+	*/
+	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 h(e) {
-		let t = e.size;
-		for (let n = 8; n < t - 8; n++) {
-			let t = n % 2 == 0;
-			e.set(n, 6, t, !0), e.set(6, n, t, !0);
+	/**
+	* Add timing pattern bits to matrix
+	*
+	* Note: this function must be called before {@link setupAlignmentPattern}
+	*
+	* @param  {BitMatrix} matrix Modules matrix
+	*/
+	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 g(e, t) {
-		let n = a.getPositions(t);
-		for (let t = 0; t < n.length; t++) {
-			let r = n[t][0], i = n[t][1];
-			for (let t = -2; t <= 2; t++) for (let n = -2; n <= 2; n++) t === -2 || t === 2 || n === -2 || n === 2 || t === 0 && n === 0 ? e.set(r + t, i + n, !0, !0) : e.set(r + t, i + n, !1, !0);
+	/**
+	* Add alignment patterns bits to matrix
+	*
+	* Note: this function must be called after {@link setupTimingPattern}
+	*
+	* @param  {BitMatrix} matrix  Modules matrix
+	* @param  {Number}    version QR Code version
+	*/
+	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 _(e, t) {
-		let n = e.size, r = u.getEncodedBits(t), i, a, o;
-		for (let t = 0; t < 18; t++) i = Math.floor(t / 3), a = t % 3 + n - 8 - 3, o = (r >> t & 1) == 1, e.set(i, a, o, !0), e.set(a, i, o, !0);
+	/**
+	* Add version info bits to matrix
+	*
+	* @param  {BitMatrix} matrix  Modules matrix
+	* @param  {Number}    version QR Code version
+	*/
+	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 v(e, t, n) {
-		let r = e.size, i = d.getEncodedBits(t, n), a, o;
-		for (a = 0; a < 15; a++) o = (i >> a & 1) == 1, a < 6 ? e.set(a, 8, o, !0) : a < 8 ? e.set(a + 1, 8, o, !0) : e.set(r - 15 + a, 8, o, !0), a < 8 ? e.set(8, r - a - 1, o, !0) : a < 9 ? e.set(8, 15 - a - 1 + 1, o, !0) : e.set(8, 15 - a - 1, o, !0);
-		e.set(r - 8, 8, 1, !0);
+	/**
+	* Add format info bits to matrix
+	*
+	* @param  {BitMatrix} matrix               Modules matrix
+	* @param  {ErrorCorrectionLevel}    errorCorrectionLevel Error correction level
+	* @param  {Number}    maskPattern          Mask pattern reference value
+	*/
+	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 y(e, t) {
-		let n = e.size, r = -1, i = n - 1, a = 7, o = 0;
-		for (let s = n - 1; s > 0; s -= 2) for (s === 6 && s--;;) {
-			for (let n = 0; n < 2; n++) if (!e.isReserved(i, s - n)) {
-				let r = !1;
-				o < t.length && (r = (t[o] >>> a & 1) == 1), e.set(i, s - n, r), a--, a === -1 && (o++, a = 7);
-			}
-			if (i += r, i < 0 || n <= i) {
-				i -= r, r = -r;
-				break;
+	/**
+	* Add encoded data bits to matrix
+	*
+	* @param  {BitMatrix}  matrix Modules matrix
+	* @param  {Uint8Array} data   Data codewords
+	*/
+	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 b(e, n, i) {
-		let a = new r();
-		i.forEach(function(t) {
-			a.put(t.mode.bit, 4), a.put(t.getLength(), f.getCharCountIndicator(t.mode, e)), t.write(a);
+	/**
+	* Create encoded codewords from data input
+	*
+	* @param  {Number}   version              QR Code version
+	* @param  {ErrorCorrectionLevel}   errorCorrectionLevel Error correction level
+	* @param  {ByteData} data                 Data input
+	* @return {Uint8Array}                    Buffer containing encoded codewords
+	*/
+	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);
 		});
-		let o = (t.getSymbolTotalCodewords(e) - c.getTotalCodewordsCount(e, n)) * 8;
-		for (a.getLengthInBits() + 4 <= o && a.put(0, 4); a.getLengthInBits() % 8 != 0;) a.putBit(0);
-		let s = (o - a.getLengthInBits()) / 8;
-		for (let e = 0; e < s; e++) a.put(e % 2 ? 17 : 236, 8);
-		return x(a, e, n);
+		const dataTotalCodewordsBits = (Utils.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 x(e, n, r) {
-		let i = t.getSymbolTotalCodewords(n), a = i - c.getTotalCodewordsCount(n, r), o = c.getBlocksCount(n, r), s = o - i % o, u = Math.floor(i / o), d = Math.floor(a / o), f = d + 1, p = u - d, m = new l(p), h = 0, g = Array(o), _ = Array(o), v = 0, y = new Uint8Array(e.buffer);
-		for (let e = 0; e < o; e++) {
-			let t = e < s ? d : f;
-			g[e] = y.slice(h, h + t), _[e] = m.encode(g[e]), h += t, v = Math.max(v, t);
+	/**
+	* Encode input data with Reed-Solomon and return codewords with
+	* relative error correction bits
+	*
+	* @param  {BitBuffer} bitBuffer            Data to encode
+	* @param  {Number}    version              QR Code version
+	* @param  {ErrorCorrectionLevel} errorCorrectionLevel Error correction level
+	* @return {Uint8Array}                     Buffer containing encoded codewords
+	*/
+	function createCodewords(bitBuffer, version, errorCorrectionLevel) {
+		const totalCodewords = Utils.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);
 		}
-		let b = new Uint8Array(i), x = 0, S, C;
-		for (S = 0; S < v; S++) for (C = 0; C < o; C++) S < g[C].length && (b[x++] = g[C][S]);
-		for (S = 0; S < p; S++) for (C = 0; C < o; C++) b[x++] = _[C][S];
-		return b;
+		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 S(e, n, r, a) {
-		let o;
-		if (Array.isArray(e)) o = p.fromArray(e);
-		else if (typeof e == "string") {
-			let t = n;
-			if (!t) {
-				let n = p.rawSplit(e);
-				t = u.getBestVersionForData(n, r);
+	/**
+	* Build QR Code symbol
+	*
+	* @param  {String} data                 Input string
+	* @param  {Number} version              QR Code version
+	* @param  {ErrorCorretionLevel} errorCorrectionLevel Error level
+	* @param  {MaskPattern} maskPattern     Mask pattern
+	* @return {Object}                      Object containing symbol 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);
 			}
-			o = p.fromString(e, t || 40);
-		} else throw Error("Invalid data");
-		let c = u.getBestVersionForData(o, r);
-		if (!c) throw Error("The amount of data is too big to be stored in a QR Code");
-		if (!n) n = c;
-		else if (n < c) throw Error("\nThe chosen QR Code version cannot contain this amount of data.\nMinimum version required to store current data is: " + c + ".\n");
-		let l = b(n, r, o), d = new i(t.getSymbolSize(n));
-		return m(d, n), h(d), g(d, n), v(d, r, 0), n >= 7 && _(d, n), y(d, l), isNaN(a) && (a = s.getBestMask(d, v.bind(null, d, r))), s.applyMask(a, d), v(d, r, a), {
-			modules: d,
-			version: n,
-			errorCorrectionLevel: r,
-			maskPattern: a,
-			segments: o
+			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.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
 		};
 	}
-	e.create = function(e, r) {
-		if (e === void 0 || e === "") throw Error("No input text");
-		let i = n.M, a, o;
-		return r !== void 0 && (i = n.from(r.errorCorrectionLevel, n.M), a = u.from(r.version), o = s.from(r.maskPattern), r.toSJISFunc && t.setToSJISFunction(r.toSJISFunc)), S(e, a, i, o);
-	};
-})), X = /* @__PURE__ */ e(((e) => {
-	function t(e) {
-		if (typeof e == "number" && (e = e.toString()), typeof e != "string") throw Error("Color should be defined as hex string");
-		let t = e.slice().replace("#", "").split("");
-		if (t.length < 3 || t.length === 5 || t.length > 8) throw Error("Invalid hex color: " + e);
-		(t.length === 3 || t.length === 4) && (t = Array.prototype.concat.apply([], t.map(function(e) {
-			return [e, e];
-		}))), t.length === 6 && t.push("F", "F");
-		let n = parseInt(t.join(""), 16);
+	/**
+	* QR Code
+	*
+	* @param {String | Array} data                 Input data
+	* @param {Object} options                      Optional configurations
+	* @param {Number} options.version              QR Code version
+	* @param {String} options.errorCorrectionLevel Error correction level
+	* @param {Function} options.toSJISFunc         Helper func to convert utf8 to sjis
+	*/
+	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.setToSJISFunction(options.toSJISFunc);
+		}
+		return createSymbol(data, version, errorCorrectionLevel, mask);
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/renderer/utils.js
+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: n >> 24 & 255,
-			g: n >> 16 & 255,
-			b: n >> 8 & 255,
-			a: n & 255,
-			hex: "#" + t.slice(0, 6).join("")
+			r: hexValue >> 24 & 255,
+			g: hexValue >> 16 & 255,
+			b: hexValue >> 8 & 255,
+			a: hexValue & 255,
+			hex: "#" + hexCode.slice(0, 6).join("")
 		};
 	}
-	e.getOptions = function(e) {
-		e ||= {}, e.color ||= {};
-		let n = e.margin === void 0 || e.margin === null || e.margin < 0 ? 4 : e.margin, r = e.width && e.width >= 21 ? e.width : void 0, i = e.scale || 4;
+	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: r,
-			scale: r ? 4 : i,
-			margin: n,
+			width,
+			scale: width ? 4 : scale,
+			margin,
 			color: {
-				dark: t(e.color.dark || "#000000ff"),
-				light: t(e.color.light || "#ffffffff")
+				dark: hex2rgba(options.color.dark || "#000000ff"),
+				light: hex2rgba(options.color.light || "#ffffffff")
 			},
-			type: e.type,
-			rendererOpts: e.rendererOpts || {}
+			type: options.type,
+			rendererOpts: options.rendererOpts || {}
 		};
-	}, e.getScale = function(e, t) {
-		return t.width && t.width >= e + t.margin * 2 ? t.width / (e + t.margin * 2) : t.scale;
-	}, e.getImageWidth = function(t, n) {
-		let r = e.getScale(t, n);
-		return Math.floor((t + n.margin * 2) * r);
-	}, e.qrToImageData = function(t, n, r) {
-		let i = n.modules.size, a = n.modules.data, o = e.getScale(i, r), s = Math.floor((i + r.margin * 2) * o), c = r.margin * o, l = [r.color.light, r.color.dark];
-		for (let e = 0; e < s; e++) for (let n = 0; n < s; n++) {
-			let u = (e * s + n) * 4, d = r.color.light;
-			if (e >= c && n >= c && e < s - c && n < s - c) {
-				let t = Math.floor((e - c) / o), r = Math.floor((n - c) / o);
-				d = l[a[t * i + r] ? 1 : 0];
+	};
+	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];
 			}
-			t[u++] = d.r, t[u++] = d.g, t[u++] = d.b, t[u] = d.a;
+			imgData[posDst++] = pxColor.r;
+			imgData[posDst++] = pxColor.g;
+			imgData[posDst++] = pxColor.b;
+			imgData[posDst] = pxColor.a;
 		}
 	};
-})), re = /* @__PURE__ */ e(((e) => {
-	var t = X();
-	function n(e, t, n) {
-		e.clearRect(0, 0, t.width, t.height), t.style ||= {}, t.height = n, t.width = n, t.style.height = n + "px", t.style.width = n + "px";
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/renderer/canvas.js
+var require_canvas = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var Utils = 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 r() {
+	function getCanvasElement() {
 		try {
 			return document.createElement("canvas");
-		} catch {
-			throw Error("You need to specify a canvas element");
+		} catch (e) {
+			throw new Error("You need to specify a canvas element");
 		}
 	}
-	e.render = function(e, i, a) {
-		let o = a, s = i;
-		o === void 0 && (!i || !i.getContext) && (o = i, i = void 0), i || (s = r()), o = t.getOptions(o);
-		let c = t.getImageWidth(e.modules.size, o), l = s.getContext("2d"), u = l.createImageData(c, c);
-		return t.qrToImageData(u.data, e, o), n(l, s, c), l.putImageData(u, 0, 0), s;
-	}, e.renderToDataURL = function(t, n, r) {
-		let i = r;
-		i === void 0 && (!n || !n.getContext) && (i = n, n = void 0), i ||= {};
-		let a = e.render(t, n, i), o = i.type || "image/png", s = i.rendererOpts || {};
-		return a.toDataURL(o, s.quality);
-	};
-})), ie = /* @__PURE__ */ e(((e) => {
-	var t = X();
-	function n(e, t) {
-		let n = e.a / 255, r = t + "=\"" + e.hex + "\"";
-		return n < 1 ? r + " " + t + "-opacity=\"" + n.toFixed(2).slice(1) + "\"" : r;
+	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.getOptions(opts);
+		const size = Utils.getImageWidth(qrData.modules.size, opts);
+		const ctx = canvasEl.getContext("2d");
+		const image = ctx.createImageData(size, size);
+		Utils.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);
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/renderer/svg-tag.js
+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 r(e, t, n) {
-		let r = e + t;
-		return n !== void 0 && (r += " " + n), r;
+	function svgCmd(cmd, x, y) {
+		let str = cmd + x;
+		if (typeof y !== "undefined") str += " " + y;
+		return str;
 	}
-	function i(e, t, n) {
-		let i = "", a = 0, o = !1, s = 0;
-		for (let c = 0; c < e.length; c++) {
-			let l = Math.floor(c % t), u = Math.floor(c / t);
-			!l && !o && (o = !0), e[c] ? (s++, c > 0 && l > 0 && e[c - 1] || (i += o ? r("M", l + n, .5 + u + n) : r("m", a, 0), a = 0, o = !1), l + 1 < t && e[c + 1] || (i += r("h", s), s = 0)) : a++;
+	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 i;
+		return path;
 	}
-	e.render = function(e, r, a) {
-		let o = t.getOptions(r), s = e.modules.size, c = e.modules.data, l = s + o.margin * 2, u = o.color.light.a ? "<path " + n(o.color.light, "fill") + " d=\"M0 0h" + l + "v" + l + "H0z\"/>" : "", d = "<path " + n(o.color.dark, "stroke") + " d=\"" + i(c, s, o.margin) + "\"/>", f = "viewBox=\"0 0 " + l + " " + l + "\"", p = "<svg xmlns=\"http://www.w3.org/2000/svg\" " + (o.width ? "width=\"" + o.width + "\" height=\"" + o.width + "\" " : "") + f + " shape-rendering=\"crispEdges\">" + u + d + "</svg>\n";
-		return typeof a == "function" && a(null, p), p;
-	};
-})), ae = (/* @__PURE__ */ e(((e) => {
-	var t = k(), n = Y(), r = re(), i = ie();
-	function a(e, r, i, a, o) {
-		let s = [].slice.call(arguments, 1), c = s.length, l = typeof s[c - 1] == "function";
-		if (!l && !t()) throw Error("Callback required as last argument");
-		if (l) {
-			if (c < 2) throw Error("Too few arguments provided");
-			c === 2 ? (o = i, i = r, r = a = void 0) : c === 3 && (r.getContext && o === void 0 ? (o = a, a = void 0) : (o = a, a = i, i = r, r = void 0));
+	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;
+	};
+}));
+//#endregion
+//#region src/modules/redirect-to-mobile/qrCode.tsx
+var import_browser = (/* @__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 (c < 1) throw Error("Too few arguments provided");
-			return c === 1 ? (i = r, r = a = void 0) : c === 2 && !r.getContext && (a = i, i = r, r = void 0), new Promise(function(t, o) {
+			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 {
-					t(e(n.create(i, a), r, a));
+					resolve(renderFunc(QRCode.create(text, opts), canvas, opts));
 				} catch (e) {
-					o(e);
+					reject(e);
 				}
 			});
 		}
 		try {
-			let t = n.create(i, a);
-			o(null, e(t, r, a));
+			const data = QRCode.create(text, opts);
+			cb(null, renderFunc(data, canvas, opts));
 		} catch (e) {
-			o(e);
+			cb(e);
 		}
 	}
-	e.create = n.create, e.toCanvas = a.bind(null, r.render), e.toDataURL = a.bind(null, r.renderToDataURL), e.toString = a.bind(null, function(e, t, n) {
-		return i.render(e, n);
+	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);
 	});
-})))(), oe = ({ value: e, size: n = 150, bgColor: r = "#ffffff", fgColor: a = "#000000" }) => {
-	let { t: o } = t(), [l, u] = s("");
-	return i(() => {
-		e && (0, ae.toString)(e, {
+})))();
+var QrCode = ({ value, size = 150, bgColor = "#ffffff", fgColor = "#000000" }) => {
+	const { t } = useTranslation();
+	const [svgString, setSvgString] = d("");
+	y(() => {
+		if (!value) return;
+		(0, import_browser.toString)(value, {
 			type: "svg",
-			width: n,
+			width: size,
 			margin: 0,
 			color: {
-				dark: a,
-				light: r
+				dark: fgColor,
+				light: bgColor
 			}
-		}).then(u).catch(() => u(""));
+		}).then(setSvgString).catch(() => setSvgString(""));
 	}, [
-		e,
-		n,
-		r,
-		a
-	]), l ? /* @__PURE__ */ c("div", {
+		value,
+		size,
+		bgColor,
+		fgColor
+	]);
+	if (!svgString) return null;
+	return /* @__PURE__ */ u("div", {
 		class: "IncodeRedirectQrCode",
 		role: "img",
-		"aria-label": o("v2.redirectToMobile.qr.description"),
-		dangerouslySetInnerHTML: { __html: l }
-	}) : null;
-}, Z = ({ redirectUrl: e }) => {
-	let { t: n } = t();
-	return /* @__PURE__ */ c(r, { children: [/* @__PURE__ */ c("p", {
+		"aria-label": t("v2.redirectToMobile.qr.description"),
+		dangerouslySetInnerHTML: { __html: svgString }
+	});
+};
+//#endregion
+//#region src/modules/redirect-to-mobile/qrTabContent.tsx
+var QrTabContent = ({ redirectUrl }) => {
+	const { t } = useTranslation();
+	return /* @__PURE__ */ u(k, { children: [/* @__PURE__ */ u("p", {
 		class: "IncodeRedirectTabDescription",
-		children: n("v2.redirectToMobile.qr.description")
-	}), /* @__PURE__ */ c("div", {
+		children: t("v2.redirectToMobile.qr.description")
+	}), /* @__PURE__ */ u("div", {
 		class: "IncodeRedirectQrWrapper",
-		children: /* @__PURE__ */ c(oe, {
-			value: e,
+		children: /* @__PURE__ */ u(QrCode, {
+			value: redirectUrl,
 			size: 186
 		})
 	})] });
-}, se = ({ formattedPhone: e, onResend: r, onChangePhone: i }) => {
-	let { t: a } = t();
-	return /* @__PURE__ */ c("div", {
+};
+//#endregion
+//#region src/modules/redirect-to-mobile/smsSentView.tsx
+var SmsSentView = ({ formattedPhone, onResend, onChangePhone }) => {
+	const { t } = useTranslation();
+	return /* @__PURE__ */ u("div", {
 		class: "IncodeRedirectLinkSent",
 		children: [
-			/* @__PURE__ */ c(v, { size: 32 }),
-			/* @__PURE__ */ c(f, { size: 16 }),
-			/* @__PURE__ */ c(y, {
+			/* @__PURE__ */ u(SuccessIcon, { size: 32 }),
+			/* @__PURE__ */ u(Spacer, { size: 16 }),
+			/* @__PURE__ */ u(AutoFocusTitle, {
 				className: "IncodeRedirectLinkSentTitle",
-				children: a("redirect.linkSent")
+				children: t("redirect.linkSent")
 			}),
-			/* @__PURE__ */ c(f, { size: 12 }),
-			/* @__PURE__ */ c("p", {
+			/* @__PURE__ */ u(Spacer, { size: 12 }),
+			/* @__PURE__ */ u("p", {
 				class: "IncodeRedirectLinkSentPhone",
-				children: a("redirect.linkSentTo", { phone: e })
+				children: t("redirect.linkSentTo", { phone: formattedPhone })
 			}),
-			/* @__PURE__ */ c(f, { size: 32 }),
-			/* @__PURE__ */ c("div", {
+			/* @__PURE__ */ u(Spacer, { size: 32 }),
+			/* @__PURE__ */ u("div", {
 				class: "IncodeRedirectLinkSentActions",
-				children: /* @__PURE__ */ c(n, {
+				children: /* @__PURE__ */ u(Trans, {
 					i18nKey: "redirect.didntReceiveLinkActions",
 					defaultValue: "Didn't receive the link? <resend>Resend</resend> or <changePhone>Change phone number</changePhone>",
 					components: {
-						resend: /* @__PURE__ */ c(_, {
+						resend: /* @__PURE__ */ u(Button, {
 							variant: "link",
-							onClick: r
+							onClick: onResend
 						}),
-						changePhone: /* @__PURE__ */ c(_, {
+						changePhone: /* @__PURE__ */ u(Button, {
 							variant: "link",
-							onClick: i
+							onClick: onChangePhone
 						})
 					}
 				})
 			})
 		]
 	});
-}, Q = ({ countryCode: e, error: n, isSending: i, isPhoneValid: a, onPhoneChange: o, onSendSms: s }) => {
-	let { t: l } = t();
-	return /* @__PURE__ */ c(r, { children: [/* @__PURE__ */ c(x, {
+};
+//#endregion
+//#region src/modules/redirect-to-mobile/smsForm.tsx
+var SmsForm = ({ countryCode, error, isSending, isPhoneValid, onPhoneChange, onSendSms }) => {
+	const { t } = useTranslation();
+	return /* @__PURE__ */ u(k, { children: [/* @__PURE__ */ u(PhoneInputComposed, {
 		id: "sms-phone",
-		countryCode: e,
-		error: n,
-		disabled: i,
-		autoFocus: !0,
-		onChange: o
-	}), /* @__PURE__ */ c(_, {
-		onClick: s,
-		disabled: !a || i,
-		isLoading: i,
+		countryCode,
+		error,
+		disabled: isSending,
+		autoFocus: true,
+		onChange: onPhoneChange
+	}), /* @__PURE__ */ u(Button, {
+		onClick: onSendSms,
+		disabled: !isPhoneValid || isSending,
+		isLoading: isSending,
 		class: "IncodeRedirectSmsSendButton",
-		children: l("redirect.sendLinkViaSms")
+		children: t("redirect.sendLinkViaSms")
 	})] });
-}, ce = (e, t) => e.startsWith(t) ? `${t} ${e.slice(t.length).replace(/(\d{3})(?=\d)/g, "$1 ")}` : e, le = ({ phonePrefix: e, smsSent: n, error: i, manager: o, onResend: l }) => {
-	let { t: u } = t(), [d, f] = s(e), [p, m] = s(!1), [h, g] = s(!1), _ = b(e)?.code ?? "", v = ce(d, e), y = a((e, t) => {
-		f(e), m(t);
-	}, []), x = a(() => {
-		g(!0), o.sendSms(d), g(!1);
-	}, [o, d]), S = a(() => {
-		x(), l();
-	}, [x, l]), C = a(() => {
-		f(e), m(!1), o.resetSms();
-	}, [o, e]);
-	return /* @__PURE__ */ c(r, { children: [/* @__PURE__ */ c("p", {
+};
+//#endregion
+//#region src/modules/redirect-to-mobile/smsTabContent.tsx
+var formatPhoneNumber = (phone, prefix) => {
+	if (!phone.startsWith(prefix)) return phone;
+	return `${prefix} ${phone.slice(prefix.length).replace(/(\d{3})(?=\d)/g, "$1 ")}`;
+};
+var SmsTabContent = ({ phonePrefix, smsSent, error, manager, onResend }) => {
+	const { t } = useTranslation();
+	const [phoneNumber, setPhoneNumber] = d(phonePrefix);
+	const [isPhoneValid, setIsPhoneValid] = d(false);
+	const [isSending, setIsSending] = d(false);
+	const countryCode = getCountryByCallingCode(phonePrefix)?.code ?? "";
+	const formattedPhone = formatPhoneNumber(phoneNumber, phonePrefix);
+	const handlePhoneChange = q((phone, valid) => {
+		setPhoneNumber(phone);
+		setIsPhoneValid(valid);
+	}, []);
+	const handleSendSms = q(() => {
+		setIsSending(true);
+		manager.sendSms(phoneNumber);
+		setIsSending(false);
+	}, [manager, phoneNumber]);
+	const handleResend = q(() => {
+		handleSendSms();
+		onResend();
+	}, [handleSendSms, onResend]);
+	const handleChangePhone = q(() => {
+		setPhoneNumber(phonePrefix);
+		setIsPhoneValid(false);
+		manager.resetSms();
+	}, [manager, phonePrefix]);
+	return /* @__PURE__ */ u(k, { children: [/* @__PURE__ */ u("p", {
 		class: "IncodeRedirectTabDescription",
-		children: u("v2.redirectToMobile.sms.description")
-	}), n ? /* @__PURE__ */ c(se, {
-		formattedPhone: v,
-		onResend: S,
-		onChangePhone: C
-	}) : /* @__PURE__ */ c(Q, {
-		countryCode: _,
-		phonePrefix: e,
-		error: i,
-		isSending: h,
-		isPhoneValid: p,
-		onPhoneChange: y,
-		onSendSms: x
+		children: t("v2.redirectToMobile.sms.description")
+	}), smsSent ? /* @__PURE__ */ u(SmsSentView, {
+		formattedPhone,
+		onResend: handleResend,
+		onChangePhone: handleChangePhone
+	}) : /* @__PURE__ */ u(SmsForm, {
+		countryCode,
+		phonePrefix,
+		error,
+		isSending,
+		isPhoneValid,
+		onPhoneChange: handlePhoneChange,
+		onSendSms: handleSendSms
 	})] });
-}, ue = ({ redirectUrl: e, phonePrefix: n, smsSent: i, disableSmsOption: o, addContinueToDesktop: l, error: u, manager: d, logoSrc: f }) => {
-	let { t: p } = t(), [m, h] = s(!1), g = a(() => {
-		h(!0), setTimeout(() => h(!1), 3e3);
-	}, []), _ = a(() => {
-		d.continueOnDesktop();
-	}, [d]);
-	return /* @__PURE__ */ c("div", {
+};
+//#endregion
+//#region src/modules/redirect-to-mobile/qrScreen.tsx
+var QrScreen = ({ redirectUrl, phonePrefix, smsSent, disableSmsOption, addContinueToDesktop, error, manager, logoSrc }) => {
+	const { t } = useTranslation();
+	const [showResendToast, setShowResendToast] = d(false);
+	const handleResend = q(() => {
+		setShowResendToast(true);
+		setTimeout(() => setShowResendToast(false), 3e3);
+	}, []);
+	const handleContinueOnDesktop = q(() => {
+		manager.continueOnDesktop();
+	}, [manager]);
+	return /* @__PURE__ */ u("div", {
 		class: "IncodeRedirectContainer",
-		children: [/* @__PURE__ */ c(O, { visible: m }), /* @__PURE__ */ c("div", {
+		children: [/* @__PURE__ */ u(ResendToast, { visible: showResendToast }), /* @__PURE__ */ u("div", {
 			class: "IncodeRedirectCard",
-			children: [o ? /* @__PURE__ */ c(r, { children: [/* @__PURE__ */ c(E, { logoSrc: f }), /* @__PURE__ */ c("div", {
+			children: [disableSmsOption ? /* @__PURE__ */ u(k, { children: [/* @__PURE__ */ u(RedirectHeader, { logoSrc }), /* @__PURE__ */ u("div", {
 				class: "IncodeRedirectOptions",
-				children: /* @__PURE__ */ c(Z, { redirectUrl: e })
-			})] }) : /* @__PURE__ */ c(w, {
+				children: /* @__PURE__ */ u(QrTabContent, { redirectUrl })
+			})] }) : /* @__PURE__ */ u(Tabs, {
 				defaultValue: "qr",
 				listClassName: "IncodeRedirectTabs",
 				triggerClassName: "IncodeRedirectTab",
 				activeTriggerClassName: "IncodeRedirectTabActive",
-				children: [/* @__PURE__ */ c("div", {
+				children: [/* @__PURE__ */ u("div", {
 					class: "IncodeRedirectTopGroup",
-					children: [/* @__PURE__ */ c(E, { logoSrc: f }), /* @__PURE__ */ c(w.List, {
-						label: p("v2.redirectToMobile.tabs.label"),
-						children: [/* @__PURE__ */ c(w.Trigger, {
+					children: [/* @__PURE__ */ u(RedirectHeader, { logoSrc }), /* @__PURE__ */ u(Tabs.List, {
+						label: t("v2.redirectToMobile.tabs.label"),
+						children: [/* @__PURE__ */ u(Tabs.Trigger, {
 							value: "qr",
-							children: p("v2.redirectToMobile.tabs.0")
-						}), /* @__PURE__ */ c(w.Trigger, {
+							children: t("v2.redirectToMobile.tabs.0")
+						}), /* @__PURE__ */ u(Tabs.Trigger, {
 							value: "sms",
-							children: p("v2.redirectToMobile.tabs.1")
+							children: t("v2.redirectToMobile.tabs.1")
 						})]
 					})]
-				}), /* @__PURE__ */ c("div", {
+				}), /* @__PURE__ */ u("div", {
 					class: "IncodeRedirectOptions",
-					children: [/* @__PURE__ */ c(w.Content, {
+					children: [/* @__PURE__ */ u(Tabs.Content, {
 						value: "qr",
-						children: /* @__PURE__ */ c(Z, { redirectUrl: e })
-					}), /* @__PURE__ */ c(w.Content, {
+						children: /* @__PURE__ */ u(QrTabContent, { redirectUrl })
+					}), /* @__PURE__ */ u(Tabs.Content, {
 						value: "sms",
-						children: /* @__PURE__ */ c(le, {
-							phonePrefix: n,
-							smsSent: i,
-							error: u,
-							manager: d,
-							onResend: g
+						children: /* @__PURE__ */ u(SmsTabContent, {
+							phonePrefix,
+							smsSent,
+							error,
+							manager,
+							onResend: handleResend
 						})
 					})]
 				})]
-			}), /* @__PURE__ */ c(D, {
-				addContinueToDesktop: l,
-				onContinueOnDesktop: _
+			}), /* @__PURE__ */ u(RedirectFooter, {
+				addContinueToDesktop,
+				onContinueOnDesktop: handleContinueOnDesktop
 			})]
 		})]
 	});
-}, de = ({ title: e, subtitle: n, logoSrc: r }) => {
-	let { t: i } = t(), a = e ?? i("verificationComplete.title"), o = n ?? i("verificationComplete.message");
-	return /* @__PURE__ */ c("div", {
+};
+//#endregion
+//#region src/modules/redirect-to-mobile/waitingScreen.tsx
+var WaitingScreen = ({ title, subtitle, logoSrc }) => {
+	const { t } = useTranslation();
+	const displayTitle = title ?? t("verificationComplete.title");
+	const displaySubtitle = subtitle ?? t("verificationComplete.message");
+	return /* @__PURE__ */ u("div", {
 		class: "IncodeRedirectFinishedContainer",
 		children: [
-			/* @__PURE__ */ c("img", {
-				src: r,
+			/* @__PURE__ */ u("img", {
+				src: logoSrc,
 				alt: "",
 				"aria-hidden": "true",
 				class: "IncodeRedirectLogo"
 			}),
-			a ? /* @__PURE__ */ c(y, {
+			displayTitle ? /* @__PURE__ */ u(AutoFocusTitle, {
 				className: "IncodeRedirectFinishedTitle",
-				children: a
+				children: displayTitle
 			}) : null,
-			o ? /* @__PURE__ */ c("p", {
+			displaySubtitle ? /* @__PURE__ */ u("p", {
 				class: "IncodeRedirectFinishedSubtitle",
-				children: o
+				children: displaySubtitle
 			}) : null
 		]
 	});
-}, fe = ({ config: e, manager: t, services: n, onFinish: r, onContinue: a, onError: s }) => {
-	let [d, f] = l(() => {
-		if (t) return t;
-		if (!e) throw Error("RedirectToMobile config is required when no manager is provided");
-		return T({
-			config: e,
-			services: n
+};
+//#endregion
+//#region src/modules/redirect-to-mobile/redirect-to-mobile.tsx
+var RedirectToMobileContent = ({ config, manager: externalManager, services, onFinish, onContinue, onError }) => {
+	const [state, manager] = useManager(() => {
+		if (externalManager) return externalManager;
+		if (!config) throw new Error("RedirectToMobile config is required when no manager is provided");
+		return createRedirectToMobileManager({
+			config,
+			services
 		});
-	}, { manageLifecycle: !t }), { logoSrc: h, logoHeightPx: _ } = m({
+	}, { manageLifecycle: !externalManager });
+	const { logoSrc, logoHeightPx } = usePageUiConfig({
 		hideHeader: void 0,
 		hideFooterBranding: void 0,
 		logo: void 0,
-		defaultLogoSrc: p
+		defaultLogoSrc: incode_logo_default
 	});
-	u({
-		status: d.status,
-		onFinish: r,
-		onError: s,
-		error: d.status === "error" ? d.error : void 0
+	useModuleTerminalCallbacks({
+		status: state.status,
+		onFinish,
+		onError,
+		error: state.status === "error" ? state.error : void 0
 	});
-	let v = o(!1);
-	i(() => {
-		v.current || d.status === "continue" && (v.current = !0, a?.());
-	}, [d.status, a]);
-	let y = d.status === "idle" || d.status === "loading" ? /* @__PURE__ */ c(g, { hideText: !0 }) : d.status === "redirecting" ? /* @__PURE__ */ c(ue, {
-		redirectUrl: d.redirectUrl,
-		phonePrefix: d.phonePrefix,
-		smsSent: d.smsSent,
-		disableSmsOption: e?.disableSmsOption ?? !1,
-		addContinueToDesktop: e?.addContinueToDesktop ?? !1,
-		error: d.error,
-		manager: f,
-		logoSrc: h
-	}) : d.status === "finished" ? /* @__PURE__ */ c(de, { logoSrc: h }) : null;
-	return /* @__PURE__ */ c("main", {
+	const continueFiredRef = A(false);
+	y(() => {
+		if (continueFiredRef.current) return;
+		if (state.status === "continue") {
+			continueFiredRef.current = true;
+			onContinue?.();
+		}
+	}, [state.status, onContinue]);
+	const content = (() => {
+		if (state.status === "idle" || state.status === "loading") return /* @__PURE__ */ u(TransitionSpinner, { hideText: true });
+		if (state.status === "redirecting") return /* @__PURE__ */ u(QrScreen, {
+			redirectUrl: state.redirectUrl,
+			phonePrefix: state.phonePrefix,
+			smsSent: state.smsSent,
+			disableSmsOption: config?.disableSmsOption ?? false,
+			addContinueToDesktop: config?.addContinueToDesktop ?? false,
+			error: state.error,
+			manager,
+			logoSrc
+		});
+		if (state.status === "finished") return /* @__PURE__ */ u(WaitingScreen, { logoSrc });
+		return null;
+	})();
+	return /* @__PURE__ */ u("main", {
 		class: "IncodeRedirectRoot",
-		style: { "--logo-height": `${_}px` },
-		children: y
+		style: { "--logo-height": `${logoHeightPx}px` },
+		children: content
 	});
-}, $ = ({ config: e, manager: t, services: n, onFinish: r, onContinue: i, onError: a }) => /* @__PURE__ */ c(d, { children: e || t ? /* @__PURE__ */ c(fe, {
-	config: e,
-	manager: t,
-	services: n,
-	onFinish: r,
-	onContinue: i,
-	onError: a
-}) : null });
-S($, "incode-redirect-to-mobile", [
+};
+var RedirectToMobile = ({ config, manager, services, onFinish, onContinue, onError }) => {
+	return /* @__PURE__ */ u(IncodeComponent, { children: config || manager ? /* @__PURE__ */ u(RedirectToMobileContent, {
+		config,
+		manager,
+		services,
+		onFinish,
+		onContinue,
+		onError
+	}) : null });
+};
+registerIncodeElement(RedirectToMobile, "incode-redirect-to-mobile", [
 	"config",
 	"services",
 	"onFinish",
@@ -1531,4 +2771,4 @@ S($, "incode-redirect-to-mobile", [
 	"onError"
 ]);
 //#endregion
-export { $ as RedirectToMobile };
+export { RedirectToMobile };