@kubohiroya/turbowarp-webrtc-qrcode-pairing 0.1.0

package/dist/webrtc-qrcode-pairing.js

@@ -0,0 +1,4064 @@
+// Name: TurboWarp-WebRTC-QRCode-Pairing
+// ID: kubohiroyawebrtcqrcodepairing
+// Description: Exchanges WebRTC offers and answers by carrying them optically as QR codes.
+// By: Hiroya Kubo
+// License: MPL-2.0
+
+(function (Scratch) {
+  'use strict';
+
+  //#region \0rolldown/runtime.js
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+  var __copyProps = (to, from, except, desc) => {
+  	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+  		key = keys[i];
+  		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+  			get: ((k) => from[k]).bind(null, key),
+  			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+  		});
+  	}
+  	return to;
+  };
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+  	value: mod,
+  	enumerable: true
+  }) : target, mod));
+  //#endregion
+  //#region src/config.ts
+  var extensionConfig = {
+  	id: "kubohiroyawebrtcqrcodepairing",
+  	slug: "webrtc-qrcode-pairing",
+  	name: "TurboWarp-WebRTC-QRCode-Pairing",
+  	description: "Exchanges WebRTC offers and answers by carrying them optically as QR codes.",
+  	author: "Hiroya Kubo",
+  	license: "MPL-2.0",
+  	unsandboxed: true,
+  	docsURI: "https://kubohiroya.github.io/turbowarp-webrtc-qrcode-pairing/",
+  	blockIconURI: "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCA0OCA0OCI+PHJlY3QgeD0iNCIgeT0iOCIgd2lkdGg9IjE4IiBoZWlnaHQ9IjE0IiByeD0iMyIgZmlsbD0iIzRDOTdGRiIvPjxyZWN0IHg9IjI2IiB5PSI4IiB3aWR0aD0iMTgiIGhlaWdodD0iMTQiIHJ4PSIzIiBmaWxsPSIjNTlDMDU5Ii8+PHJlY3QgeD0iMTUiIHk9IjI2IiB3aWR0aD0iMTgiIGhlaWdodD0iMTQiIHJ4PSIzIiBmaWxsPSIjRkZBQjE5Ii8+PC9zdmc+"
+  };
+  var block_definitions_default = {
+  	extensionName: "TurboWarp-WebRTC-QRCode-Pairing",
+  	blocks: [
+  		{
+  			"opcode": "startOfferPairing",
+  			"blockType": "COMMAND",
+  			"text": "start offer pairing [SESSION] as [LOCAL_PEER] to [REMOTE_PEER]",
+  			"description": "Creates a WebRTC offer for the integration machine and prepares its QR parts.",
+  			"arguments": {
+  				"SESSION": {
+  					"type": "STRING",
+  					"defaultValue": "pairing-1"
+  				},
+  				"LOCAL_PEER": {
+  					"type": "STRING",
+  					"defaultValue": "hub"
+  				},
+  				"REMOTE_PEER": {
+  					"type": "STRING",
+  					"defaultValue": "camera-1"
+  				}
+  			}
+  		},
+  		{
+  			"opcode": "startAnswerPairing",
+  			"blockType": "COMMAND",
+  			"text": "start answer pairing [SESSION] as [LOCAL_PEER]",
+  			"description": "Waits for an offer on the camera machine. Leave the name empty to adopt the name the offer assigns.",
+  			"arguments": {
+  				"SESSION": {
+  					"type": "STRING",
+  					"defaultValue": "pairing-1"
+  				},
+  				"LOCAL_PEER": {
+  					"type": "STRING",
+  					"defaultValue": ""
+  				}
+  			}
+  		},
+  		{
+  			"opcode": "ingestPairingQrText",
+  			"blockType": "COMMAND",
+  			"text": "receive pairing QR text [TEXT] for [SESSION]",
+  			"description": "Accepts one decoded QR text. Repeated readings of the same part are ignored.",
+  			"arguments": {
+  				"TEXT": {
+  					"type": "STRING",
+  					"defaultValue": ""
+  				},
+  				"SESSION": {
+  					"type": "STRING",
+  					"defaultValue": "pairing-1"
+  				}
+  			}
+  		},
+  		{
+  			"opcode": "scanPairingQrFromCamera",
+  			"blockType": "COMMAND",
+  			"text": "scan pairing QR for [SESSION] from camera [CAMERA_ID]",
+  			"description": "Reads parts from the named camera until the exchange has every part it needs.",
+  			"arguments": {
+  				"SESSION": {
+  					"type": "STRING",
+  					"defaultValue": "pairing-1"
+  				},
+  				"CAMERA_ID": {
+  					"type": "STRING",
+  					"defaultValue": "default"
+  				}
+  			}
+  		},
+  		{
+  			"opcode": "pairingReceivedParts",
+  			"blockType": "REPORTER",
+  			"text": "received parts of [SESSION]",
+  			"description": "Returns how many distinct parts have been accepted.",
+  			"arguments": { "SESSION": {
+  				"type": "STRING",
+  				"defaultValue": "pairing-1"
+  			} }
+  		},
+  		{
+  			"opcode": "pairingRequiredParts",
+  			"blockType": "REPORTER",
+  			"text": "required parts of [SESSION]",
+  			"description": "Returns how many parts the incoming message has, or zero before the first part arrives.",
+  			"arguments": { "SESSION": {
+  				"type": "STRING",
+  				"defaultValue": "pairing-1"
+  			} }
+  		},
+  		{
+  			"opcode": "pairingMissingParts",
+  			"blockType": "REPORTER",
+  			"text": "missing parts of [SESSION]",
+  			"description": "Returns the one-based part numbers that have not been read yet, separated by commas.",
+  			"arguments": { "SESSION": {
+  				"type": "STRING",
+  				"defaultValue": "pairing-1"
+  			} }
+  		},
+  		{
+  			"opcode": "showPairingQrPart",
+  			"blockType": "COMMAND",
+  			"text": "show pairing QR part [INDEX] of [SESSION] on this sprite",
+  			"description": "Shows the selected one-based part using a temporary sprite skin.",
+  			"arguments": {
+  				"INDEX": {
+  					"type": "NUMBER",
+  					"defaultValue": 1
+  				},
+  				"SESSION": {
+  					"type": "STRING",
+  					"defaultValue": "pairing-1"
+  				}
+  			}
+  		},
+  		{
+  			"opcode": "showNextPairingQrPart",
+  			"blockType": "COMMAND",
+  			"text": "show next pairing QR part of [SESSION] on this sprite",
+  			"description": "Shows the next part and wraps from the last part back to the first.",
+  			"arguments": { "SESSION": {
+  				"type": "STRING",
+  				"defaultValue": "pairing-1"
+  			} }
+  		},
+  		{
+  			"opcode": "pairingQrPartCount",
+  			"blockType": "REPORTER",
+  			"text": "pairing QR part count of [SESSION]",
+  			"description": "Returns how many parts are prepared for display, or zero when none are.",
+  			"arguments": { "SESSION": {
+  				"type": "STRING",
+  				"defaultValue": "pairing-1"
+  			} }
+  		},
+  		{
+  			"opcode": "pairingQrCurrentPart",
+  			"blockType": "REPORTER",
+  			"text": "current pairing QR part of [SESSION]",
+  			"description": "Returns the one-based part selected for display, or zero when none is selected.",
+  			"arguments": { "SESSION": {
+  				"type": "STRING",
+  				"defaultValue": "pairing-1"
+  			} }
+  		},
+  		{
+  			"opcode": "pairingQrPartSvg",
+  			"blockType": "REPORTER",
+  			"text": "pairing QR part [INDEX] of [SESSION] as SVG",
+  			"description": "Returns the part as SVG markup so a project can display it its own way.",
+  			"arguments": {
+  				"INDEX": {
+  					"type": "NUMBER",
+  					"defaultValue": 1
+  				},
+  				"SESSION": {
+  					"type": "STRING",
+  					"defaultValue": "pairing-1"
+  				}
+  			}
+  		},
+  		{
+  			"opcode": "pairingQrPartDataUri",
+  			"blockType": "REPORTER",
+  			"text": "pairing QR part [INDEX] of [SESSION] as data URI",
+  			"description": "Returns the part as a base64 SVG data URI for costumes and HTML images.",
+  			"arguments": {
+  				"INDEX": {
+  					"type": "NUMBER",
+  					"defaultValue": 1
+  				},
+  				"SESSION": {
+  					"type": "STRING",
+  					"defaultValue": "pairing-1"
+  				}
+  			}
+  		},
+  		{
+  			"opcode": "endPairingQrDisplay",
+  			"blockType": "COMMAND",
+  			"text": "end pairing QR display of [SESSION]",
+  			"description": "Restores the sprites this session changed. The session itself stays open.",
+  			"arguments": { "SESSION": {
+  				"type": "STRING",
+  				"defaultValue": "pairing-1"
+  			} }
+  		},
+  		{
+  			"opcode": "pairingPhase",
+  			"blockType": "REPORTER",
+  			"text": "pairing phase of [SESSION]",
+  			"description": "Returns the session phase, such as offer-ready, receiving, answer-ready, connecting, or connected.",
+  			"arguments": { "SESSION": {
+  				"type": "STRING",
+  				"defaultValue": "pairing-1"
+  			} }
+  		},
+  		{
+  			"opcode": "pairingConnectionState",
+  			"blockType": "REPORTER",
+  			"text": "pairing connection state of [SESSION]",
+  			"description": "Returns the WebRTC connection state reported for this session's peer.",
+  			"arguments": { "SESSION": {
+  				"type": "STRING",
+  				"defaultValue": "pairing-1"
+  			} }
+  		},
+  		{
+  			"opcode": "isPairingConnected",
+  			"blockType": "BOOLEAN",
+  			"text": "pairing [SESSION] connected?",
+  			"description": "Reports whether WebRTC has established the connection for this session.",
+  			"arguments": { "SESSION": {
+  				"type": "STRING",
+  				"defaultValue": "pairing-1"
+  			} }
+  		},
+  		{
+  			"opcode": "waitUntilPairingConnected",
+  			"blockType": "COMMAND",
+  			"text": "wait until pairing [SESSION] is connected",
+  			"description": "Waits for the connection, or fails when the session is cancelled, times out, or fails.",
+  			"arguments": { "SESSION": {
+  				"type": "STRING",
+  				"defaultValue": "pairing-1"
+  			} }
+  		},
+  		{
+  			"opcode": "pairingError",
+  			"blockType": "REPORTER",
+  			"text": "pairing error code of [SESSION]",
+  			"description": "Returns the latest error code, such as hash-mismatch or peer-mismatch, or an empty string.",
+  			"arguments": { "SESSION": {
+  				"type": "STRING",
+  				"defaultValue": "pairing-1"
+  			} }
+  		},
+  		{
+  			"opcode": "pairingErrorMessage",
+  			"blockType": "REPORTER",
+  			"text": "pairing error message of [SESSION]",
+  			"description": "Returns the latest error message. Pairing codes and QR payloads are never included.",
+  			"arguments": { "SESSION": {
+  				"type": "STRING",
+  				"defaultValue": "pairing-1"
+  			} }
+  		},
+  		{
+  			"opcode": "pairingLocalPeer",
+  			"blockType": "REPORTER",
+  			"text": "local peer of [SESSION]",
+  			"description": "Returns the name this machine uses for itself in this exchange.",
+  			"arguments": { "SESSION": {
+  				"type": "STRING",
+  				"defaultValue": "pairing-1"
+  			} }
+  		},
+  		{
+  			"opcode": "pairingRemotePeer",
+  			"blockType": "REPORTER",
+  			"text": "remote peer of [SESSION]",
+  			"description": "Returns the name this machine uses for the other machine, which is also its WebRTC peer name.",
+  			"arguments": { "SESSION": {
+  				"type": "STRING",
+  				"defaultValue": "pairing-1"
+  			} }
+  		},
+  		{
+  			"opcode": "pairingExchangeId",
+  			"blockType": "REPORTER",
+  			"text": "exchange id of [SESSION]",
+  			"description": "Returns the identifier of the current offer and answer exchange. A retry allocates a new one.",
+  			"arguments": { "SESSION": {
+  				"type": "STRING",
+  				"defaultValue": "pairing-1"
+  			} }
+  		},
+  		{
+  			"opcode": "pairingRemainingSeconds",
+  			"blockType": "REPORTER",
+  			"text": "remaining seconds of [SESSION]",
+  			"description": "Returns the seconds left before the exchange times out.",
+  			"arguments": { "SESSION": {
+  				"type": "STRING",
+  				"defaultValue": "pairing-1"
+  			} }
+  		},
+  		{
+  			"opcode": "pairingSessions",
+  			"blockType": "REPORTER",
+  			"text": "pairing sessions",
+  			"description": "Returns the open session names, separated by commas.",
+  			"arguments": {}
+  		},
+  		{
+  			"opcode": "cancelPairing",
+  			"blockType": "COMMAND",
+  			"text": "cancel pairing [SESSION]",
+  			"description": "Cancels the exchange and releases displays, buffers, and unconnected peers. Established connections stay up.",
+  			"arguments": { "SESSION": {
+  				"type": "STRING",
+  				"defaultValue": "pairing-1"
+  			} }
+  		},
+  		{
+  			"opcode": "retryPairing",
+  			"blockType": "COMMAND",
+  			"text": "retry pairing [SESSION]",
+  			"description": "Starts a new exchange for the same session. QR codes from the previous exchange stop being accepted.",
+  			"arguments": { "SESSION": {
+  				"type": "STRING",
+  				"defaultValue": "pairing-1"
+  			} }
+  		},
+  		{
+  			"opcode": "setPairingTimeout",
+  			"blockType": "COMMAND",
+  			"text": "set pairing timeout of [SESSION] to [SECONDS] seconds",
+  			"description": "Sets how long the exchange waits, measured on this machine's own clock.",
+  			"arguments": {
+  				"SESSION": {
+  					"type": "STRING",
+  					"defaultValue": "pairing-1"
+  				},
+  				"SECONDS": {
+  					"type": "NUMBER",
+  					"defaultValue": 600
+  				}
+  			}
+  		}
+  	]
+  };
+  //#endregion
+  //#region src/config/feature-flags.ts
+  var overrides = globalThis.__TWQP_FEATURE_FLAGS__;
+  /**
+  * Startup-fixed flags, read once and frozen. The QR pairing path stays opt-in
+  * until it is verified on hardware; turning it off is a route switch back to
+  * manual offer/answer exchange, not a disconnect of established connections.
+  */
+  var featureFlags = Object.freeze({ qrCodePairing: overrides?.qrCodePairing === true });
+  //#endregion
+  //#region src/clock.ts
+  var systemMonotonicClock = { nowMilliseconds: () => typeof performance === "object" && typeof performance.now === "function" ? performance.now() : Date.now() };
+  //#endregion
+  //#region src/config/qr-config.ts
+  var configuredLevel = globalThis.__TWQP_QR_CONFIG__?.errorCorrectionLevel;
+  /**
+  * Startup-fixed QR settings. M is the software-validated default; higher levels
+  * survive worse optical conditions but carry fewer characters per symbol, which
+  * raises the part count the operator has to carry.
+  */
+  var qrConfig = Object.freeze({ errorCorrectionLevel: isLevel(configuredLevel) ? configuredLevel : "M" });
+  function isLevel(value) {
+  	return value === "L" || value === "M" || value === "Q" || value === "H";
+  }
+  //#endregion
+  //#region src/errors.ts
+  var QrPairingError = class extends Error {
+  	constructor(code, message, options) {
+  		super(message, options);
+  		this.name = "QrPairingError";
+  		this.code = code;
+  	}
+  };
+  //#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;
+  	};
+  }));
+  //#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,
+  		70,
+  		100,
+  		134,
+  		172,
+  		196,
+  		242,
+  		292,
+  		346,
+  		404,
+  		466,
+  		532,
+  		581,
+  		655,
+  		733,
+  		815,
+  		901,
+  		991,
+  		1085,
+  		1156,
+  		1258,
+  		1364,
+  		1474,
+  		1588,
+  		1706,
+  		1828,
+  		1921,
+  		2051,
+  		2185,
+  		2323,
+  		2465,
+  		2611,
+  		2761,
+  		2876,
+  		3034,
+  		3196,
+  		3362,
+  		3532,
+  		3706
+  	];
+  	/**
+  	* 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 exports.L;
+  			case "m":
+  			case "medium": return exports.M;
+  			case "q":
+  			case "quartile": return exports.Q;
+  			case "h":
+  			case "high": return exports.H;
+  			default: throw new Error("Unknown EC Level: " + string);
+  		}
+  	}
+  	exports.isValid = function isValid(level) {
+  		return level && typeof level.bit !== "undefined" && level.bit >= 0 && level.bit < 4;
+  	};
+  	exports.from = function from(value, defaultValue) {
+  		if (exports.isValid(value)) return value;
+  		try {
+  			return fromString(value);
+  		} catch (e) {
+  			return defaultValue;
+  		}
+  	};
+  }));
+  //#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;
+  	}
+  	BitBuffer.prototype = {
+  		get: function(index) {
+  			const bufIndex = Math.floor(index / 8);
+  			return (this.buffer[bufIndex] >>> 7 - index % 8 & 1) === 1;
+  		},
+  		put: function(num, length) {
+  			for (let i = 0; i < length; i++) this.putBit((num >>> length - i - 1 & 1) === 1);
+  		},
+  		getLengthInBits: function() {
+  			return this.length;
+  		},
+  		putBit: function(bit) {
+  			const bufIndex = Math.floor(this.length / 8);
+  			if (this.buffer.length <= bufIndex) this.buffer.push(0);
+  			if (bit) this.buffer[bufIndex] |= 128 >>> this.length % 8;
+  			this.length++;
+  		}
+  	};
+  	module.exports = BitBuffer;
+  }));
+  //#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);
+  	}
+  	/**
+  	* 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],
+  			[size - FINDER_PATTERN_SIZE, 0],
+  			[0, size - FINDER_PATTERN_SIZE]
+  		];
+  	};
+  }));
+  //#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,
+  		PATTERN011: 3,
+  		PATTERN100: 4,
+  		PATTERN101: 5,
+  		PATTERN110: 6,
+  		PATTERN111: 7
+  	};
+  	/**
+  	* Weighted penalty scores for the undesirable features
+  	* @type {Object}
+  	*/
+  	var PenaltyScores = {
+  		N1: 3,
+  		N2: 3,
+  		N3: 40,
+  		N4: 10
+  	};
+  	/**
+  	* 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;
+  				}
+  			}
+  			if (sameCountCol >= 5) points += PenaltyScores.N1 + (sameCountCol - 5);
+  			if (sameCountRow >= 5) points += PenaltyScores.N1 + (sameCountRow - 5);
+  		}
+  		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 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 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);
+  		}
+  	}
+  	/**
+  	* 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 bestPattern;
+  	};
+  }));
+  //#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,
+  		1,
+  		1,
+  		1,
+  		1,
+  		1,
+  		1,
+  		1,
+  		2,
+  		2,
+  		1,
+  		2,
+  		2,
+  		4,
+  		1,
+  		2,
+  		4,
+  		4,
+  		2,
+  		4,
+  		4,
+  		4,
+  		2,
+  		4,
+  		6,
+  		5,
+  		2,
+  		4,
+  		6,
+  		6,
+  		2,
+  		5,
+  		8,
+  		8,
+  		4,
+  		5,
+  		8,
+  		8,
+  		4,
+  		5,
+  		8,
+  		11,
+  		4,
+  		8,
+  		10,
+  		11,
+  		4,
+  		9,
+  		12,
+  		16,
+  		4,
+  		9,
+  		16,
+  		16,
+  		6,
+  		10,
+  		12,
+  		18,
+  		6,
+  		10,
+  		17,
+  		16,
+  		6,
+  		11,
+  		16,
+  		19,
+  		6,
+  		13,
+  		18,
+  		21,
+  		7,
+  		14,
+  		21,
+  		25,
+  		8,
+  		16,
+  		20,
+  		25,
+  		8,
+  		17,
+  		23,
+  		25,
+  		9,
+  		17,
+  		23,
+  		34,
+  		9,
+  		18,
+  		25,
+  		30,
+  		10,
+  		20,
+  		27,
+  		32,
+  		12,
+  		21,
+  		29,
+  		35,
+  		12,
+  		23,
+  		34,
+  		37,
+  		12,
+  		25,
+  		34,
+  		40,
+  		13,
+  		26,
+  		35,
+  		42,
+  		14,
+  		28,
+  		38,
+  		45,
+  		15,
+  		29,
+  		40,
+  		48,
+  		16,
+  		31,
+  		43,
+  		51,
+  		17,
+  		33,
+  		45,
+  		54,
+  		18,
+  		35,
+  		48,
+  		57,
+  		19,
+  		37,
+  		51,
+  		60,
+  		19,
+  		38,
+  		53,
+  		63,
+  		20,
+  		40,
+  		56,
+  		66,
+  		21,
+  		43,
+  		59,
+  		70,
+  		22,
+  		45,
+  		62,
+  		74,
+  		24,
+  		47,
+  		65,
+  		77,
+  		25,
+  		49,
+  		68,
+  		81
+  	];
+  	var EC_CODEWORDS_TABLE = [
+  		7,
+  		10,
+  		13,
+  		17,
+  		10,
+  		16,
+  		22,
+  		28,
+  		15,
+  		26,
+  		36,
+  		44,
+  		20,
+  		36,
+  		52,
+  		64,
+  		26,
+  		48,
+  		72,
+  		88,
+  		36,
+  		64,
+  		96,
+  		112,
+  		40,
+  		72,
+  		108,
+  		130,
+  		48,
+  		88,
+  		132,
+  		156,
+  		60,
+  		110,
+  		160,
+  		192,
+  		72,
+  		130,
+  		192,
+  		224,
+  		80,
+  		150,
+  		224,
+  		264,
+  		96,
+  		176,
+  		260,
+  		308,
+  		104,
+  		198,
+  		288,
+  		352,
+  		120,
+  		216,
+  		320,
+  		384,
+  		132,
+  		240,
+  		360,
+  		432,
+  		144,
+  		280,
+  		408,
+  		480,
+  		168,
+  		308,
+  		448,
+  		532,
+  		180,
+  		338,
+  		504,
+  		588,
+  		196,
+  		364,
+  		546,
+  		650,
+  		224,
+  		416,
+  		600,
+  		700,
+  		224,
+  		442,
+  		644,
+  		750,
+  		252,
+  		476,
+  		690,
+  		816,
+  		270,
+  		504,
+  		750,
+  		900,
+  		300,
+  		560,
+  		810,
+  		960,
+  		312,
+  		588,
+  		870,
+  		1050,
+  		336,
+  		644,
+  		952,
+  		1110,
+  		360,
+  		700,
+  		1020,
+  		1200,
+  		390,
+  		728,
+  		1050,
+  		1260,
+  		420,
+  		784,
+  		1140,
+  		1350,
+  		450,
+  		812,
+  		1200,
+  		1440,
+  		480,
+  		868,
+  		1290,
+  		1530,
+  		510,
+  		924,
+  		1350,
+  		1620,
+  		540,
+  		980,
+  		1440,
+  		1710,
+  		570,
+  		1036,
+  		1530,
+  		1800,
+  		570,
+  		1064,
+  		1590,
+  		1890,
+  		600,
+  		1120,
+  		1680,
+  		1980,
+  		630,
+  		1204,
+  		1770,
+  		2100,
+  		660,
+  		1260,
+  		1860,
+  		2220,
+  		720,
+  		1316,
+  		1950,
+  		2310,
+  		750,
+  		1372,
+  		2040,
+  		2430
+  	];
+  	/**
+  	* 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;
+  		}
+  	};
+  	/**
+  	* 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;
+  		}
+  	};
+  }));
+  //#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 = /* @__PURE__ */ new Uint8Array(512);
+  	var LOG_TABLE = /* @__PURE__ */ 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 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);
+  	}
+  	/**
+  	* 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 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 = /* @__PURE__ */ new RegExp("^[0-9]+$");
+  	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: [
+  			10,
+  			12,
+  			14
+  		]
+  	};
+  	/**
+  	* 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: [
+  			9,
+  			11,
+  			13
+  		]
+  	};
+  	/**
+  	* In byte mode, data is encoded at 8 bits per character.
+  	*
+  	* @type {Object}
+  	*/
+  	exports.BYTE = {
+  		id: "Byte",
+  		bit: 4,
+  		ccBits: [
+  			8,
+  			16,
+  			16
+  		]
+  	};
+  	/**
+  	* 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: [
+  			8,
+  			10,
+  			12
+  		]
+  	};
+  	/**
+  	* 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);
+  		}
+  	}
+  	/**
+  	* 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 fromString(value);
+  		} catch (e) {
+  			return defaultValue;
+  		}
+  	};
+  }));
+  //#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 getReservedBitsCount(mode, version) {
+  		return Mode.getCharCountIndicator(mode, version) + 4;
+  	}
+  	function getTotalBitsFromDataArray(segments, version) {
+  		let totalBits = 0;
+  		segments.forEach(function(data) {
+  			const reservedBits = getReservedBitsCount(data.mode, version);
+  			totalBits += reservedBits + data.getBitsLength();
+  		});
+  		return totalBits;
+  	}
+  	function getBestVersionForMixedData(segments, errorCorrectionLevel) {
+  		for (let currentVersion = 1; currentVersion <= 40; currentVersion++) if (getTotalBitsFromDataArray(segments, currentVersion) <= exports.getCapacity(currentVersion, errorCorrectionLevel, Mode.MIXED)) return currentVersion;
+  	}
+  	/**
+  	* 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);
+  		}
+  	};
+  	/**
+  	* 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();
+  	}
+  	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;
+  	};
+  	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;
+  	}
+  	AlphanumericData.getBitsLength = function getBitsLength(length) {
+  		return 11 * Math.floor(length / 2) + 6 * (length % 2);
+  	};
+  	AlphanumericData.prototype.getLength = function getLength() {
+  		return this.data.length;
+  	};
+  	AlphanumericData.prototype.getBitsLength = function getBitsLength() {
+  		return AlphanumericData.getBitsLength(this.data.length);
+  	};
+  	AlphanumericData.prototype.write = function write(bitBuffer) {
+  		let i = 0;
+  		for (; i + 2 <= this.data.length; i += 2) {
+  			let value = ALPHA_NUM_CHARS.indexOf(this.data[i]) * 45;
+  			value += ALPHA_NUM_CHARS.indexOf(this.data[i + 1]);
+  			bitBuffer.put(value, 11);
+  		}
+  		if (this.data.length % 2) bitBuffer.put(ALPHA_NUM_CHARS.indexOf(this.data[i]), 6);
+  	};
+  	module.exports = AlphanumericData;
+  }));
+  //#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);
+  	}
+  	ByteData.getBitsLength = function getBitsLength(length) {
+  		return length * 8;
+  	};
+  	ByteData.prototype.getLength = function getLength() {
+  		return this.data.length;
+  	};
+  	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;
+  	}
+  	KanjiData.getBitsLength = function getBitsLength(length) {
+  		return length * 13;
+  	};
+  	KanjiData.prototype.getLength = function getLength() {
+  		return this.data.length;
+  	};
+  	KanjiData.prototype.getBitsLength = function getBitsLength() {
+  		return KanjiData.getBitsLength(this.data.length);
+  	};
+  	KanjiData.prototype.write = function(bitBuffer) {
+  		let i = 0;
+  		for (; 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);
+  		}
+  	};
+  	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 ",
+  					s,
+  					" to ",
+  					d,
+  					"."
+  				].join("");
+  				throw new Error(msg);
+  			}
+  			return predecessors;
+  		},
+  		extract_shortest_path_from_predecessor_list: function(predecessors, d) {
+  			var nodes = [];
+  			var u = d;
+  			while (u) {
+  				nodes.push(u);
+  				predecessors[u];
+  				u = predecessors[u];
+  			}
+  			nodes.reverse();
+  			return nodes;
+  		},
+  		find_path: function(graph, s, d) {
+  			var predecessors = dijkstra.single_source_shortest_paths(graph, s, d);
+  			return dijkstra.extract_shortest_path_from_predecessor_list(predecessors, d);
+  		},
+  		/**
+  		* A very naive priority queue implementation.
+  		*/
+  		PriorityQueue: {
+  			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(a, b) {
+  				return a.cost - b.cost;
+  			},
+  			/**
+  			* Add a new item to the queue and ensure the highest priority element
+  			* is at the front of the queue.
+  			*/
+  			push: function(value, cost) {
+  				var item = {
+  					value,
+  					cost
+  				};
+  				this.queue.push(item);
+  				this.queue.sort(this.sorter);
+  			},
+  			/**
+  			* Return the highest priority element in the queue.
+  			*/
+  			pop: function() {
+  				return this.queue.shift();
+  			},
+  			empty: function() {
+  				return this.queue.length === 0;
+  			}
+  		}
+  	};
+  	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;
+  	}
+  	/**
+  	* 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 segments;
+  	}
+  	/**
+  	* 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: obj.data,
+  				mode: obj.mode,
+  				length: obj.length
+  			};
+  		});
+  	}
+  	/**
+  	* 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);
+  		}
+  	}
+  	/**
+  	* 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;
+  		}, []);
+  	}
+  	/**
+  	* 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: seg.data,
+  							mode: Mode.ALPHANUMERIC,
+  							length: seg.length
+  						},
+  						{
+  							data: seg.data,
+  							mode: Mode.BYTE,
+  							length: seg.length
+  						}
+  					]);
+  					break;
+  				case Mode.ALPHANUMERIC:
+  					nodes.push([seg, {
+  						data: seg.data,
+  						mode: Mode.BYTE,
+  						length: seg.length
+  					}]);
+  					break;
+  				case Mode.KANJI:
+  					nodes.push([seg, {
+  						data: seg.data,
+  						mode: Mode.BYTE,
+  						length: getStringByteLength(seg.data)
+  					}]);
+  					break;
+  				case Mode.BYTE: nodes.push([{
+  					data: seg.data,
+  					mode: Mode.BYTE,
+  					length: getStringByteLength(seg.data)
+  				}]);
+  			}
+  		}
+  		return nodes;
+  	}
+  	/**
+  	* 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
+  				};
+  				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);
+  					}
+  				}
+  			}
+  			prevNodeIds = currentNodeIds;
+  		}
+  		for (let n = 0; n < prevNodeIds.length; n++) graph[prevNodeIds[n]].end = 0;
+  		return {
+  			map: graph,
+  			table
+  		};
+  	}
+  	/**
+  	* 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);
+  		}
+  	}
+  	/**
+  	* 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;
+  		}, []);
+  	};
+  	/**
+  	* 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);
+  				}
+  			}
+  		}
+  	}
+  	/**
+  	* 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);
+  		}
+  	}
+  	/**
+  	* 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);
+  		}
+  	}
+  	/**
+  	* 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);
+  		}
+  	}
+  	/**
+  	* 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);
+  	}
+  	/**
+  	* 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;
+  				}
+  			}
+  		}
+  	}
+  	/**
+  	* 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);
+  		});
+  		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);
+  	}
+  	/**
+  	* 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);
+  		}
+  		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;
+  	}
+  	/**
+  	* 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);
+  			}
+  			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
+  		};
+  	}
+  	/**
+  	* 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: hexValue >> 24 & 255,
+  			g: hexValue >> 16 & 255,
+  			b: hexValue >> 8 & 255,
+  			a: hexValue & 255,
+  			hex: "#" + hexCode.slice(0, 6).join("")
+  		};
+  	}
+  	exports.getOptions = function getOptions(options) {
+  		if (!options) options = {};
+  		if (!options.color) options.color = {};
+  		const margin = typeof options.margin === "undefined" || options.margin === null || options.margin < 0 ? 4 : options.margin;
+  		const width = options.width && options.width >= 21 ? options.width : void 0;
+  		const scale = options.scale || 4;
+  		return {
+  			width,
+  			scale: width ? 4 : scale,
+  			margin,
+  			color: {
+  				dark: hex2rgba(options.color.dark || "#000000ff"),
+  				light: hex2rgba(options.color.light || "#ffffffff")
+  			},
+  			type: options.type,
+  			rendererOpts: options.rendererOpts || {}
+  		};
+  	};
+  	exports.getScale = function getScale(qrSize, opts) {
+  		return opts.width && opts.width >= qrSize + opts.margin * 2 ? opts.width / (qrSize + opts.margin * 2) : opts.scale;
+  	};
+  	exports.getImageWidth = function getImageWidth(qrSize, opts) {
+  		const scale = exports.getScale(qrSize, opts);
+  		return Math.floor((qrSize + opts.margin * 2) * scale);
+  	};
+  	exports.qrToImageData = function qrToImageData(imgData, qr, opts) {
+  		const size = qr.modules.size;
+  		const data = qr.modules.data;
+  		const scale = exports.getScale(size, opts);
+  		const symbolSize = Math.floor((size + opts.margin * 2) * scale);
+  		const scaledMargin = opts.margin * scale;
+  		const palette = [opts.color.light, opts.color.dark];
+  		for (let i = 0; i < symbolSize; i++) for (let j = 0; j < symbolSize; j++) {
+  			let posDst = (i * symbolSize + j) * 4;
+  			let pxColor = opts.color.light;
+  			if (i >= scaledMargin && j >= scaledMargin && i < symbolSize - scaledMargin && j < symbolSize - scaledMargin) {
+  				const iSrc = Math.floor((i - scaledMargin) / scale);
+  				const jSrc = Math.floor((j - scaledMargin) / scale);
+  				pxColor = palette[data[iSrc * size + jSrc] ? 1 : 0];
+  			}
+  			imgData[posDst++] = pxColor.r;
+  			imgData[posDst++] = pxColor.g;
+  			imgData[posDst++] = pxColor.b;
+  			imgData[posDst] = pxColor.a;
+  		}
+  	};
+  }));
+  //#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 getCanvasElement() {
+  		try {
+  			return document.createElement("canvas");
+  		} catch (e) {
+  			throw new Error("You need to specify a canvas element");
+  		}
+  	}
+  	exports.render = function render(qrData, canvas, options) {
+  		let opts = options;
+  		let canvasEl = canvas;
+  		if (typeof opts === "undefined" && (!canvas || !canvas.getContext)) {
+  			opts = canvas;
+  			canvas = void 0;
+  		}
+  		if (!canvas) canvasEl = getCanvasElement();
+  		opts = Utils.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 svgCmd(cmd, x, y) {
+  		let str = cmd + x;
+  		if (typeof y !== "undefined") str += " " + y;
+  		return str;
+  	}
+  	function qrToPath(data, size, margin) {
+  		let path = "";
+  		let moveBy = 0;
+  		let newRow = false;
+  		let lineLength = 0;
+  		for (let i = 0; i < data.length; i++) {
+  			const col = Math.floor(i % size);
+  			const row = Math.floor(i / size);
+  			if (!col && !newRow) newRow = true;
+  			if (data[i]) {
+  				lineLength++;
+  				if (!(i > 0 && col > 0 && data[i - 1])) {
+  					path += newRow ? svgCmd("M", col + margin, .5 + row + margin) : svgCmd("m", moveBy, 0);
+  					moveBy = 0;
+  					newRow = false;
+  				}
+  				if (!(col + 1 < size && data[i + 1])) {
+  					path += svgCmd("h", lineLength);
+  					lineLength = 0;
+  				}
+  			} else moveBy++;
+  		}
+  		return path;
+  	}
+  	exports.render = function render(qrData, options, cb) {
+  		const opts = Utils.getOptions(options);
+  		const size = qrData.modules.size;
+  		const data = qrData.modules.data;
+  		const qrcodesize = size + opts.margin * 2;
+  		const bg = !opts.color.light.a ? "" : "<path " + getColorAttrib(opts.color.light, "fill") + " d=\"M0 0h" + qrcodesize + "v" + qrcodesize + "H0z\"/>";
+  		const path = "<path " + getColorAttrib(opts.color.dark, "stroke") + " d=\"" + qrToPath(data, size, opts.margin) + "\"/>";
+  		const viewBox = "viewBox=\"0 0 " + qrcodesize + " " + qrcodesize + "\"";
+  		const svgTag = "<svg xmlns=\"http://www.w3.org/2000/svg\" " + (!opts.width ? "" : "width=\"" + opts.width + "\" height=\"" + opts.width + "\" ") + viewBox + " shape-rendering=\"crispEdges\">" + bg + path + "</svg>\n";
+  		if (typeof cb === "function") cb(null, svgTag);
+  		return svgTag;
+  	};
+  }));
+  //#endregion
+  //#region src/qr/limits.ts
+  var import_browser = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports) => {
+  	var canPromise = require_can_promise();
+  	var QRCode = require_qrcode();
+  	var CanvasRenderer = require_canvas();
+  	var SvgRenderer = require_svg_tag();
+  	function renderCanvas(renderFunc, canvas, text, opts, cb) {
+  		const args = [].slice.call(arguments, 1);
+  		const argsNum = args.length;
+  		const isLastArgCb = typeof args[argsNum - 1] === "function";
+  		if (!isLastArgCb && !canPromise()) throw new Error("Callback required as last argument");
+  		if (isLastArgCb) {
+  			if (argsNum < 2) throw new Error("Too few arguments provided");
+  			if (argsNum === 2) {
+  				cb = text;
+  				text = canvas;
+  				canvas = opts = void 0;
+  			} else if (argsNum === 3) {
+  				if (canvas.getContext && typeof cb === "undefined") {
+  					cb = opts;
+  					opts = void 0;
+  				} else {
+  					cb = opts;
+  					opts = text;
+  					text = canvas;
+  					canvas = void 0;
+  				}
+  			}
+  		} else {
+  			if (argsNum < 1) throw new Error("Too few arguments provided");
+  			if (argsNum === 1) {
+  				text = canvas;
+  				canvas = opts = void 0;
+  			} else if (argsNum === 2 && !canvas.getContext) {
+  				opts = text;
+  				text = canvas;
+  				canvas = void 0;
+  			}
+  			return new Promise(function(resolve, reject) {
+  				try {
+  					resolve(renderFunc(QRCode.create(text, opts), canvas, opts));
+  				} catch (e) {
+  					reject(e);
+  				}
+  			});
+  		}
+  		try {
+  			const data = QRCode.create(text, opts);
+  			cb(null, renderFunc(data, canvas, opts));
+  		} catch (e) {
+  			cb(e);
+  		}
+  	}
+  	exports.create = QRCode.create;
+  	exports.toCanvas = renderCanvas.bind(null, CanvasRenderer.render);
+  	exports.toDataURL = renderCanvas.bind(null, CanvasRenderer.renderToDataURL);
+  	exports.toString = renderCanvas.bind(null, function(data, _, opts) {
+  		return SvgRenderer.render(data, opts);
+  	});
+  })))(), 1);
+  /**
+  * Transport limits with their units and boundary conditions.
+  *
+  * Every length here counts characters. Payloads are restricted to printable
+  * ASCII, so one character is one UTF-16 code unit and one byte; character
+  * counts and byte counts agree.
+  */
+  /**
+  * Largest carried message. Boundary: 1 <= messageLength <= MAX_MESSAGE_LENGTH;
+  * zero is rejected.
+  *
+  * The effective ceiling is lower than this value for most error correction
+  * levels, because MAX_PART_COUNT parts of (QR version 40 capacity - envelope
+  * header) characters run out first:
+  *
+  *   L: 2953 - 362 = 2591 chars/part -> 165,824 for 64 parts (this value binds)
+  *   M: 2331 - 362 = 1969 chars/part -> 126,016 for 64 parts (part count binds)
+  *   Q: 1663 - 362 = 1301 chars/part ->  83,264 for 64 parts (part count binds)
+  *   H: 1273 - 362 =  911 chars/part ->  58,304 for 64 parts (part count binds)
+  *
+  * Exceeding either ceiling fails while splitting, with `message-too-large` or
+  * `too-many-parts`.
+  */
+  var MAX_MESSAGE_LENGTH = 131072;
+  /**
+  * Payload characters per part. Always larger than the capacity a QR symbol can
+  * actually carry, so this is a guard against hostile input rather than the
+  * value that drives splitting.
+  */
+  var MAX_CHUNK_LENGTH = 4096;
+  /** Largest accepted QR text. Covers the envelope header plus its payload. */
+  var MAX_PART_TEXT_LENGTH = 8192;
+  //#endregion
+  //#region src/qr/envelope.ts
+  /**
+  * Transport format identifier.
+  *
+  * `twmp-qr/1` from turbowarp-realtime-motion-capture is the starting point, but
+  * this format adds three required fields (`senderPeerId`, `targetPeerId`, and
+  * `replyTo`) that the older one cannot express, so it gets its own namespace
+  * and version. `twmp-qr/1` is rejected with `unsupported-protocol` rather than
+  * accepted in a compatibility mode: an explicit failure is safer than an
+  * ambiguous acceptance that could pair the wrong peers.
+  */
+  var QR_PROTOCOL = "twqr/1";
+  /** Printable ASCII. Pairing codes are base64url, so this never rejects a valid payload. */
+  var printableAscii$1 = /^[ -~]+$/u;
+  var base64Url = /^[A-Za-z0-9_-]+$/u;
+  /** Separator for identity keys. Cannot occur in printable-ASCII fields. */
+  var identitySeparator = "\0";
+  function serializeEnvelope(envelope) {
+  	validateEnvelope(envelope);
+  	return JSON.stringify(envelope);
+  }
+  function parseEnvelope(text) {
+  	if (typeof text !== "string") throw new QrPairingError("invalid-json", "QR part must be text.");
+  	if (text.length > 8192) throw new QrPairingError("part-too-large", `QR part text must be at most ${MAX_PART_TEXT_LENGTH} characters.`);
+  	let parsed;
+  	try {
+  		parsed = JSON.parse(text);
+  	} catch (error) {
+  		throw new QrPairingError("invalid-json", "QR part is not valid JSON.", { cause: error });
+  	}
+  	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new QrPairingError("invalid-envelope", "QR part must be an object.");
+  	const envelope = parsed;
+  	validateEnvelope(envelope);
+  	return envelope;
+  }
+  function validateEnvelope(envelope) {
+  	if (envelope.protocol !== "twqr/1") throw new QrPairingError("unsupported-protocol", `QR part protocol must be ${QR_PROTOCOL}.`);
+  	requireIdentifier(envelope.sessionId, "session ID");
+  	requireIdentifier(envelope.senderPeerId, "sender peer ID");
+  	requireIdentifier(envelope.targetPeerId, "target peer ID");
+  	requireIdentifier(envelope.messageId, "message ID");
+  	if (envelope.kind !== "offer" && envelope.kind !== "answer") throw new QrPairingError("invalid-envelope", "QR message kind must be offer or answer.");
+  	if (envelope.kind === "answer") requireIdentifier(envelope.replyTo, "reply-to message ID");
+  	else if (envelope.replyTo !== "") throw new QrPairingError("invalid-envelope", "An offer QR part must not set reply-to.");
+  	if (!Number.isSafeInteger(envelope.createdAt) || envelope.createdAt < 0) throw new QrPairingError("invalid-envelope", "QR creation timestamp is invalid.");
+  	if (!Number.isInteger(envelope.partCount) || envelope.partCount < 1 || envelope.partCount > 64) throw new QrPairingError("invalid-envelope", `QR part count must be between 1 and 64.`);
+  	if (!Number.isInteger(envelope.partIndex) || envelope.partIndex < 0 || envelope.partIndex >= envelope.partCount) throw new QrPairingError("index-out-of-range", "QR part index must be within the declared part count.");
+  	if (!Number.isInteger(envelope.messageLength) || envelope.messageLength < 1) throw new QrPairingError("invalid-envelope", "QR message length must be a positive integer.");
+  	if (envelope.messageLength > 131072) throw new QrPairingError("message-too-large", `QR message length must be at most ${MAX_MESSAGE_LENGTH} characters.`);
+  	if (typeof envelope.messageHash !== "string" || envelope.messageHash.length !== 43 || !base64Url.test(envelope.messageHash)) throw new QrPairingError("invalid-envelope", "QR message hash is malformed.");
+  	if (typeof envelope.payload !== "string" || envelope.payload.length > 4096) throw new QrPairingError("invalid-envelope", `QR part payload must be at most ${MAX_CHUNK_LENGTH} characters.`);
+  	if (envelope.payload.length > 0 && !printableAscii$1.test(envelope.payload)) throw new QrPairingError("invalid-envelope", "QR part payload must be printable ASCII.");
+  }
+  /**
+  * Everything that must agree across the parts of one message. `partIndex` and
+  * `payload` are the only fields allowed to differ.
+  */
+  function envelopeIdentity(envelope) {
+  	return [
+  		envelope.protocol,
+  		envelope.sessionId,
+  		envelope.senderPeerId,
+  		envelope.targetPeerId,
+  		envelope.kind,
+  		envelope.messageId,
+  		envelope.replyTo,
+  		envelope.createdAt,
+  		envelope.partCount,
+  		envelope.messageLength,
+  		envelope.messageHash
+  	].join(identitySeparator);
+  }
+  function requireIdentifier(value, label) {
+  	if (typeof value !== "string" || value.length < 1 || value.length > 128 || !printableAscii$1.test(value)) throw new QrPairingError("invalid-envelope", `Invalid ${label}.`);
+  	return value;
+  }
+  //#endregion
+  //#region src/qr/hash.ts
+  /**
+  * SHA-256 as unpadded base64url.
+  *
+  * The digest detects optical transport damage. It is not an authentication
+  * mechanism: anyone who can photograph the QR codes can also recompute it.
+  */
+  async function sha256Base64Url(value) {
+  	const bytes = new TextEncoder().encode(value);
+  	const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", bytes));
+  	let binary = "";
+  	for (const byte of digest) binary += String.fromCharCode(byte);
+  	return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/u, "");
+  }
+  //#endregion
+  //#region src/qr/courier.ts
+  var printableAscii = /^[ -~]+$/u;
+  /**
+  * Splits a pairing code into parts that each fit one QR symbol.
+  *
+  * The chunk length depends on the envelope header, which in turn depends on the
+  * part count, so the loop repeats until the two agree.
+  */
+  async function createParts(message, options) {
+  	requireMessage(message);
+  	const senderPeerId = requireIdentifier(options.senderPeerId, "sender peer ID");
+  	const targetPeerId = requireIdentifier(options.targetPeerId, "target peer ID");
+  	if (options.kind !== "offer" && options.kind !== "answer") throw new QrPairingError("invalid-argument", "QR message kind must be offer or answer.");
+  	const replyTo = options.kind === "answer" ? requireIdentifier(options.replyTo ?? "", "reply-to message ID") : "";
+  	if (options.kind === "offer" && (options.replyTo ?? "") !== "") throw new QrPairingError("invalid-argument", "An offer must not set reply-to.");
+  	const sessionId = requireIdentifier(options.sessionId ?? crypto.randomUUID(), "session ID");
+  	const createdAt = options.createdAt ?? Date.now();
+  	if (!Number.isSafeInteger(createdAt) || createdAt < 0) throw new QrPairingError("invalid-argument", "QR creation timestamp is invalid.");
+  	const errorCorrectionLevel = options.errorCorrectionLevel ?? "M";
+  	const messageHash = await sha256Base64Url(message);
+  	const messageId = `${sessionId}.${messageHash.slice(0, 12)}`;
+  	let partCount = 1;
+  	let chunkLength = 0;
+  	for (;;) {
+  		chunkLength = maximumPayloadLength({
+  			protocol: QR_PROTOCOL,
+  			sessionId,
+  			senderPeerId,
+  			targetPeerId,
+  			kind: options.kind,
+  			messageId,
+  			replyTo,
+  			createdAt,
+  			partIndex: partCount - 1,
+  			partCount,
+  			messageLength: message.length,
+  			messageHash,
+  			payload: ""
+  		}, errorCorrectionLevel);
+  		if (chunkLength < 1) throw new QrPairingError("invalid-envelope", "QR encoder capacity is too small for the part envelope.");
+  		const required = Math.ceil(message.length / chunkLength);
+  		if (required > 64) throw new QrPairingError("too-many-parts", `Splitting needs ${required} parts, which exceeds the limit of 64.`);
+  		if (required === partCount) break;
+  		partCount = required;
+  	}
+  	const parts = Array.from({ length: partCount }, (_unused, partIndex) => ({
+  		protocol: QR_PROTOCOL,
+  		sessionId,
+  		senderPeerId,
+  		targetPeerId,
+  		kind: options.kind,
+  		messageId,
+  		replyTo,
+  		createdAt,
+  		partIndex,
+  		partCount,
+  		messageLength: message.length,
+  		messageHash,
+  		payload: message.slice(partIndex * chunkLength, (partIndex + 1) * chunkLength)
+  	}));
+  	const texts = parts.map(serializeEnvelope);
+  	for (const text of texts) import_browser.create(text, { errorCorrectionLevel });
+  	return {
+  		parts,
+  		texts,
+  		sessionId,
+  		messageId
+  	};
+  }
+  /** Collects the parts of exactly one message and verifies the result. */
+  var PartAssembler = class {
+  	constructor() {
+  		this.parts = /* @__PURE__ */ new Map();
+  	}
+  	add(envelope) {
+  		const identity = envelopeIdentity(envelope);
+  		if (this.identity !== void 0 && this.identity !== identity) throw new QrPairingError("message-mismatch", "QR part does not belong to the message being assembled.");
+  		this.identity = identity;
+  		const existing = this.parts.get(envelope.partIndex);
+  		if (existing && existing.payload !== envelope.payload) throw new QrPairingError("conflicting-part", `QR part ${envelope.partIndex + 1} arrived twice with different content.`);
+  		this.parts.set(envelope.partIndex, envelope);
+  		return {
+  			received: this.parts.size,
+  			total: envelope.partCount,
+  			duplicate: existing !== void 0
+  		};
+  	}
+  	receivedCount() {
+  		return this.parts.size;
+  	}
+  	/** Zero until the first part arrives, because the part count is carried by the parts. */
+  	requiredCount() {
+  		return this.first()?.partCount ?? 0;
+  	}
+  	/** Zero-based indices that have not arrived yet, in ascending order. */
+  	missingParts() {
+  		const total = this.requiredCount();
+  		const missing = [];
+  		for (let index = 0; index < total; index += 1) if (!this.parts.has(index)) missing.push(index);
+  		return missing;
+  	}
+  	isComplete() {
+  		const total = this.requiredCount();
+  		return total > 0 && this.parts.size === total;
+  	}
+  	/** Joins the parts and verifies length and hash before returning anything. */
+  	async assemble() {
+  		const first = this.first();
+  		if (!first) throw new QrPairingError("missing-parts", "No QR parts have been received.");
+  		if (this.parts.size !== first.partCount) throw new QrPairingError("missing-parts", `QR message is missing ${first.partCount - this.parts.size} of ${first.partCount} parts.`);
+  		const message = Array.from({ length: first.partCount }, (_unused, index) => {
+  			const part = this.parts.get(index);
+  			if (!part) throw new QrPairingError("missing-parts", `QR message is missing part ${index + 1}.`);
+  			return part.payload;
+  		}).join("");
+  		if (message.length !== first.messageLength) throw new QrPairingError("length-mismatch", "Reassembled QR message has the wrong length.");
+  		if (await sha256Base64Url(message) !== first.messageHash) throw new QrPairingError("hash-mismatch", "Reassembled QR message failed its hash check.");
+  		return message;
+  	}
+  	clear() {
+  		this.parts.clear();
+  		this.identity = void 0;
+  	}
+  	first() {
+  		return this.parts.values().next().value;
+  	}
+  };
+  /**
+  * Largest payload that still lets the whole envelope fit a version 40 symbol at
+  * the given error correction level.
+  */
+  function maximumPayloadLength(base, errorCorrectionLevel) {
+  	let low = 0;
+  	let high = MAX_CHUNK_LENGTH;
+  	while (low < high) {
+  		const middle = Math.ceil((low + high) / 2);
+  		const text = JSON.stringify({
+  			...base,
+  			payload: "A".repeat(middle)
+  		});
+  		try {
+  			import_browser.create([{
+  				data: new TextEncoder().encode(text),
+  				mode: "byte"
+  			}], {
+  				version: 40,
+  				errorCorrectionLevel
+  			});
+  			low = middle;
+  		} catch {
+  			high = middle - 1;
+  		}
+  	}
+  	return low;
+  }
+  function requireMessage(value) {
+  	if (typeof value !== "string" || value.length < 1) throw new QrPairingError("invalid-argument", "Pairing code is empty.");
+  	if (value.length > 131072) throw new QrPairingError("message-too-large", `Pairing code must be at most ${MAX_MESSAGE_LENGTH} characters.`);
+  	if (!printableAscii.test(value)) throw new QrPairingError("invalid-argument", "Pairing code must be printable ASCII.");
+  }
+  //#endregion
+  //#region src/qr/svg.ts
+  var QUIET_ZONE_MODULES = 4;
+  function createQrSvg(text, errorCorrectionLevel = "M") {
+  	const qr = import_browser.create([{
+  		data: new TextEncoder().encode(text),
+  		mode: "byte"
+  	}], { errorCorrectionLevel });
+  	const size = qr.modules.size;
+  	const viewSize = size + 8;
+  	const commands = [];
+  	for (let row = 0; row < size; row += 1) for (let column = 0; column < size; column += 1) if (qr.modules.get(row, column)) commands.push(`M${column + QUIET_ZONE_MODULES} ${row + QUIET_ZONE_MODULES}h1v1h-1z`);
+  	return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${viewSize} ${viewSize}" shape-rendering="crispEdges"><rect width="100%" height="100%" fill="#fff"/><path d="${commands.join("")}" fill="#000"/></svg>`;
+  }
+  //#endregion
+  //#region src/pairing/limits.ts
+  var MAX_TIMEOUT_SECONDS = 3600;
+  //#endregion
+  //#region src/pairing/types.ts
+  var terminalPhases = /* @__PURE__ */ new Set([
+  	"connected",
+  	"cancelled",
+  	"expired",
+  	"failed"
+  ]);
+  function isTerminalPhase(phase) {
+  	return terminalPhases.has(phase);
+  }
+  //#endregion
+  //#region src/ports/display.ts
+  /**
+  * Swaps a sprite's skin for a QR image and puts the original back.
+  *
+  * The original skin ID is captured on the first swap so that repeated part
+  * changes never lose it, and every exit path restores it: ending the display,
+  * cancelling, stopping the project, removing the sprite, or disposing the
+  * runtime.
+  */
+  var TemporarySpriteSkinManager = class {
+  	constructor(runtime) {
+  		this.runtime = runtime;
+  		this.displays = /* @__PURE__ */ new Map();
+  	}
+  	validateTarget(target) {
+  		if (!target || target.isStage) throw new QrPairingError("invalid-argument", "A pairing QR must be displayed on a sprite target.");
+  		if (target.isOriginal === false) throw new QrPairingError("invalid-argument", "Pairing QR display does not support sprite clones.");
+  		if (!Number.isInteger(target.drawableID) || Number(target.drawableID) < 0) throw new QrPairingError("renderer-unavailable", "The pairing QR sprite target has no valid drawable.");
+  		return target;
+  	}
+  	show(targetValue, svg) {
+  		const target = this.validateTarget(targetValue);
+  		const renderer = requireRenderer(this.runtime.renderer);
+  		const drawableId = Number(target.drawableID);
+  		const current = this.displays.get(target);
+  		const originalSkinId = current?.originalSkinId ?? currentSkinId(renderer, drawableId);
+  		const temporarySkinId = renderer.createSVGSkin(svg);
+  		if (!Number.isInteger(temporarySkinId) || temporarySkinId < 0) throw new QrPairingError("renderer-unavailable", "The renderer could not create a temporary QR skin.");
+  		try {
+  			renderer.updateDrawableSkinId(drawableId, temporarySkinId);
+  		} catch (error) {
+  			renderer.destroySkin(temporarySkinId);
+  			throw new QrPairingError("renderer-unavailable", "The renderer could not display the temporary QR skin.", { cause: error });
+  		}
+  		this.displays.set(target, {
+  			target,
+  			drawableId,
+  			originalSkinId,
+  			temporarySkinId
+  		});
+  		if (current) renderer.destroySkin(current.temporarySkinId);
+  		this.runtime.requestRedraw?.();
+  		return target;
+  	}
+  	releaseTarget(target) {
+  		const record = this.displays.get(target);
+  		if (!record) return;
+  		this.displays.delete(target);
+  		const renderer = this.runtime.renderer;
+  		try {
+  			if (renderer?.updateDrawableSkinId && this.runtime.targets?.includes(target) !== false) renderer.updateDrawableSkinId(record.drawableId, record.originalSkinId);
+  		} finally {
+  			renderer?.destroySkin?.(record.temporarySkinId);
+  			this.runtime.requestRedraw?.();
+  		}
+  	}
+  	releaseAll() {
+  		for (const target of [...this.displays.keys()]) this.releaseTarget(target);
+  	}
+  	isDisplaying(target) {
+  		return this.displays.has(target);
+  	}
+  };
+  function requireRenderer(renderer) {
+  	if (!renderer || typeof renderer.createSVGSkin !== "function" || typeof renderer.destroySkin !== "function" || typeof renderer.updateDrawableSkinId !== "function") throw new QrPairingError("renderer-unavailable", "The TurboWarp renderer does not provide temporary SVG skin APIs.");
+  	return renderer;
+  }
+  function currentSkinId(renderer, drawableId) {
+  	const skinId = renderer._allDrawables?.[drawableId]?._skin?._id;
+  	if (!Number.isInteger(skinId) || Number(skinId) < 0) throw new QrPairingError("renderer-unavailable", "The renderer could not determine the sprite original skin.");
+  	return Number(skinId);
+  }
+  //#endregion
+  //#region src/ports/qr-scan.ts
+  var QR_DECODER_KEY = "ext_kubohiroyajsqr";
+  var CAMERA_SOURCE_KEY = "ext_kubohiroyacamerasource";
+  /**
+  * Reads QR texts from a camera for the length of a pairing session.
+  *
+  * The jsQR extension's own `waitForQrText` acquires and releases a camera lease
+  * per call, which would restart the camera between every part. This holds one
+  * lease for the whole session instead and reuses jsQR only for decoding, so the
+  * camera-source lease rules are respected and other holders keep the camera
+  * alive after the session ends.
+  */
+  var CameraQrScanner = class {
+  	constructor(runtime, owner) {
+  		this.runtime = runtime;
+  		this.owner = owner;
+  		this.leasedCameraId = "";
+  	}
+  	async scanOnce(options) {
+  		if (options.signal.aborted) throw cancelled();
+  		const decoder = this.decoder();
+  		const lease = await this.acquire(options.cameraId);
+  		if (options.signal.aborted) throw cancelled();
+  		const interval = Math.max(50, options.intervalMilliseconds ?? 150);
+  		return new Promise((resolve, reject) => {
+  			let timer;
+  			const cleanup = () => {
+  				if (timer !== void 0) clearTimeout(timer);
+  				options.signal.removeEventListener("abort", onAbort);
+  			};
+  			const onAbort = () => {
+  				cleanup();
+  				reject(cancelled());
+  			};
+  			const tick = () => {
+  				if (options.signal.aborted) {
+  					onAbort();
+  					return;
+  				}
+  				try {
+  					const text = decoder.scanFrame(lease.getFrameSource());
+  					if (text !== null) {
+  						cleanup();
+  						resolve(text);
+  						return;
+  					}
+  				} catch (error) {
+  					cleanup();
+  					reject(new QrPairingError("camera-unavailable", "Reading the camera frame failed.", { cause: error }));
+  					return;
+  				}
+  				timer = setTimeout(tick, interval);
+  			};
+  			options.signal.addEventListener("abort", onAbort, { once: true });
+  			tick();
+  		});
+  	}
+  	async release() {
+  		const lease = this.lease;
+  		this.lease = void 0;
+  		this.leasedCameraId = "";
+  		await lease?.release();
+  	}
+  	async acquire(cameraId) {
+  		if (this.lease && this.leasedCameraId === cameraId) return this.lease;
+  		await this.release();
+  		const lease = await this.cameraSource().acquireCamera({
+  			owner: this.owner,
+  			cameraId
+  		});
+  		this.lease = lease;
+  		this.leasedCameraId = cameraId;
+  		return lease;
+  	}
+  	decoder() {
+  		const candidate = this.runtime[QR_DECODER_KEY];
+  		if (!isRecord(candidate) || typeof candidate.scanFrame !== "function") throw new QrPairingError("qr-decoder-missing", "Scanning pairing QR codes requires @kubohiroya/turbowarp-jsqr.");
+  		return candidate;
+  	}
+  	cameraSource() {
+  		const candidate = this.runtime[CAMERA_SOURCE_KEY];
+  		if (!isRecord(candidate) || typeof candidate.acquireCamera !== "function") throw new QrPairingError("camera-unavailable", "Scanning pairing QR codes requires @kubohiroya/turbowarp-camera-source.");
+  		return candidate;
+  	}
+  };
+  function cancelled() {
+  	return new QrPairingError("cancelled", "QR scanning was cancelled.");
+  }
+  function isRecord(value) {
+  	return typeof value === "object" && value !== null;
+  }
+  //#endregion
+  //#region src/ports/webrtc.ts
+  var WEBRTC_CAPABILITY_KEY = "kubohiroyaWebRtcCapability";
+  var requiredMethods = [
+  	"requireVersion",
+  	"createOffer",
+  	"getOffer",
+  	"acceptOffer",
+  	"getAnswer",
+  	"acceptAnswer",
+  	"connectionState",
+  	"closePeer"
+  ];
+  function requireWebRtcPairingPort(runtime) {
+  	const candidate = runtime[WEBRTC_CAPABILITY_KEY];
+  	if (typeof candidate !== "object" || candidate === null) throw new QrPairingError("webrtc-capability-missing", "TurboWarp WebRTC is not loaded.");
+  	const record = candidate;
+  	for (const method of requiredMethods) if (typeof record[method] !== "function") throw new QrPairingError("webrtc-capability-missing", `TurboWarp WebRTC runtime capability v3 is required.`);
+  	try {
+  		record.requireVersion(3);
+  	} catch (error) {
+  		throw new QrPairingError("webrtc-capability-missing", `TurboWarp WebRTC runtime capability v3 is required.`, { cause: error });
+  	}
+  	return candidate;
+  }
+  //#endregion
+  //#region src/pairing/controller.ts
+  /**
+  * Errors that only mean "that was not our QR code".
+  *
+  * A camera pointed at a projection also sees posters, other sessions, and the
+  * previous exchange's codes, so scanning skips these and keeps looking. Damage
+  * to a code that does belong to this exchange is not in this set: that is
+  * reported, because silently retrying would hide a real problem.
+  */
+  var skippableWhileScanning = /* @__PURE__ */ new Set([
+  	"invalid-json",
+  	"unsupported-protocol",
+  	"invalid-envelope",
+  	"part-too-large",
+  	"index-out-of-range",
+  	"message-too-large",
+  	"unexpected-kind",
+  	"stale-exchange",
+  	"peer-mismatch",
+  	"reply-mismatch",
+  	"message-mismatch"
+  ]);
+  var idlePhase = "idle";
+  /**
+  * Drives one QR-carried offer/answer exchange per session key.
+  *
+  * The controller owns no display and no camera: it turns pairing codes into QR
+  * texts, accepts decoded texts back, and hands verified codes to WebRTC exactly
+  * once. Display and scanning adapters build on top of it.
+  */
+  var PairingController = class {
+  	constructor(options = {}) {
+  		this.sessions = /* @__PURE__ */ new Map();
+  		this.activeScans = 0;
+  		this.runtime = options.runtime ?? Scratch.vm?.runtime ?? {};
+  		this.enabled = options.enabled ?? featureFlags.qrCodePairing;
+  		this.errorCorrectionLevel = options.errorCorrectionLevel ?? qrConfig.errorCorrectionLevel;
+  		this.injectedWebRtc = options.webrtc;
+  		this.injectedDisplay = options.display;
+  		this.injectedScan = options.scan;
+  		this.clock = options.clock ?? systemMonotonicClock;
+  		this.now = options.now ?? (() => Date.now());
+  	}
+  	/** Hub side: create an offer and prepare its QR parts. */
+  	async startOfferPairing(input) {
+  		this.requireEnabled();
+  		const sessionKey = requireSessionKey(input.sessionKey);
+  		if (this.sessions.has(sessionKey)) throw new QrPairingError("session-exists", `Pairing session ${sessionKey} is already open.`);
+  		this.requireCapacity();
+  		const localPeerId = requireIdentifier(input.localPeerId.trim(), "local peer name");
+  		const remotePeerId = requireIdentifier(input.remotePeerId.trim(), "remote peer name");
+  		const session = this.createSession({
+  			sessionKey,
+  			role: "hub",
+  			expectedLocalPeerId: localPeerId,
+  			localPeerId,
+  			remotePeerId
+  		});
+  		this.sessions.set(sessionKey, session);
+  		await this.runOfferExchange(session);
+  	}
+  	/**
+  	* Camera side: wait for an offer.
+  	*
+  	* `expectedLocalPeerId` may be empty, in which case this device adopts the
+  	* name the offer assigns to it. A non-empty value is verified instead, which
+  	* catches an operator scanning the wrong projection.
+  	*/
+  	startAnswerPairing(input) {
+  		this.requireEnabled();
+  		const sessionKey = requireSessionKey(input.sessionKey);
+  		if (this.sessions.has(sessionKey)) throw new QrPairingError("session-exists", `Pairing session ${sessionKey} is already open.`);
+  		this.requireCapacity();
+  		const expectedLocalPeerId = input.expectedLocalPeerId.trim();
+  		if (expectedLocalPeerId !== "") requireIdentifier(expectedLocalPeerId, "local peer name");
+  		const session = this.createSession({
+  			sessionKey,
+  			role: "camera",
+  			expectedLocalPeerId,
+  			localPeerId: expectedLocalPeerId,
+  			remotePeerId: ""
+  		});
+  		session.phase = "awaiting-offer";
+  		this.sessions.set(sessionKey, session);
+  		this.scheduleTick(session);
+  	}
+  	/**
+  	* Accepts one decoded QR text. When the last part arrives, the reassembled
+  	* code is verified and handed to WebRTC once.
+  	*/
+  	async ingestQrText(sessionKey, text) {
+  		this.requireEnabled();
+  		const session = this.requireSession(sessionKey);
+  		if (isTerminalPhase(session.phase)) throw new QrPairingError(session.phase === "connected" ? "already-accepted" : "stale-exchange", `Pairing session ${session.sessionKey} is no longer receiving parts.`);
+  		const envelope = parseEnvelope(text);
+  		this.verifyEnvelope(session, envelope);
+  		if (session.delivered) throw new QrPairingError("already-accepted", "The pairing code for this exchange has already been accepted.");
+  		if (session.role === "camera" && session.exchangeId === "") this.adoptOffer(session, envelope);
+  		session.assembler.add(envelope);
+  		if (!isTerminalPhase(session.phase)) session.phase = session.role === "hub" ? "awaiting-answer" : "receiving";
+  		if (!session.assembler.isComplete()) return;
+  		const epoch = session.epoch;
+  		let message;
+  		try {
+  			message = await session.assembler.assemble();
+  		} catch (error) {
+  			if (!this.isStale(session, epoch)) this.failFrom(session, error);
+  			throw error;
+  		}
+  		if (this.isStale(session, epoch)) return;
+  		session.incomingMessageId = envelope.messageId;
+  		session.phase = session.role === "hub" ? "answer-received" : "offer-received";
+  		session.delivered = true;
+  		if (session.role === "hub") await this.acceptAnswer(session, message, epoch);
+  		else await this.acceptOfferAndPrepareAnswer(session, message, epoch);
+  	}
+  	/** Selects the one-based part to display and returns its SVG. */
+  	selectPart(sessionKey, oneBasedIndex) {
+  		const session = this.requireSession(sessionKey);
+  		const total = session.outgoingSvgs.length;
+  		if (total === 0) throw new QrPairingError("no-session", "No QR parts have been prepared yet.");
+  		if (!Number.isInteger(oneBasedIndex) || oneBasedIndex < 1 || oneBasedIndex > total) throw new QrPairingError("invalid-argument", `QR part index must be between 1 and ${total}.`);
+  		session.outgoingCurrentIndex = oneBasedIndex - 1;
+  		return session.outgoingSvgs[session.outgoingCurrentIndex] ?? "";
+  	}
+  	/** Advances to the next part, wrapping from the last part to the first. */
+  	selectNextPart(sessionKey) {
+  		const session = this.requireSession(sessionKey);
+  		const total = session.outgoingSvgs.length;
+  		if (total === 0) throw new QrPairingError("no-session", "No QR parts have been prepared yet.");
+  		return this.selectPart(sessionKey, (session.outgoingCurrentIndex + 1) % total + 1);
+  	}
+  	partSvg(sessionKey, oneBasedIndex) {
+  		return this.requireSession(sessionKey).outgoingSvgs[oneBasedIndex - 1] ?? "";
+  	}
+  	partText(sessionKey, oneBasedIndex) {
+  		return this.requireSession(sessionKey).outgoing?.texts[oneBasedIndex - 1] ?? "";
+  	}
+  	/** Shows the one-based part on the supplied sprite, keeping its original skin. */
+  	showPart(sessionKey, oneBasedIndex, target) {
+  		const session = this.requireSession(sessionKey);
+  		const svg = this.selectPart(sessionKey, oneBasedIndex);
+  		session.displayTargets.add(this.display().show(target, svg));
+  	}
+  	showNextPart(sessionKey, target) {
+  		const session = this.requireSession(sessionKey);
+  		const svg = this.selectNextPart(sessionKey);
+  		session.displayTargets.add(this.display().show(target, svg));
+  	}
+  	/** Restores the sprites this session changed. The session itself stays open. */
+  	endDisplay(sessionKey) {
+  		this.releaseDisplay(this.requireSession(sessionKey));
+  	}
+  	/** Called when the runtime removes a sprite, so its skin is not restored onto nothing. */
+  	handleTargetRemoved(target) {
+  		for (const session of this.sessions.values()) {
+  			if (!session.displayTargets.delete(target)) continue;
+  			this.display().releaseTarget(target);
+  		}
+  	}
+  	/**
+  	* Reads parts from a camera until the exchange has everything it needs.
+  	*
+  	* Codes that belong to something else are skipped rather than reported: a
+  	* camera aimed at a projection also sees whatever else is in frame.
+  	*/
+  	async scanFromCamera(sessionKey, cameraId) {
+  		this.requireEnabled();
+  		const session = this.requireSession(sessionKey);
+  		const camera = cameraId.trim() || "default";
+  		if (session.scanAbort) throw new QrPairingError("invalid-argument", `Pairing session ${session.sessionKey} is already scanning.`);
+  		const epoch = session.epoch;
+  		const abort = new AbortController();
+  		session.scanAbort = abort;
+  		this.activeScans += 1;
+  		const scan = this.scanner();
+  		try {
+  			while (!this.isStale(session, epoch) && !isTerminalPhase(session.phase)) {
+  				if (session.delivered) return;
+  				const text = await scan.scanOnce({
+  					cameraId: camera,
+  					signal: abort.signal
+  				});
+  				if (this.isStale(session, epoch)) return;
+  				try {
+  					await this.ingestQrText(sessionKey, text);
+  				} catch (error) {
+  					if (!(error instanceof QrPairingError) || !skippableWhileScanning.has(error.code)) throw error;
+  				}
+  			}
+  		} catch (error) {
+  			if (error instanceof QrPairingError && error.code === "cancelled") return;
+  			throw error;
+  		} finally {
+  			if (session.scanAbort === abort) session.scanAbort = void 0;
+  			this.activeScans -= 1;
+  			if (this.activeScans === 0) await scan.release();
+  		}
+  	}
+  	cancelPairing(sessionKey) {
+  		const session = this.sessions.get(requireSessionKey(sessionKey));
+  		if (!session) return;
+  		this.finish(session, "cancelled", "", "");
+  	}
+  	/** Cancels the current exchange and starts a new one with a fresh exchange ID. */
+  	async retryPairing(sessionKey) {
+  		this.requireEnabled();
+  		const session = this.requireSession(sessionKey);
+  		this.finish(session, "cancelled", "", "");
+  		this.resetSession(session);
+  		if (session.role === "hub") await this.runOfferExchange(session);
+  		else {
+  			session.phase = "awaiting-offer";
+  			this.scheduleTick(session);
+  		}
+  	}
+  	setTimeoutSeconds(sessionKey, seconds) {
+  		const session = this.requireSession(sessionKey);
+  		if (!Number.isFinite(seconds) || seconds < 1 || seconds > 3600) throw new QrPairingError("invalid-argument", `Pairing timeout must be between 1 and ${MAX_TIMEOUT_SECONDS} seconds.`);
+  		session.timeoutMilliseconds = Math.floor(seconds * 1e3);
+  	}
+  	progress(sessionKey) {
+  		const session = this.sessions.get(sessionKey.trim());
+  		if (!session) return {
+  			phase: this.enabled ? idlePhase : "disabled",
+  			role: "hub",
+  			sessionKey: sessionKey.trim(),
+  			exchangeId: "",
+  			localPeerId: "",
+  			remotePeerId: "",
+  			outgoingPartCount: 0,
+  			outgoingCurrentPart: 0,
+  			receivedParts: 0,
+  			requiredParts: 0,
+  			missingParts: [],
+  			connectionState: "",
+  			errorCode: "",
+  			errorMessage: "",
+  			remainingSeconds: 0
+  		};
+  		const elapsed = this.clock.nowMilliseconds() - session.startedAtMonotonic;
+  		const remaining = Math.max(0, session.timeoutMilliseconds - elapsed);
+  		return {
+  			phase: this.enabled ? session.phase : "disabled",
+  			role: session.role,
+  			sessionKey: session.sessionKey,
+  			exchangeId: session.exchangeId,
+  			localPeerId: session.localPeerId,
+  			remotePeerId: session.remotePeerId,
+  			outgoingPartCount: session.outgoingSvgs.length,
+  			outgoingCurrentPart: session.outgoingCurrentIndex + 1,
+  			receivedParts: session.assembler.receivedCount(),
+  			requiredParts: session.assembler.requiredCount(),
+  			missingParts: session.assembler.missingParts().map((index) => index + 1),
+  			connectionState: session.peerCreated ? this.readConnectionState(session) : "",
+  			errorCode: session.errorCode,
+  			errorMessage: session.errorMessage,
+  			remainingSeconds: isTerminalPhase(session.phase) ? 0 : Math.ceil(remaining / 1e3)
+  		};
+  	}
+  	sessionKeys() {
+  		return [...this.sessions.keys()];
+  	}
+  	isConnected(sessionKey) {
+  		return this.sessions.get(sessionKey.trim())?.phase === "connected";
+  	}
+  	/** Resolves on connection, rejects on failure, cancellation, or expiry. */
+  	waitUntilConnected(sessionKey) {
+  		const session = this.requireSession(sessionKey);
+  		if (session.phase === "connected") return Promise.resolve();
+  		if (isTerminalPhase(session.phase)) return Promise.reject(this.terminalError(session));
+  		return new Promise((resolve, reject) => {
+  			session.waiters.push({
+  				resolve,
+  				reject
+  			});
+  		});
+  	}
+  	/**
+  	* Project run stop. Cancels exchanges in progress and releases what this
+  	* controller owns. Established connections stay up: closing them is the
+  	* application's explicit decision.
+  	*/
+  	stopTransient() {
+  		for (const session of [...this.sessions.values()]) {
+  			if (session.phase === "connected") {
+  				this.clearTimer(session);
+  				session.scanAbort?.abort();
+  				this.releaseDisplay(session);
+  				continue;
+  			}
+  			this.finish(session, "cancelled", "", "");
+  		}
+  		this.releaseScanner();
+  	}
+  	/** Runtime disposal. Drops every session and its retained state. */
+  	dispose() {
+  		for (const session of [...this.sessions.values()]) this.finish(session, "cancelled", "", "");
+  		this.sessions.clear();
+  		this.lazyDisplay?.releaseAll();
+  		this.releaseScanner();
+  	}
+  	async runOfferExchange(session) {
+  		const epoch = session.epoch;
+  		session.phase = "creating-offer";
+  		this.scheduleTick(session);
+  		try {
+  			const webrtc = this.webrtc();
+  			const created = await webrtc.createOffer(session.remotePeerId);
+  			if (this.isStale(session, epoch)) return;
+  			session.peerCreated = true;
+  			const code = created || webrtc.getOffer(session.remotePeerId);
+  			if (!code) throw new QrPairingError("webrtc-rejected", "TurboWarp WebRTC did not return an offer pairing code.");
+  			const parts = await createParts(code, this.partOptions(session, "offer"));
+  			if (this.isStale(session, epoch)) return;
+  			this.attachOutgoing(session, parts);
+  			session.phase = "offer-ready";
+  		} catch (error) {
+  			if (!this.isStale(session, epoch)) this.failFrom(session, error);
+  			throw error;
+  		}
+  	}
+  	async acceptAnswer(session, message, epoch) {
+  		try {
+  			await this.webrtc().acceptAnswer(session.remotePeerId, message);
+  			if (this.isStale(session, epoch)) return;
+  			session.phase = "connecting";
+  			this.scheduleTick(session);
+  		} catch (error) {
+  			if (!this.isStale(session, epoch)) this.failFrom(session, error);
+  			throw error;
+  		}
+  	}
+  	async acceptOfferAndPrepareAnswer(session, message, epoch) {
+  		session.phase = "creating-answer";
+  		try {
+  			const webrtc = this.webrtc();
+  			const created = await webrtc.acceptOffer(session.remotePeerId, message);
+  			if (this.isStale(session, epoch)) return;
+  			session.peerCreated = true;
+  			const code = created || webrtc.getAnswer(session.remotePeerId);
+  			if (!code) throw new QrPairingError("webrtc-rejected", "TurboWarp WebRTC did not return an answer pairing code.");
+  			const parts = await createParts(code, this.partOptions(session, "answer"));
+  			if (this.isStale(session, epoch)) return;
+  			this.attachOutgoing(session, parts);
+  			session.phase = "answer-ready";
+  			this.scheduleTick(session);
+  		} catch (error) {
+  			if (!this.isStale(session, epoch)) this.failFrom(session, error);
+  			throw error;
+  		}
+  	}
+  	partOptions(session, kind) {
+  		const common = {
+  			senderPeerId: session.localPeerId,
+  			targetPeerId: session.remotePeerId,
+  			errorCorrectionLevel: this.errorCorrectionLevel,
+  			createdAt: this.now()
+  		};
+  		return kind === "offer" ? {
+  			...common,
+  			kind
+  		} : {
+  			...common,
+  			kind,
+  			sessionId: session.exchangeId,
+  			replyTo: session.incomingMessageId
+  		};
+  	}
+  	attachOutgoing(session, parts) {
+  		session.outgoing = parts;
+  		session.outgoingSvgs = parts.texts.map((text) => createQrSvg(text, this.errorCorrectionLevel));
+  		session.outgoingCurrentIndex = -1;
+  		session.exchangeId = parts.sessionId;
+  		session.outgoingMessageId = parts.messageId;
+  	}
+  	/**
+  	* Checks that a part belongs to this exchange, this role, and this peer pair
+  	* before any of it reaches the assembler.
+  	*/
+  	verifyEnvelope(session, envelope) {
+  		const expectedKind = session.role === "hub" ? "answer" : "offer";
+  		if (envelope.kind !== expectedKind) throw new QrPairingError("unexpected-kind", `This session expects ${expectedKind} parts.`);
+  		if (session.role === "hub") {
+  			if (envelope.sessionId !== session.exchangeId) throw new QrPairingError("stale-exchange", "QR part belongs to a different pairing exchange.");
+  			if (envelope.replyTo !== session.outgoingMessageId) throw new QrPairingError("reply-mismatch", "QR part answers a different offer.");
+  			if (envelope.senderPeerId !== session.remotePeerId || envelope.targetPeerId !== session.localPeerId) throw new QrPairingError("peer-mismatch", "QR part names a different pair of peers.");
+  			return;
+  		}
+  		if (session.exchangeId !== "" && envelope.sessionId !== session.exchangeId) throw new QrPairingError("stale-exchange", "QR part belongs to a different pairing exchange.");
+  		if (session.expectedLocalPeerId !== "" && envelope.targetPeerId !== session.expectedLocalPeerId) throw new QrPairingError("peer-mismatch", "QR part is addressed to a different device.");
+  		if (session.remotePeerId !== "" && envelope.senderPeerId !== session.remotePeerId) throw new QrPairingError("peer-mismatch", "QR part names a different sender.");
+  	}
+  	/**
+  	* Adopts the peer naming the offer carries. The sender's name for itself
+  	* becomes this device's WebRTC peer key, so the two ends never need to be
+  	* configured with the same identifiers.
+  	*/
+  	adoptOffer(session, envelope) {
+  		session.exchangeId = envelope.sessionId;
+  		session.localPeerId = envelope.targetPeerId;
+  		session.remotePeerId = envelope.senderPeerId;
+  	}
+  	createSession(input) {
+  		return {
+  			sessionKey: input.sessionKey,
+  			role: input.role,
+  			expectedLocalPeerId: input.expectedLocalPeerId,
+  			localPeerId: input.localPeerId,
+  			remotePeerId: input.remotePeerId,
+  			phase: idlePhase,
+  			epoch: 0,
+  			exchangeId: "",
+  			outgoingMessageId: "",
+  			incomingMessageId: "",
+  			outgoing: void 0,
+  			outgoingSvgs: [],
+  			outgoingCurrentIndex: -1,
+  			assembler: new PartAssembler(),
+  			delivered: false,
+  			peerCreated: false,
+  			timeoutMilliseconds: 6e5,
+  			startedAtMonotonic: this.clock.nowMilliseconds(),
+  			errorCode: "",
+  			errorMessage: "",
+  			tickTimer: void 0,
+  			displayTargets: /* @__PURE__ */ new Set(),
+  			scanAbort: void 0,
+  			waiters: []
+  		};
+  	}
+  	/** Prepares an existing session entry for a new exchange after a retry. */
+  	resetSession(session) {
+  		session.epoch += 1;
+  		session.phase = idlePhase;
+  		session.exchangeId = "";
+  		session.outgoingMessageId = "";
+  		session.incomingMessageId = "";
+  		session.outgoing = void 0;
+  		session.outgoingSvgs = [];
+  		session.outgoingCurrentIndex = -1;
+  		session.assembler = new PartAssembler();
+  		session.delivered = false;
+  		session.peerCreated = false;
+  		session.startedAtMonotonic = this.clock.nowMilliseconds();
+  		session.errorCode = "";
+  		session.errorMessage = "";
+  		session.scanAbort = void 0;
+  		if (session.role === "camera") {
+  			session.localPeerId = session.expectedLocalPeerId;
+  			session.remotePeerId = "";
+  		}
+  	}
+  	scheduleTick(session) {
+  		if (session.tickTimer !== void 0) return;
+  		session.tickTimer = setTimeout(() => {
+  			session.tickTimer = void 0;
+  			this.tick(session);
+  		}, 250);
+  	}
+  	tick(session) {
+  		if (this.sessions.get(session.sessionKey) !== session) return;
+  		if (isTerminalPhase(session.phase)) return;
+  		if (this.clock.nowMilliseconds() - session.startedAtMonotonic >= session.timeoutMilliseconds) {
+  			this.finish(session, "expired", "timeout", "The pairing exchange timed out.");
+  			return;
+  		}
+  		if (session.peerCreated) {
+  			const state = this.readConnectionState(session);
+  			if (state === "connected") {
+  				this.finish(session, "connected", "", "");
+  				return;
+  			}
+  			if (state === "failed" || state === "closed") {
+  				this.finish(session, "failed", "webrtc-rejected", "WebRTC reported that the connection could not be established.");
+  				return;
+  			}
+  		}
+  		this.scheduleTick(session);
+  	}
+  	/**
+  	* Moves a session to a terminal phase and releases what it owns.
+  	*
+  	* Everything but an established RTCPeerConnection is released: timers, the
+  	* receive buffer, and the peer connection when it never connected.
+  	*/
+  	finish(session, phase, errorCode, errorMessage) {
+  		if (isTerminalPhase(session.phase) && session.phase !== "connected") return;
+  		const connected = phase === "connected";
+  		session.epoch += 1;
+  		session.phase = phase;
+  		session.errorCode = errorCode;
+  		session.errorMessage = errorMessage;
+  		this.clearTimer(session);
+  		session.scanAbort?.abort();
+  		this.releaseDisplay(session);
+  		if (!connected) {
+  			session.assembler.clear();
+  			if (session.peerCreated) {
+  				try {
+  					this.webrtc().closePeer(session.remotePeerId);
+  				} catch {}
+  				session.peerCreated = false;
+  			}
+  		}
+  		const waiters = session.waiters.splice(0, session.waiters.length);
+  		for (const waiter of waiters) if (connected) waiter.resolve();
+  		else waiter.reject(this.terminalError(session));
+  	}
+  	failFrom(session, error) {
+  		const code = error instanceof QrPairingError ? error.code : "webrtc-rejected";
+  		const message = error instanceof Error ? error.message : "Pairing failed.";
+  		this.finish(session, "failed", code, message);
+  	}
+  	terminalError(session) {
+  		if (session.phase === "cancelled") return new QrPairingError("cancelled", "The pairing exchange was cancelled.");
+  		if (session.phase === "expired") return new QrPairingError("timeout", "The pairing exchange timed out.");
+  		return new QrPairingError(session.errorCode === "" ? "webrtc-rejected" : session.errorCode, session.errorMessage || "The pairing exchange failed.");
+  	}
+  	clearTimer(session) {
+  		if (session.tickTimer === void 0) return;
+  		clearTimeout(session.tickTimer);
+  		session.tickTimer = void 0;
+  	}
+  	readConnectionState(session) {
+  		try {
+  			return this.webrtc().connectionState(session.remotePeerId);
+  		} catch {
+  			return "";
+  		}
+  	}
+  	async releaseScanner() {
+  		if (this.activeScans > 0) return;
+  		await this.lazyScan?.release();
+  	}
+  	releaseDisplay(session) {
+  		if (session.displayTargets.size === 0) return;
+  		const display = this.display();
+  		for (const target of [...session.displayTargets]) display.releaseTarget(target);
+  		session.displayTargets.clear();
+  	}
+  	webrtc() {
+  		return this.injectedWebRtc ?? requireWebRtcPairingPort(this.runtime);
+  	}
+  	display() {
+  		this.lazyDisplay ?? (this.lazyDisplay = this.injectedDisplay ?? new TemporarySpriteSkinManager(this.runtime));
+  		return this.lazyDisplay;
+  	}
+  	scanner() {
+  		this.lazyScan ?? (this.lazyScan = this.injectedScan ?? new CameraQrScanner(this.runtime, "webrtc-qrcode-pairing"));
+  		return this.lazyScan;
+  	}
+  	requireEnabled() {
+  		if (this.enabled) return;
+  		throw new QrPairingError("feature-disabled", "QR code pairing is disabled. Enable it before the project starts.");
+  	}
+  	requireCapacity() {
+  		if (this.sessions.size < 8) return;
+  		throw new QrPairingError("session-limit", `At most 8 pairing sessions can be open at once.`);
+  	}
+  	requireSession(sessionKey) {
+  		const session = this.sessions.get(requireSessionKey(sessionKey));
+  		if (!session) throw new QrPairingError("no-session", `Pairing session ${sessionKey.trim()} is not open.`);
+  		return session;
+  	}
+  	isStale(session, epoch) {
+  		return session.epoch !== epoch || this.sessions.get(session.sessionKey) !== session;
+  	}
+  };
+  function requireSessionKey(value) {
+  	const key = typeof value === "string" ? value.trim() : "";
+  	if (key === "") throw new QrPairingError("invalid-argument", "Pairing session name must not be empty.");
+  	return key;
+  }
+  //#endregion
+  //#region src/extension.ts
+  var blockDefinitions = block_definitions_default.blocks;
+  /**
+  * Block facade.
+  *
+  * Every method casts its arguments and delegates. Pairing logic lives in
+  * PairingController, which has no Scratch dependency and can be tested without
+  * a runtime.
+  */
+  var WebRtcQrCodePairingExtension = class {
+  	constructor(options = {}) {
+  		this.stopListener = () => this.pairing.stopTransient();
+  		this.resetListener = () => this.pairing.dispose();
+  		this.disposeListener = () => this.dispose();
+  		this.targetRemovedListener = (target) => {
+  			if (isTarget(target)) this.pairing.handleTargetRemoved(target);
+  		};
+  		this.enabled = options.enabled ?? featureFlags.qrCodePairing;
+  		this.runtime = options.runtime ?? Scratch.vm?.runtime ?? {};
+  		this.pairing = new PairingController({
+  			...options,
+  			runtime: this.runtime
+  		});
+  		this.runtime.on?.("PROJECT_RUN_STOP", this.stopListener);
+  		this.runtime.on?.("PROJECT_STOP_ALL", this.stopListener);
+  		this.runtime.on?.("PROJECT_LOADED", this.resetListener);
+  		this.runtime.on?.("RUNTIME_DISPOSED", this.disposeListener);
+  		this.runtime.on?.("targetWasRemoved", this.targetRemovedListener);
+  	}
+  	getInfo() {
+  		return {
+  			id: extensionConfig.id,
+  			name: Scratch.translate(block_definitions_default.extensionName),
+  			docsURI: extensionConfig.docsURI,
+  			blockIconURI: extensionConfig.blockIconURI,
+  			blocks: this.enabled ? blockDefinitions.map((block) => this.toScratchBlock(block)) : []
+  		};
+  	}
+  	async startOfferPairing(args) {
+  		await this.pairing.startOfferPairing({
+  			sessionKey: Scratch.Cast.toString(args.SESSION),
+  			localPeerId: Scratch.Cast.toString(args.LOCAL_PEER),
+  			remotePeerId: Scratch.Cast.toString(args.REMOTE_PEER)
+  		});
+  	}
+  	startAnswerPairing(args) {
+  		this.pairing.startAnswerPairing({
+  			sessionKey: Scratch.Cast.toString(args.SESSION),
+  			expectedLocalPeerId: Scratch.Cast.toString(args.LOCAL_PEER)
+  		});
+  	}
+  	async ingestPairingQrText(args) {
+  		await this.pairing.ingestQrText(Scratch.Cast.toString(args.SESSION), Scratch.Cast.toString(args.TEXT));
+  	}
+  	async scanPairingQrFromCamera(args) {
+  		await this.pairing.scanFromCamera(Scratch.Cast.toString(args.SESSION), Scratch.Cast.toString(args.CAMERA_ID));
+  	}
+  	pairingReceivedParts(args) {
+  		return this.progress(args).receivedParts;
+  	}
+  	pairingRequiredParts(args) {
+  		return this.progress(args).requiredParts;
+  	}
+  	pairingMissingParts(args) {
+  		return this.progress(args).missingParts.join(",");
+  	}
+  	showPairingQrPart(args, util) {
+  		this.pairing.showPart(Scratch.Cast.toString(args.SESSION), Scratch.Cast.toNumber(args.INDEX), util?.target);
+  	}
+  	showNextPairingQrPart(args, util) {
+  		this.pairing.showNextPart(Scratch.Cast.toString(args.SESSION), util?.target);
+  	}
+  	pairingQrPartCount(args) {
+  		return this.progress(args).outgoingPartCount;
+  	}
+  	pairingQrCurrentPart(args) {
+  		return this.progress(args).outgoingCurrentPart;
+  	}
+  	pairingQrPartSvg(args) {
+  		return this.partSvg(args);
+  	}
+  	pairingQrPartDataUri(args) {
+  		const svg = this.partSvg(args);
+  		return svg === "" ? "" : `data:image/svg+xml;base64,${btoa(svg)}`;
+  	}
+  	endPairingQrDisplay(args) {
+  		this.pairing.endDisplay(Scratch.Cast.toString(args.SESSION));
+  	}
+  	pairingPhase(args) {
+  		return this.progress(args).phase;
+  	}
+  	pairingConnectionState(args) {
+  		return this.progress(args).connectionState;
+  	}
+  	isPairingConnected(args) {
+  		return this.pairing.isConnected(Scratch.Cast.toString(args.SESSION));
+  	}
+  	async waitUntilPairingConnected(args) {
+  		await this.pairing.waitUntilConnected(Scratch.Cast.toString(args.SESSION));
+  	}
+  	pairingError(args) {
+  		return this.progress(args).errorCode;
+  	}
+  	pairingErrorMessage(args) {
+  		return this.progress(args).errorMessage;
+  	}
+  	pairingLocalPeer(args) {
+  		return this.progress(args).localPeerId;
+  	}
+  	pairingRemotePeer(args) {
+  		return this.progress(args).remotePeerId;
+  	}
+  	pairingExchangeId(args) {
+  		return this.progress(args).exchangeId;
+  	}
+  	pairingRemainingSeconds(args) {
+  		return this.progress(args).remainingSeconds;
+  	}
+  	pairingSessions() {
+  		return this.pairing.sessionKeys().join(",");
+  	}
+  	cancelPairing(args) {
+  		this.pairing.cancelPairing(Scratch.Cast.toString(args.SESSION));
+  	}
+  	async retryPairing(args) {
+  		await this.pairing.retryPairing(Scratch.Cast.toString(args.SESSION));
+  	}
+  	setPairingTimeout(args) {
+  		this.pairing.setTimeoutSeconds(Scratch.Cast.toString(args.SESSION), Scratch.Cast.toNumber(args.SECONDS));
+  	}
+  	dispose() {
+  		this.pairing.dispose();
+  		this.runtime.off?.("PROJECT_RUN_STOP", this.stopListener);
+  		this.runtime.off?.("PROJECT_STOP_ALL", this.stopListener);
+  		this.runtime.off?.("PROJECT_LOADED", this.resetListener);
+  		this.runtime.off?.("RUNTIME_DISPOSED", this.disposeListener);
+  		this.runtime.off?.("targetWasRemoved", this.targetRemovedListener);
+  	}
+  	progress(args) {
+  		return this.pairing.progress(Scratch.Cast.toString(args.SESSION));
+  	}
+  	/** Reporters report; they never stop a script, so an unknown session is an empty string. */
+  	partSvg(args) {
+  		try {
+  			return this.pairing.partSvg(Scratch.Cast.toString(args.SESSION), Scratch.Cast.toNumber(args.INDEX));
+  		} catch {
+  			return "";
+  		}
+  	}
+  	toScratchBlock(block) {
+  		return {
+  			opcode: block.opcode,
+  			blockType: Scratch.BlockType[block.blockType],
+  			text: Scratch.translate(block.text),
+  			arguments: Object.fromEntries(Object.entries(block.arguments).map(([name, argument]) => [name, {
+  				type: Scratch.ArgumentType[argument.type],
+  				defaultValue: argument.defaultValue
+  			}]))
+  		};
+  	}
+  };
+  function isTarget(value) {
+  	return typeof value === "object" && value !== null;
+  }
+  //#endregion
+  //#region src/index.ts
+  if (extensionConfig.unsandboxed && !Scratch.extensions.unsandboxed) throw new Error(`${extensionConfig.name} must run unsandboxed.`);
+  Scratch.extensions.register(new WebRtcQrCodePairingExtension());
+  //#endregion
+
+})(Scratch);