dsh-codex-subscription 2.5.9 → 3.0.0-beta.1

package/lib/client.js

@@ -11,6 +11,7 @@ window.__ModuleLoader__.load({
 		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];
@@ -1086,6 +1087,10 @@ window.__ModuleLoader__.load({
 			"runtime/cancel",
 			"storage/status",
 			"storage/clear-forecast",
+			"remote/status",
+			"remote/enable",
+			"remote/disable",
+			"remote/pair",
 			"reset-credit/inspect",
 			"reset-credit/prepare",
 			"reset-credit/consume",
@@ -5680,6 +5685,24 @@ window.__ModuleLoader__.load({
 			subagentBackend_dsh: "DSH",
 			subagentBackend_codex: "Codex",
 			connectionTitle: "连接方式",
+			remoteTitle: "手机远程控制",
+			remote_off: "关闭",
+			remote_on: "开启",
+			remoteHint: "实验功能，默认关闭。开启后，这台电脑上的 DSH 会出现在 ChatGPT 手机 App 的 Codex 主机列表里，可用手机查看对话、发消息、切换模型和审批。需要订阅账号登录；电脑要保持开机和联网。",
+			remoteConnected: "已连接",
+			remoteConnecting: "正在连接",
+			remoteError: "连接失败，会自动重试",
+			remoteStopped: "已停止",
+			remotePhones: "{count} 个手机连接",
+			remotePair: "显示配对码",
+			remotePairAgain: "重新生成配对码",
+			remotePairFailed: "无法生成配对码，请确认已登录订阅账号。",
+			remotePairSteps: "在手机 ChatGPT App 的 Codex 里扫码，或输入下面的手动码。",
+			remoteManualCode: "手动配对码",
+			remoteQrLabel: "配对二维码",
+			remoteExpires: "约 {minutes} 分钟内有效",
+			remoteExpired: "配对码已过期，请重新生成。",
+			remoteLimits: "手机上可以查看和继续 DSH 里的对话、新建对话、切换模型、选择权限并审批。手机暂不能直接在电脑上执行命令。",
 			reviewModelTitle: "Auto review 审查模型",
 			reviewModel_session: "当前模型",
 			reviewModel_official: "Codex 官方审查模型",
@@ -6267,6 +6290,24 @@ window.__ModuleLoader__.load({
 			subagentBackend_dsh: "DSH",
 			subagentBackend_codex: "Codex",
 			connectionTitle: "Connection",
+			remoteTitle: "Phone remote control",
+			remote_off: "Off",
+			remote_on: "On",
+			remoteHint: "Experimental, off by default. When on, this computer's DSH appears as a host in the ChatGPT mobile app's Codex list, so you can follow conversations, send messages, switch models and approve actions from your phone. Needs a signed-in subscription account; the computer must stay on and online.",
+			remoteConnected: "Connected",
+			remoteConnecting: "Connecting",
+			remoteError: "Connection failed, retrying",
+			remoteStopped: "Stopped",
+			remotePhones: "{count} phone(s) connected",
+			remotePair: "Show pairing code",
+			remotePairAgain: "New pairing code",
+			remotePairFailed: "Could not create a pairing code. Check that the subscription account is signed in.",
+			remotePairSteps: "Scan this in the ChatGPT app's Codex section, or type the manual code.",
+			remoteManualCode: "Manual pairing code",
+			remoteQrLabel: "Pairing QR code",
+			remoteExpires: "Valid for about {minutes} minute(s)",
+			remoteExpired: "The pairing code expired. Create a new one.",
+			remoteLimits: "From the phone you can follow and continue DSH conversations, start new ones, switch models, choose permissions and approve actions. The phone cannot run commands on the computer directly.",
 			reviewModelTitle: "Auto review model",
 			reviewModel_session: "Current model",
 			reviewModel_official: "Codex reviewer",
@@ -6999,6 +7040,7 @@ window.__ModuleLoader__.load({
 .codexSubscriptionSettingRows>.codexImagePreference+.codexImagePreference{border-top:1px solid var(--dsw-alias-border-l2)}
 .codexSubscriptionDiagnostics .codexSubscriptionSectionHead{align-items:flex-start;flex-direction:column;gap:12px}
 .codexSubscriptionDiagnostics .codexSubscriptionSectionTitle{display:flex;flex-direction:column;gap:5px}
+.codexSubscriptionRemotePair{display:flex;gap:16px;align-items:center;flex-wrap:wrap;margin-top:8px}.codexSubscriptionRemoteQr{width:168px;height:168px;flex:none;border-radius:12px;overflow:hidden;background:#fff}.codexSubscriptionRemoteQr svg{display:block;width:100%;height:100%}.codexSubscriptionRemoteCode{margin:6px 0;font:600 20px/28px ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;letter-spacing:.08em;user-select:all}
 .codexSubscriptionStorageMeter{display:flex;flex-direction:column;gap:9px;padding:12px;border-radius:10px;background:var(--dsw-alias-bg-module-platform)}
 .codexSubscriptionStorageMeter>div{display:flex;justify-content:space-between;gap:8px;flex-wrap:wrap;font-size:12px;line-height:18px}
 .codexSubscriptionStorageMeter output{font-variant-numeric:tabular-nums;color:var(--dsw-alias-label-secondary)}
@@ -8498,6 +8540,7 @@ window.__ModuleLoader__.load({
 					autoQuotaRetry: normalizeAutoQuotaRetry(value?.[AUTO_QUOTA_RETRY_FIELD]),
 					connectionMode: value?.connectionMode === "websocket" ? "websocket" : "sse",
 					reviewModel: value?.reviewModel === "official" ? "official" : "session",
+					remoteControl: value?.remoteControl === "on" ? "on" : "off",
 					compactionMode: value?.compactionMode === "cloud" ? "cloud" : "dsh",
 					subagentBackend: value?.subagentBackend === "codex" ? "codex" : "dsh",
 					subagentBackendAvailable,
@@ -8558,6 +8601,7 @@ window.__ModuleLoader__.load({
 						[AUTO_QUOTA_RETRY_FIELD]: normalizeAutoQuotaRetry(value?.[AUTO_QUOTA_RETRY_FIELD]),
 						connectionMode: value?.connectionMode === "websocket" ? "websocket" : "sse",
 						reviewModel: value?.reviewModel === "official" ? "official" : "session",
+						remoteControl: value?.remoteControl === "on" ? "on" : "off",
 						compactionMode: value?.compactionMode === "cloud" ? "cloud" : "dsh",
 						subagentBackend: value?.subagentBackend === "codex" ? "codex" : "dsh",
 						...readCapabilitySettings(value),
@@ -9091,7 +9135,7 @@ window.__ModuleLoader__.load({
 		}
 		//#endregion
 		//#region src/version.js
-		const PACKAGE_VERSION = "2.5.9";
+		const PACKAGE_VERSION = "3.0.0-beta.1";
 		//#endregion
 		//#region src/client-recovery.js
 		async function recoveryCall(rpc, endpoint, payload = {}, timeoutMs = 1e4) {
@@ -10219,6 +10263,2371 @@ window.__ModuleLoader__.load({
 			});
 		}
 		//#endregion
+		//#region node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/core/utils.js
+		var require_utils = /* @__PURE__ */ __commonJSMin(((exports) => {
+			let toSJISFunction;
+			const 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.
+			*/
+			const getSymbolSize = require_utils().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) => {
+			const getSymbolSize = require_utils().getSymbolSize;
+			const 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}
+			*/
+			const 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) => {
+			const ECLevel = require_error_correction_level();
+			const 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
+			];
+			const 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) => {
+			const EXP_TABLE = /* @__PURE__ */ new Uint8Array(512);
+			const 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) => {
+			const 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) => {
+			const 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) => {
+			const numeric = "[0-9]+";
+			const alphanumeric = "[A-Z $%*+\\-./:]+";
+			let 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");
+			const 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");
+			const TEST_KANJI = new RegExp("^" + kanji + "$");
+			const TEST_NUMERIC = /* @__PURE__ */ new RegExp("^[0-9]+$");
+			const 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) => {
+			const VersionCheck = require_version_check();
+			const 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) => {
+			const Utils = require_utils();
+			const ECCode = require_error_correction_code();
+			const ECLevel = require_error_correction_level();
+			const Mode = require_mode();
+			const VersionCheck = require_version_check();
+			const G18 = 7973;
+			const 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) => {
+			const Utils = require_utils();
+			const G15 = 1335;
+			const G15_MASK = 21522;
+			const 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) => {
+			const 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) => {
+			const 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}
+			*/
+			const 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;
+				for (i = 0; i + 2 <= this.data.length; i += 2) {
+					let value = ALPHA_NUM_CHARS.indexOf(this.data[i]) * 45;
+					value += ALPHA_NUM_CHARS.indexOf(this.data[i + 1]);
+					bitBuffer.put(value, 11);
+				}
+				if (this.data.length % 2) bitBuffer.put(ALPHA_NUM_CHARS.indexOf(this.data[i]), 6);
+			};
+			module.exports = AlphanumericData;
+		}));
+		//#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) => {
+			const 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) => {
+			const Mode = require_mode();
+			const Utils = require_utils();
+			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;
+				for (i = 0; i < this.data.length; i++) {
+					let value = Utils.toSJIS(this.data[i]);
+					if (value >= 33088 && value <= 40956) value -= 33088;
+					else if (value >= 57408 && value <= 60351) value -= 49472;
+					else throw new Error("Invalid SJIS character: " + this.data[i] + "\nMake sure your charset is UTF-8");
+					value = (value >>> 8 & 255) * 192 + (value & 255);
+					bitBuffer.put(value, 13);
+				}
+			};
+			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) => {
+			const Mode = require_mode();
+			const NumericData = require_numeric_data();
+			const AlphanumericData = require_alphanumeric_data();
+			const ByteData = require_byte_data();
+			const KanjiData = require_kanji_data();
+			const Regex = require_regex();
+			const Utils = require_utils();
+			const 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 src/client-remote-control.jsx
+		var import_qrcode = (/* @__PURE__ */ __commonJSMin(((exports) => {
+			const Utils = require_utils();
+			const ECLevel = require_error_correction_level();
+			const BitBuffer = require_bit_buffer();
+			const BitMatrix = require_bit_matrix();
+			const AlignmentPattern = require_alignment_pattern();
+			const FinderPattern = require_finder_pattern();
+			const MaskPattern = require_mask_pattern();
+			const ECCode = require_error_correction_code();
+			const ReedSolomonEncoder = require_reed_solomon_encoder();
+			const Version = require_version();
+			const FormatInfo = require_format_info();
+			const Mode = require_mode();
+			const 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 moduleCount = Utils.getSymbolSize(version);
+				const modules = new BitMatrix(moduleCount);
+				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);
+			};
+		})))();
+		const PAIR_URL = "https://chatgpt.com/codex/pair?pairing_code=";
+		const STATUS_KEYS = {
+			connected: "remoteConnected",
+			connecting: "remoteConnecting",
+			error: "remoteError",
+			stopped: "remoteStopped"
+		};
+		const MARGIN = 2;
+		function Qr({ value, label }) {
+			let modules;
+			try {
+				modules = (0, import_qrcode.create)(value, { errorCorrectionLevel: "M" }).modules;
+			} catch {
+				return null;
+			}
+			const size = modules.size;
+			let path = "";
+			for (let row = 0; row < size; row++) for (let column = 0; column < size; column++) if (modules.get(row, column)) path += `M${column + MARGIN} ${row + MARGIN}h1v1h-1z`;
+			const span = size + MARGIN * 2;
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+				className: "codexSubscriptionRemoteQr",
+				role: "img",
+				"aria-label": label,
+				children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("svg", {
+					viewBox: `0 0 ${span} ${span}`,
+					shapeRendering: "crispEdges",
+					"aria-hidden": "true",
+					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("rect", {
+						width: span,
+						height: span,
+						fill: "#fff"
+					}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("path", {
+						d: path,
+						fill: "#000"
+					})]
+				})
+			});
+		}
+		/** Beta: show this DSH in the ChatGPT mobile app's Codex list (Remote Control). */
+		function RemoteControlCard({ rpc, preference, snapshot, t }) {
+			const [state, setState] = (0, react.useState)();
+			const [pairing, setPairing] = (0, react.useState)();
+			const [busy, setBusy] = (0, react.useState)(false);
+			const [failed, setFailed] = (0, react.useState)(false);
+			const [now, setNow] = (0, react.useState)(Date.now());
+			const alive = (0, react.useRef)(false);
+			const on = snapshot.remoteControl === "on";
+			const read = async () => {
+				try {
+					const result = await rpc.call(CHANNEL, "remote/status", {});
+					if (alive.current && result.ok) setState(result.value);
+				} catch {}
+			};
+			(0, react.useEffect)(() => {
+				alive.current = true;
+				return () => {
+					alive.current = false;
+				};
+			}, []);
+			(0, react.useEffect)(() => {
+				if (!on) {
+					setState(void 0);
+					setPairing(void 0);
+					return;
+				}
+				let stopped = false, timer;
+				const poll = async () => {
+					await read();
+					if (!stopped) timer = setTimeout(poll, 4e3);
+				};
+				poll();
+				return () => {
+					stopped = true;
+					clearTimeout(timer);
+				};
+			}, [on, rpc]);
+			(0, react.useEffect)(() => {
+				if (!pairing) return void 0;
+				const timer = setInterval(() => setNow(Date.now()), 5e3);
+				return () => clearInterval(timer);
+			}, [pairing]);
+			const pair = async () => {
+				if (busy) return;
+				setBusy(true);
+				setFailed(false);
+				try {
+					const result = await rpc.call(CHANNEL, "remote/pair", {});
+					if (!alive.current) return;
+					if (!result.ok) {
+						setFailed(true);
+						return;
+					}
+					setPairing(result.value);
+					setNow(Date.now());
+					read();
+				} catch {
+					if (alive.current) setFailed(true);
+				} finally {
+					if (alive.current) setBusy(false);
+				}
+			};
+			const expired = pairing && pairing.expiresAt <= now;
+			const minutes = pairing ? Math.max(0, Math.ceil((pairing.expiresAt - now) / 6e4)) : 0;
+			const status = state?.status ?? "connecting";
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("section", {
+				className: "codexSubscriptionCard codexSubscriptionPreferencesCard",
+				"aria-label": t("remoteTitle"),
+				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+					className: "codexSubscriptionPreference",
+					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						className: "codexSubscriptionPreferenceCopy",
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
+							className: "codexSubscriptionPreferenceLabel",
+							children: [
+								t("remoteTitle"),
+								" ",
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)("small", { children: "Beta" })
+							]
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							className: "codexSubscriptionPreferenceHint",
+							children: t("remoteHint")
+						})]
+					}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+						className: "codexSubscriptionQuotaModes",
+						role: "radiogroup",
+						"aria-label": t("remoteTitle"),
+						"aria-busy": snapshot.saving || void 0,
+						children: ["off", "on"].map((value) => /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("label", {
+							className: "codexSubscriptionQuotaMode",
+							children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+								type: "radio",
+								name: "codex-remote-control",
+								checked: snapshot.remoteControl === value,
+								disabled: !snapshot.writable,
+								onChange: () => {
+									preference.set({ remoteControl: value });
+								}
+							}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", { children: t(`remote_${value}`) })]
+						}, value))
+					})]
+				}), on ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", { className: "codexSubscriptionDivider" }),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						className: "codexSubscriptionPreference",
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
+							role: "status",
+							children: [
+								t(STATUS_KEYS[status] ?? "remoteConnecting"),
+								status === "error" && state?.lastError ? ` · ${state.lastError}` : "",
+								state?.phones > 0 ? ` · ${t("remotePhones").replace("{count}", String(state.phones))}` : ""
+							]
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Button, {
+							type: "button",
+							variant: "outline",
+							disabled: busy || status === "stopped",
+							onClick: () => {
+								pair();
+							},
+							children: t(pairing ? "remotePairAgain" : "remotePair")
+						})]
+					}),
+					failed ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						role: "alert",
+						className: "codexSubscriptionHelp",
+						children: t("remotePairFailed")
+					}) : null,
+					pairing && !expired ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						className: "codexSubscriptionRemotePair",
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Qr, {
+							value: `${PAIR_URL}${pairing.pairingCode}`,
+							label: t("remoteQrLabel")
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", { children: [
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+								className: "codexSubscriptionHelp",
+								children: t("remotePairSteps")
+							}),
+							pairing.manualCode ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+								className: "codexSubscriptionRemoteCode",
+								"aria-label": t("remoteManualCode"),
+								children: pairing.manualCode
+							}) : null,
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+								className: "codexSubscriptionHelp",
+								children: t("remoteExpires").replace("{minutes}", String(minutes))
+							})
+						] })]
+					}) : pairing ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						className: "codexSubscriptionHelp",
+						children: t("remoteExpired")
+					}) : null,
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						className: "codexSubscriptionHelp",
+						children: t("remoteLimits")
+					})
+				] }) : null]
+			});
+		}
+		//#endregion
 		//#region src/context-draft-state.js
 		const hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value ?? {}, key);
 		/**
@@ -10801,6 +13210,12 @@ window.__ModuleLoader__.load({
 							})]
 						})
 					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)(RemoteControlCard, {
+						rpc,
+						preference,
+						snapshot,
+						t
+					}),
 					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("section", {
 						className: "codexSubscriptionCard codexSubscriptionPreferencesCard",
 						"aria-label": t("compactionTitle"),