muon-ui 0.20.0 → 0.22.0

package/dist/runtime/linux-amd64/plugins/node-bridge.mjs

@@ -0,0 +1,3013 @@
+/*!
+* name: muon-node
+* version: 0.22.0
+* description: Out-of-process Node.js bridge for muon.
+* author: Kouji Matsui (@kekyo@mi.kekyo.net)
+* license: MIT
+* repository.url: https://github.com/kekyo/muon-ui.git
+* git.commit.hash: 5c8d38ea864ba1916f26e6beb6814a4af57479d7
+*/
+import { Socket, createConnection } from "node:net";
+import { timingSafeEqual } from "node:crypto";
+import { readFile, realpath } from "node:fs/promises";
+import { builtinModules, createRequire, isBuiltin } from "node:module";
+import path, { dirname, extname, isAbsolute, join, parse, resolve, sep } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import assert from "node:assert";
+import fs, { realpathSync, statSync } from "node:fs";
+import process$1 from "node:process";
+import v8 from "node:v8";
+import { format, inspect } from "node:util";
+//#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 ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+//#region ../node_modules/import-meta-resolve/lib/errors.js
+/**
+* @typedef ErrnoExceptionFields
+* @property {number | undefined} [errnode]
+* @property {string | undefined} [code]
+* @property {string | undefined} [path]
+* @property {string | undefined} [syscall]
+* @property {string | undefined} [url]
+*
+* @typedef {Error & ErrnoExceptionFields} ErrnoException
+*/
+/**
+* @typedef {(...parameters: Array<any>) => string} MessageFunction
+*/
+var own$1 = {}.hasOwnProperty;
+var classRegExp = /^([A-Z][a-z\d]*)+$/;
+var kTypes = new Set([
+	"string",
+	"function",
+	"number",
+	"object",
+	"Function",
+	"Object",
+	"boolean",
+	"bigint",
+	"symbol"
+]);
+var codes = {};
+/**
+* Create a list string in the form like 'A and B' or 'A, B, ..., and Z'.
+* We cannot use Intl.ListFormat because it's not available in
+* --without-intl builds.
+*
+* @param {Array<string>} array
+*   An array of strings.
+* @param {string} [type]
+*   The list type to be inserted before the last element.
+* @returns {string}
+*/
+function formatList(array, type = "and") {
+	return array.length < 3 ? array.join(` ${type} `) : `${array.slice(0, -1).join(", ")}, ${type} ${array[array.length - 1]}`;
+}
+/** @type {Map<string, MessageFunction | string>} */
+var messages = /* @__PURE__ */ new Map();
+var nodeInternalPrefix = "__node_internal_";
+/** @type {number} */
+var userStackTraceLimit;
+codes.ERR_INVALID_ARG_TYPE = createError(
+	"ERR_INVALID_ARG_TYPE",
+	/**
+	* @param {string} name
+	* @param {Array<string> | string} expected
+	* @param {unknown} actual
+	*/
+	(name, expected, actual) => {
+		assert.ok(typeof name === "string", "'name' must be a string");
+		if (!Array.isArray(expected)) expected = [expected];
+		let message = "The ";
+		if (name.endsWith(" argument")) message += `${name} `;
+		else {
+			const type = name.includes(".") ? "property" : "argument";
+			message += `"${name}" ${type} `;
+		}
+		message += "must be ";
+		/** @type {Array<string>} */
+		const types = [];
+		/** @type {Array<string>} */
+		const instances = [];
+		/** @type {Array<string>} */
+		const other = [];
+		for (const value of expected) {
+			assert.ok(typeof value === "string", "All expected entries have to be of type string");
+			if (kTypes.has(value)) types.push(value.toLowerCase());
+			else if (classRegExp.exec(value) === null) {
+				assert.ok(value !== "object", "The value \"object\" should be written as \"Object\"");
+				other.push(value);
+			} else instances.push(value);
+		}
+		if (instances.length > 0) {
+			const pos = types.indexOf("object");
+			if (pos !== -1) {
+				types.slice(pos, 1);
+				instances.push("Object");
+			}
+		}
+		if (types.length > 0) {
+			message += `${types.length > 1 ? "one of type" : "of type"} ${formatList(types, "or")}`;
+			if (instances.length > 0 || other.length > 0) message += " or ";
+		}
+		if (instances.length > 0) {
+			message += `an instance of ${formatList(instances, "or")}`;
+			if (other.length > 0) message += " or ";
+		}
+		if (other.length > 0) if (other.length > 1) message += `one of ${formatList(other, "or")}`;
+		else {
+			if (other[0].toLowerCase() !== other[0]) message += "an ";
+			message += `${other[0]}`;
+		}
+		message += `. Received ${determineSpecificType(actual)}`;
+		return message;
+	},
+	TypeError
+);
+codes.ERR_INVALID_MODULE_SPECIFIER = createError(
+	"ERR_INVALID_MODULE_SPECIFIER",
+	/**
+	* @param {string} request
+	* @param {string} reason
+	* @param {string} [base]
+	*/
+	(request, reason, base = void 0) => {
+		return `Invalid module "${request}" ${reason}${base ? ` imported from ${base}` : ""}`;
+	},
+	TypeError
+);
+codes.ERR_INVALID_PACKAGE_CONFIG = createError(
+	"ERR_INVALID_PACKAGE_CONFIG",
+	/**
+	* @param {string} path
+	* @param {string} [base]
+	* @param {string} [message]
+	*/
+	(path, base, message) => {
+		return `Invalid package config ${path}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
+	},
+	Error
+);
+codes.ERR_INVALID_PACKAGE_TARGET = createError(
+	"ERR_INVALID_PACKAGE_TARGET",
+	/**
+	* @param {string} packagePath
+	* @param {string} key
+	* @param {unknown} target
+	* @param {boolean} [isImport=false]
+	* @param {string} [base]
+	*/
+	(packagePath, key, target, isImport = false, base = void 0) => {
+		const relatedError = typeof target === "string" && !isImport && target.length > 0 && !target.startsWith("./");
+		if (key === ".") {
+			assert.ok(isImport === false);
+			return `Invalid "exports" main target ${JSON.stringify(target)} defined in the package config ${packagePath}package.json${base ? ` imported from ${base}` : ""}${relatedError ? "; targets must start with \"./\"" : ""}`;
+		}
+		return `Invalid "${isImport ? "imports" : "exports"}" target ${JSON.stringify(target)} defined for '${key}' in the package config ${packagePath}package.json${base ? ` imported from ${base}` : ""}${relatedError ? "; targets must start with \"./\"" : ""}`;
+	},
+	Error
+);
+codes.ERR_MODULE_NOT_FOUND = createError(
+	"ERR_MODULE_NOT_FOUND",
+	/**
+	* @param {string} path
+	* @param {string} base
+	* @param {boolean} [exactUrl]
+	*/
+	(path, base, exactUrl = false) => {
+		return `Cannot find ${exactUrl ? "module" : "package"} '${path}' imported from ${base}`;
+	},
+	Error
+);
+codes.ERR_NETWORK_IMPORT_DISALLOWED = createError("ERR_NETWORK_IMPORT_DISALLOWED", "import of '%s' by %s is not supported: %s", Error);
+codes.ERR_PACKAGE_IMPORT_NOT_DEFINED = createError(
+	"ERR_PACKAGE_IMPORT_NOT_DEFINED",
+	/**
+	* @param {string} specifier
+	* @param {string} packagePath
+	* @param {string} base
+	*/
+	(specifier, packagePath, base) => {
+		return `Package import specifier "${specifier}" is not defined${packagePath ? ` in package ${packagePath}package.json` : ""} imported from ${base}`;
+	},
+	TypeError
+);
+codes.ERR_PACKAGE_PATH_NOT_EXPORTED = createError(
+	"ERR_PACKAGE_PATH_NOT_EXPORTED",
+	/**
+	* @param {string} packagePath
+	* @param {string} subpath
+	* @param {string} [base]
+	*/
+	(packagePath, subpath, base = void 0) => {
+		if (subpath === ".") return `No "exports" main defined in ${packagePath}package.json${base ? ` imported from ${base}` : ""}`;
+		return `Package subpath '${subpath}' is not defined by "exports" in ${packagePath}package.json${base ? ` imported from ${base}` : ""}`;
+	},
+	Error
+);
+codes.ERR_UNSUPPORTED_DIR_IMPORT = createError("ERR_UNSUPPORTED_DIR_IMPORT", "Directory import '%s' is not supported resolving ES modules imported from %s", Error);
+codes.ERR_UNSUPPORTED_RESOLVE_REQUEST = createError("ERR_UNSUPPORTED_RESOLVE_REQUEST", "Failed to resolve module specifier \"%s\" from \"%s\": Invalid relative URL or base scheme is not hierarchical.", TypeError);
+codes.ERR_UNKNOWN_FILE_EXTENSION = createError(
+	"ERR_UNKNOWN_FILE_EXTENSION",
+	/**
+	* @param {string} extension
+	* @param {string} path
+	*/
+	(extension, path) => {
+		return `Unknown file extension "${extension}" for ${path}`;
+	},
+	TypeError
+);
+codes.ERR_INVALID_ARG_VALUE = createError(
+	"ERR_INVALID_ARG_VALUE",
+	/**
+	* @param {string} name
+	* @param {unknown} value
+	* @param {string} [reason='is invalid']
+	*/
+	(name, value, reason = "is invalid") => {
+		let inspected = inspect(value);
+		if (inspected.length > 128) inspected = `${inspected.slice(0, 128)}...`;
+		return `The ${name.includes(".") ? "property" : "argument"} '${name}' ${reason}. Received ${inspected}`;
+	},
+	TypeError
+);
+/**
+* Utility function for registering the error codes. Only used here. Exported
+* *only* to allow for testing.
+* @param {string} sym
+* @param {MessageFunction | string} value
+* @param {ErrorConstructor} constructor
+* @returns {new (...parameters: Array<any>) => Error}
+*/
+function createError(sym, value, constructor) {
+	messages.set(sym, value);
+	return makeNodeErrorWithCode(constructor, sym);
+}
+/**
+* @param {ErrorConstructor} Base
+* @param {string} key
+* @returns {ErrorConstructor}
+*/
+function makeNodeErrorWithCode(Base, key) {
+	return NodeError;
+	/**
+	* @param {Array<unknown>} parameters
+	*/
+	function NodeError(...parameters) {
+		const limit = Error.stackTraceLimit;
+		if (isErrorStackTraceLimitWritable()) Error.stackTraceLimit = 0;
+		const error = new Base();
+		if (isErrorStackTraceLimitWritable()) Error.stackTraceLimit = limit;
+		const message = getMessage(key, parameters, error);
+		Object.defineProperties(error, {
+			message: {
+				value: message,
+				enumerable: false,
+				writable: true,
+				configurable: true
+			},
+			toString: {
+				/** @this {Error} */
+				value() {
+					return `${this.name} [${key}]: ${this.message}`;
+				},
+				enumerable: false,
+				writable: true,
+				configurable: true
+			}
+		});
+		captureLargerStackTrace(error);
+		error.code = key;
+		return error;
+	}
+}
+/**
+* @returns {boolean}
+*/
+function isErrorStackTraceLimitWritable() {
+	try {
+		if (v8.startupSnapshot.isBuildingSnapshot()) return false;
+	} catch {}
+	const desc = Object.getOwnPropertyDescriptor(Error, "stackTraceLimit");
+	if (desc === void 0) return Object.isExtensible(Error);
+	return own$1.call(desc, "writable") && desc.writable !== void 0 ? desc.writable : desc.set !== void 0;
+}
+/**
+* This function removes unnecessary frames from Node.js core errors.
+* @template {(...parameters: unknown[]) => unknown} T
+* @param {T} wrappedFunction
+* @returns {T}
+*/
+function hideStackFrames(wrappedFunction) {
+	const hidden = nodeInternalPrefix + wrappedFunction.name;
+	Object.defineProperty(wrappedFunction, "name", { value: hidden });
+	return wrappedFunction;
+}
+var captureLargerStackTrace = hideStackFrames(
+	/**
+	* @param {Error} error
+	* @returns {Error}
+	*/
+	function(error) {
+		const stackTraceLimitIsWritable = isErrorStackTraceLimitWritable();
+		if (stackTraceLimitIsWritable) {
+			userStackTraceLimit = Error.stackTraceLimit;
+			Error.stackTraceLimit = Number.POSITIVE_INFINITY;
+		}
+		Error.captureStackTrace(error);
+		if (stackTraceLimitIsWritable) Error.stackTraceLimit = userStackTraceLimit;
+		return error;
+	}
+);
+/**
+* @param {string} key
+* @param {Array<unknown>} parameters
+* @param {Error} self
+* @returns {string}
+*/
+function getMessage(key, parameters, self) {
+	const message = messages.get(key);
+	assert.ok(message !== void 0, "expected `message` to be found");
+	if (typeof message === "function") {
+		assert.ok(message.length <= parameters.length, `Code: ${key}; The provided arguments length (${parameters.length}) does not match the required ones (${message.length}).`);
+		return Reflect.apply(message, self, parameters);
+	}
+	const regex = /%[dfijoOs]/g;
+	let expectedLength = 0;
+	while (regex.exec(message) !== null) expectedLength++;
+	assert.ok(expectedLength === parameters.length, `Code: ${key}; The provided arguments length (${parameters.length}) does not match the required ones (${expectedLength}).`);
+	if (parameters.length === 0) return message;
+	parameters.unshift(message);
+	return Reflect.apply(format, null, parameters);
+}
+/**
+* Determine the specific type of a value for type-mismatch errors.
+* @param {unknown} value
+* @returns {string}
+*/
+function determineSpecificType(value) {
+	if (value === null || value === void 0) return String(value);
+	if (typeof value === "function" && value.name) return `function ${value.name}`;
+	if (typeof value === "object") {
+		if (value.constructor && value.constructor.name) return `an instance of ${value.constructor.name}`;
+		return `${inspect(value, { depth: -1 })}`;
+	}
+	let inspected = inspect(value, { colors: false });
+	if (inspected.length > 28) inspected = `${inspected.slice(0, 25)}...`;
+	return `type ${typeof value} (${inspected})`;
+}
+//#endregion
+//#region ../node_modules/import-meta-resolve/lib/package-json-reader.js
+/**
+* @import {ErrnoException} from './errors.js'
+*
+* @typedef {'commonjs' | 'module' | 'none'} PackageType
+*
+* @typedef PackageConfig
+* @property {string} pjsonPath
+* @property {boolean} exists
+* @property {string | undefined} [main]
+* @property {string | undefined} [name]
+* @property {PackageType} type
+* @property {Record<string, unknown> | undefined} [exports]
+* @property {Record<string, unknown> | undefined} [imports]
+*/
+var hasOwnProperty$1 = {}.hasOwnProperty;
+var { ERR_INVALID_PACKAGE_CONFIG: ERR_INVALID_PACKAGE_CONFIG$1 } = codes;
+/** @type {Map<string, PackageConfig>} */
+var cache = /* @__PURE__ */ new Map();
+/**
+* @param {string} jsonPath
+* @param {{specifier: URL | string, base?: URL}} options
+* @returns {PackageConfig}
+*/
+function read(jsonPath, { base, specifier }) {
+	const existing = cache.get(jsonPath);
+	if (existing) return existing;
+	/** @type {string | undefined} */
+	let string;
+	try {
+		string = fs.readFileSync(path.toNamespacedPath(jsonPath), "utf8");
+	} catch (error) {
+		const exception = error;
+		if (exception.code !== "ENOENT") throw exception;
+	}
+	/** @type {PackageConfig} */
+	const result = {
+		exists: false,
+		pjsonPath: jsonPath,
+		main: void 0,
+		name: void 0,
+		type: "none",
+		exports: void 0,
+		imports: void 0
+	};
+	if (string !== void 0) {
+		/** @type {Record<string, unknown>} */
+		let parsed;
+		try {
+			parsed = JSON.parse(string);
+		} catch (error_) {
+			const cause = error_;
+			const error = new ERR_INVALID_PACKAGE_CONFIG$1(jsonPath, (base ? `"${specifier}" from ` : "") + fileURLToPath(base || specifier), cause.message);
+			error.cause = cause;
+			throw error;
+		}
+		result.exists = true;
+		if (hasOwnProperty$1.call(parsed, "name") && typeof parsed.name === "string") result.name = parsed.name;
+		if (hasOwnProperty$1.call(parsed, "main") && typeof parsed.main === "string") result.main = parsed.main;
+		if (hasOwnProperty$1.call(parsed, "exports")) result.exports = parsed.exports;
+		if (hasOwnProperty$1.call(parsed, "imports")) result.imports = parsed.imports;
+		if (hasOwnProperty$1.call(parsed, "type") && (parsed.type === "commonjs" || parsed.type === "module")) result.type = parsed.type;
+	}
+	cache.set(jsonPath, result);
+	return result;
+}
+/**
+* @param {URL | string} resolved
+* @returns {PackageConfig}
+*/
+function getPackageScopeConfig(resolved) {
+	let packageJSONUrl = new URL("package.json", resolved);
+	while (true) {
+		if (packageJSONUrl.pathname.endsWith("node_modules/package.json")) break;
+		const packageConfig = read(fileURLToPath(packageJSONUrl), { specifier: resolved });
+		if (packageConfig.exists) return packageConfig;
+		const lastPackageJSONUrl = packageJSONUrl;
+		packageJSONUrl = new URL("../package.json", packageJSONUrl);
+		if (packageJSONUrl.pathname === lastPackageJSONUrl.pathname) break;
+	}
+	return {
+		pjsonPath: fileURLToPath(packageJSONUrl),
+		exists: false,
+		type: "none"
+	};
+}
+/**
+* Returns the package type for a given URL.
+* @param {URL} url - The URL to get the package type for.
+* @returns {PackageType}
+*/
+function getPackageType(url) {
+	return getPackageScopeConfig(url).type;
+}
+//#endregion
+//#region ../node_modules/import-meta-resolve/lib/get-format.js
+var { ERR_UNKNOWN_FILE_EXTENSION } = codes;
+var hasOwnProperty = {}.hasOwnProperty;
+/** @type {Record<string, string>} */
+var extensionFormatMap = {
+	__proto__: null,
+	".cjs": "commonjs",
+	".js": "module",
+	".json": "json",
+	".mjs": "module"
+};
+/**
+* @param {string | null} mime
+* @returns {string | null}
+*/
+function mimeToFormat(mime) {
+	if (mime && /\s*(text|application)\/javascript\s*(;\s*charset=utf-?8\s*)?/i.test(mime)) return "module";
+	if (mime === "application/json") return "json";
+	return null;
+}
+/**
+* @callback ProtocolHandler
+* @param {URL} parsed
+* @param {{parentURL: string, source?: Buffer}} context
+* @param {boolean} ignoreErrors
+* @returns {string | null | void}
+*/
+/**
+* @type {Record<string, ProtocolHandler>}
+*/
+var protocolHandlers = {
+	__proto__: null,
+	"data:": getDataProtocolModuleFormat,
+	"file:": getFileProtocolModuleFormat,
+	"http:": getHttpProtocolModuleFormat,
+	"https:": getHttpProtocolModuleFormat,
+	"node:"() {
+		return "builtin";
+	}
+};
+/**
+* @param {URL} parsed
+*/
+function getDataProtocolModuleFormat(parsed) {
+	const { 1: mime } = /^([^/]+\/[^;,]+)[^,]*?(;base64)?,/.exec(parsed.pathname) || [
+		null,
+		null,
+		null
+	];
+	return mimeToFormat(mime);
+}
+/**
+* Returns the file extension from a URL.
+*
+* Should give similar result to
+* `require('node:path').extname(require('node:url').fileURLToPath(url))`
+* when used with a `file:` URL.
+*
+* @param {URL} url
+* @returns {string}
+*/
+function extname$1(url) {
+	const pathname = url.pathname;
+	let index = pathname.length;
+	while (index--) {
+		const code = pathname.codePointAt(index);
+		if (code === 47) return "";
+		if (code === 46) return pathname.codePointAt(index - 1) === 47 ? "" : pathname.slice(index);
+	}
+	return "";
+}
+/**
+* @type {ProtocolHandler}
+*/
+function getFileProtocolModuleFormat(url, _context, ignoreErrors) {
+	const value = extname$1(url);
+	if (value === ".js") {
+		const packageType = getPackageType(url);
+		if (packageType !== "none") return packageType;
+		return "commonjs";
+	}
+	if (value === "") {
+		const packageType = getPackageType(url);
+		if (packageType === "none" || packageType === "commonjs") return "commonjs";
+		return "module";
+	}
+	const format = extensionFormatMap[value];
+	if (format) return format;
+	if (ignoreErrors) return;
+	throw new ERR_UNKNOWN_FILE_EXTENSION(value, fileURLToPath(url));
+}
+function getHttpProtocolModuleFormat() {}
+/**
+* @param {URL} url
+* @param {{parentURL: string}} context
+* @returns {string | null}
+*/
+function defaultGetFormatWithoutErrors(url, context) {
+	const protocol = url.protocol;
+	if (!hasOwnProperty.call(protocolHandlers, protocol)) return null;
+	return protocolHandlers[protocol](url, context, true) || null;
+}
+//#endregion
+//#region ../node_modules/import-meta-resolve/lib/utils.js
+var { ERR_INVALID_ARG_VALUE } = codes;
+var DEFAULT_CONDITIONS = Object.freeze(["node", "import"]);
+var DEFAULT_CONDITIONS_SET = new Set(DEFAULT_CONDITIONS);
+/**
+* Returns the default conditions for ES module loading.
+*/
+function getDefaultConditions() {
+	return DEFAULT_CONDITIONS;
+}
+/**
+* Returns the default conditions for ES module loading, as a Set.
+*/
+function getDefaultConditionsSet() {
+	return DEFAULT_CONDITIONS_SET;
+}
+/**
+* @param {Array<string>} [conditions]
+* @returns {Set<string>}
+*/
+function getConditionsSet(conditions) {
+	if (conditions !== void 0 && conditions !== getDefaultConditions()) {
+		if (!Array.isArray(conditions)) throw new ERR_INVALID_ARG_VALUE("conditions", conditions, "expected an array");
+		return new Set(conditions);
+	}
+	return getDefaultConditionsSet();
+}
+//#endregion
+//#region ../node_modules/import-meta-resolve/lib/resolve.js
+/**
+* @import {Stats} from 'node:fs'
+* @import {ErrnoException} from './errors.js'
+* @import {PackageConfig} from './package-json-reader.js'
+*/
+var RegExpPrototypeSymbolReplace = RegExp.prototype[Symbol.replace];
+var { ERR_NETWORK_IMPORT_DISALLOWED, ERR_INVALID_MODULE_SPECIFIER, ERR_INVALID_PACKAGE_CONFIG, ERR_INVALID_PACKAGE_TARGET, ERR_MODULE_NOT_FOUND, ERR_PACKAGE_IMPORT_NOT_DEFINED, ERR_PACKAGE_PATH_NOT_EXPORTED, ERR_UNSUPPORTED_DIR_IMPORT, ERR_UNSUPPORTED_RESOLVE_REQUEST } = codes;
+var own = {}.hasOwnProperty;
+var invalidSegmentRegEx = /(^|\\|\/)((\.|%2e)(\.|%2e)?|(n|%6e|%4e)(o|%6f|%4f)(d|%64|%44)(e|%65|%45)(_|%5f)(m|%6d|%4d)(o|%6f|%4f)(d|%64|%44)(u|%75|%55)(l|%6c|%4c)(e|%65|%45)(s|%73|%53))?(\\|\/|$)/i;
+var deprecatedInvalidSegmentRegEx = /(^|\\|\/)((\.|%2e)(\.|%2e)?|(n|%6e|%4e)(o|%6f|%4f)(d|%64|%44)(e|%65|%45)(_|%5f)(m|%6d|%4d)(o|%6f|%4f)(d|%64|%44)(u|%75|%55)(l|%6c|%4c)(e|%65|%45)(s|%73|%53))(\\|\/|$)/i;
+var invalidPackageNameRegEx = /^\.|%|\\/;
+var patternRegEx = /\*/g;
+var encodedSeparatorRegEx = /%2f|%5c/i;
+/** @type {Set<string>} */
+var emittedPackageWarnings = /* @__PURE__ */ new Set();
+var doubleSlashRegEx = /[/\\]{2}/;
+/**
+*
+* @param {string} target
+* @param {string} request
+* @param {string} match
+* @param {URL} packageJsonUrl
+* @param {boolean} internal
+* @param {URL} base
+* @param {boolean} isTarget
+*/
+function emitInvalidSegmentDeprecation(target, request, match, packageJsonUrl, internal, base, isTarget) {
+	if (process$1.noDeprecation) return;
+	const pjsonPath = fileURLToPath(packageJsonUrl);
+	const double = doubleSlashRegEx.exec(isTarget ? target : request) !== null;
+	process$1.emitWarning(`Use of deprecated ${double ? "double slash" : "leading or trailing slash matching"} resolving "${target}" for module request "${request}" ${request === match ? "" : `matched to "${match}" `}in the "${internal ? "imports" : "exports"}" field module resolution of the package at ${pjsonPath}${base ? ` imported from ${fileURLToPath(base)}` : ""}.`, "DeprecationWarning", "DEP0166");
+}
+/**
+* @param {URL} url
+* @param {URL} packageJsonUrl
+* @param {URL} base
+* @param {string} [main]
+* @returns {void}
+*/
+function emitLegacyIndexDeprecation(url, packageJsonUrl, base, main) {
+	if (process$1.noDeprecation) return;
+	if (defaultGetFormatWithoutErrors(url, { parentURL: base.href }) !== "module") return;
+	const urlPath = fileURLToPath(url.href);
+	const packagePath = fileURLToPath(new URL(".", packageJsonUrl));
+	const basePath = fileURLToPath(base);
+	if (!main) process$1.emitWarning(`No "main" or "exports" field defined in the package.json for ${packagePath} resolving the main entry point "${urlPath.slice(packagePath.length)}", imported from ${basePath}.\nDefault "index" lookups for the main are deprecated for ES modules.`, "DeprecationWarning", "DEP0151");
+	else if (path.resolve(packagePath, main) !== urlPath) process$1.emitWarning(`Package ${packagePath} has a "main" field set to "${main}", excluding the full filename and extension to the resolved file at "${urlPath.slice(packagePath.length)}", imported from ${basePath}.\n Automatic extension resolution of the "main" field is deprecated for ES modules.`, "DeprecationWarning", "DEP0151");
+}
+/**
+* @param {string} path
+* @returns {Stats | undefined}
+*/
+function tryStatSync(path) {
+	try {
+		return statSync(path);
+	} catch {}
+}
+/**
+* Legacy CommonJS main resolution:
+* 1. let M = pkg_url + (json main field)
+* 2. TRY(M, M.js, M.json, M.node)
+* 3. TRY(M/index.js, M/index.json, M/index.node)
+* 4. TRY(pkg_url/index.js, pkg_url/index.json, pkg_url/index.node)
+* 5. NOT_FOUND
+*
+* @param {URL} url
+* @returns {boolean}
+*/
+function fileExists(url) {
+	const stats = statSync(url, { throwIfNoEntry: false });
+	const isFile = stats ? stats.isFile() : void 0;
+	return isFile === null || isFile === void 0 ? false : isFile;
+}
+/**
+* @param {URL} packageJsonUrl
+* @param {PackageConfig} packageConfig
+* @param {URL} base
+* @returns {URL}
+*/
+function legacyMainResolve(packageJsonUrl, packageConfig, base) {
+	/** @type {URL | undefined} */
+	let guess;
+	if (packageConfig.main !== void 0) {
+		guess = new URL(packageConfig.main, packageJsonUrl);
+		if (fileExists(guess)) return guess;
+		const tries = [
+			`./${packageConfig.main}.js`,
+			`./${packageConfig.main}.json`,
+			`./${packageConfig.main}.node`,
+			`./${packageConfig.main}/index.js`,
+			`./${packageConfig.main}/index.json`,
+			`./${packageConfig.main}/index.node`
+		];
+		let i = -1;
+		while (++i < tries.length) {
+			guess = new URL(tries[i], packageJsonUrl);
+			if (fileExists(guess)) break;
+			guess = void 0;
+		}
+		if (guess) {
+			emitLegacyIndexDeprecation(guess, packageJsonUrl, base, packageConfig.main);
+			return guess;
+		}
+	}
+	const tries = [
+		"./index.js",
+		"./index.json",
+		"./index.node"
+	];
+	let i = -1;
+	while (++i < tries.length) {
+		guess = new URL(tries[i], packageJsonUrl);
+		if (fileExists(guess)) break;
+		guess = void 0;
+	}
+	if (guess) {
+		emitLegacyIndexDeprecation(guess, packageJsonUrl, base, packageConfig.main);
+		return guess;
+	}
+	throw new ERR_MODULE_NOT_FOUND(fileURLToPath(new URL(".", packageJsonUrl)), fileURLToPath(base));
+}
+/**
+* @param {URL} resolved
+* @param {URL} base
+* @param {boolean} [preserveSymlinks]
+* @returns {URL}
+*/
+function finalizeResolution(resolved, base, preserveSymlinks) {
+	if (encodedSeparatorRegEx.exec(resolved.pathname) !== null) throw new ERR_INVALID_MODULE_SPECIFIER(resolved.pathname, "must not include encoded \"/\" or \"\\\" characters", fileURLToPath(base));
+	/** @type {string} */
+	let filePath;
+	try {
+		filePath = fileURLToPath(resolved);
+	} catch (error) {
+		const cause = error;
+		Object.defineProperty(cause, "input", { value: String(resolved) });
+		Object.defineProperty(cause, "module", { value: String(base) });
+		throw cause;
+	}
+	const stats = tryStatSync(filePath.endsWith("/") ? filePath.slice(-1) : filePath);
+	if (stats && stats.isDirectory()) {
+		const error = new ERR_UNSUPPORTED_DIR_IMPORT(filePath, fileURLToPath(base));
+		error.url = String(resolved);
+		throw error;
+	}
+	if (!stats || !stats.isFile()) {
+		const error = new ERR_MODULE_NOT_FOUND(filePath || resolved.pathname, base && fileURLToPath(base), true);
+		error.url = String(resolved);
+		throw error;
+	}
+	if (!preserveSymlinks) {
+		const real = realpathSync(filePath);
+		const { search, hash } = resolved;
+		resolved = pathToFileURL(real + (filePath.endsWith(path.sep) ? "/" : ""));
+		resolved.search = search;
+		resolved.hash = hash;
+	}
+	return resolved;
+}
+/**
+* @param {string} specifier
+* @param {URL | undefined} packageJsonUrl
+* @param {URL} base
+* @returns {Error}
+*/
+function importNotDefined(specifier, packageJsonUrl, base) {
+	return new ERR_PACKAGE_IMPORT_NOT_DEFINED(specifier, packageJsonUrl && fileURLToPath(new URL(".", packageJsonUrl)), fileURLToPath(base));
+}
+/**
+* @param {string} subpath
+* @param {URL} packageJsonUrl
+* @param {URL} base
+* @returns {Error}
+*/
+function exportsNotFound(subpath, packageJsonUrl, base) {
+	return new ERR_PACKAGE_PATH_NOT_EXPORTED(fileURLToPath(new URL(".", packageJsonUrl)), subpath, base && fileURLToPath(base));
+}
+/**
+* @param {string} request
+* @param {string} match
+* @param {URL} packageJsonUrl
+* @param {boolean} internal
+* @param {URL} [base]
+* @returns {never}
+*/
+function throwInvalidSubpath(request, match, packageJsonUrl, internal, base) {
+	throw new ERR_INVALID_MODULE_SPECIFIER(request, `request is not a valid match in pattern "${match}" for the "${internal ? "imports" : "exports"}" resolution of ${fileURLToPath(packageJsonUrl)}`, base && fileURLToPath(base));
+}
+/**
+* @param {string} subpath
+* @param {unknown} target
+* @param {URL} packageJsonUrl
+* @param {boolean} internal
+* @param {URL} [base]
+* @returns {Error}
+*/
+function invalidPackageTarget(subpath, target, packageJsonUrl, internal, base) {
+	target = typeof target === "object" && target !== null ? JSON.stringify(target, null, "") : `${target}`;
+	return new ERR_INVALID_PACKAGE_TARGET(fileURLToPath(new URL(".", packageJsonUrl)), subpath, target, internal, base && fileURLToPath(base));
+}
+/**
+* @param {string} target
+* @param {string} subpath
+* @param {string} match
+* @param {URL} packageJsonUrl
+* @param {URL} base
+* @param {boolean} pattern
+* @param {boolean} internal
+* @param {boolean} isPathMap
+* @param {Set<string> | undefined} conditions
+* @returns {URL}
+*/
+function resolvePackageTargetString(target, subpath, match, packageJsonUrl, base, pattern, internal, isPathMap, conditions) {
+	if (subpath !== "" && !pattern && target[target.length - 1] !== "/") throw invalidPackageTarget(match, target, packageJsonUrl, internal, base);
+	if (!target.startsWith("./")) {
+		if (internal && !target.startsWith("../") && !target.startsWith("/")) {
+			let isURL = false;
+			try {
+				new URL(target);
+				isURL = true;
+			} catch {}
+			if (!isURL) return packageResolve(pattern ? RegExpPrototypeSymbolReplace.call(patternRegEx, target, () => subpath) : target + subpath, packageJsonUrl, conditions);
+		}
+		throw invalidPackageTarget(match, target, packageJsonUrl, internal, base);
+	}
+	if (invalidSegmentRegEx.exec(target.slice(2)) !== null) if (deprecatedInvalidSegmentRegEx.exec(target.slice(2)) === null) {
+		if (!isPathMap) {
+			const request = pattern ? match.replace("*", () => subpath) : match + subpath;
+			emitInvalidSegmentDeprecation(pattern ? RegExpPrototypeSymbolReplace.call(patternRegEx, target, () => subpath) : target, request, match, packageJsonUrl, internal, base, true);
+		}
+	} else throw invalidPackageTarget(match, target, packageJsonUrl, internal, base);
+	const resolved = new URL(target, packageJsonUrl);
+	const resolvedPath = resolved.pathname;
+	const packagePath = new URL(".", packageJsonUrl).pathname;
+	if (!resolvedPath.startsWith(packagePath)) throw invalidPackageTarget(match, target, packageJsonUrl, internal, base);
+	if (subpath === "") return resolved;
+	if (invalidSegmentRegEx.exec(subpath) !== null) {
+		const request = pattern ? match.replace("*", () => subpath) : match + subpath;
+		if (deprecatedInvalidSegmentRegEx.exec(subpath) === null) {
+			if (!isPathMap) emitInvalidSegmentDeprecation(pattern ? RegExpPrototypeSymbolReplace.call(patternRegEx, target, () => subpath) : target, request, match, packageJsonUrl, internal, base, false);
+		} else throwInvalidSubpath(request, match, packageJsonUrl, internal, base);
+	}
+	if (pattern) return new URL(RegExpPrototypeSymbolReplace.call(patternRegEx, resolved.href, () => subpath));
+	return new URL(subpath, resolved);
+}
+/**
+* @param {string} key
+* @returns {boolean}
+*/
+function isArrayIndex(key) {
+	const keyNumber = Number(key);
+	if (`${keyNumber}` !== key) return false;
+	return keyNumber >= 0 && keyNumber < 4294967295;
+}
+/**
+* @param {URL} packageJsonUrl
+* @param {unknown} target
+* @param {string} subpath
+* @param {string} packageSubpath
+* @param {URL} base
+* @param {boolean} pattern
+* @param {boolean} internal
+* @param {boolean} isPathMap
+* @param {Set<string> | undefined} conditions
+* @returns {URL | null}
+*/
+function resolvePackageTarget(packageJsonUrl, target, subpath, packageSubpath, base, pattern, internal, isPathMap, conditions) {
+	if (typeof target === "string") return resolvePackageTargetString(target, subpath, packageSubpath, packageJsonUrl, base, pattern, internal, isPathMap, conditions);
+	if (Array.isArray(target)) {
+		/** @type {Array<unknown>} */
+		const targetList = target;
+		if (targetList.length === 0) return null;
+		/** @type {ErrnoException | null | undefined} */
+		let lastException;
+		let i = -1;
+		while (++i < targetList.length) {
+			const targetItem = targetList[i];
+			/** @type {URL | null} */
+			let resolveResult;
+			try {
+				resolveResult = resolvePackageTarget(packageJsonUrl, targetItem, subpath, packageSubpath, base, pattern, internal, isPathMap, conditions);
+			} catch (error) {
+				const exception = error;
+				lastException = exception;
+				if (exception.code === "ERR_INVALID_PACKAGE_TARGET") continue;
+				throw error;
+			}
+			if (resolveResult === void 0) continue;
+			if (resolveResult === null) {
+				lastException = null;
+				continue;
+			}
+			return resolveResult;
+		}
+		if (lastException === void 0 || lastException === null) return null;
+		throw lastException;
+	}
+	if (typeof target === "object" && target !== null) {
+		const keys = Object.getOwnPropertyNames(target);
+		let i = -1;
+		while (++i < keys.length) {
+			const key = keys[i];
+			if (isArrayIndex(key)) throw new ERR_INVALID_PACKAGE_CONFIG(fileURLToPath(packageJsonUrl), base, "\"exports\" cannot contain numeric property keys.");
+		}
+		i = -1;
+		while (++i < keys.length) {
+			const key = keys[i];
+			if (key === "default" || conditions && conditions.has(key)) {
+				const conditionalTarget = target[key];
+				const resolveResult = resolvePackageTarget(packageJsonUrl, conditionalTarget, subpath, packageSubpath, base, pattern, internal, isPathMap, conditions);
+				if (resolveResult === void 0) continue;
+				return resolveResult;
+			}
+		}
+		return null;
+	}
+	if (target === null) return null;
+	throw invalidPackageTarget(packageSubpath, target, packageJsonUrl, internal, base);
+}
+/**
+* @param {unknown} exports
+* @param {URL} packageJsonUrl
+* @param {URL} base
+* @returns {boolean}
+*/
+function isConditionalExportsMainSugar(exports, packageJsonUrl, base) {
+	if (typeof exports === "string" || Array.isArray(exports)) return true;
+	if (typeof exports !== "object" || exports === null) return false;
+	const keys = Object.getOwnPropertyNames(exports);
+	let isConditionalSugar = false;
+	let i = 0;
+	let keyIndex = -1;
+	while (++keyIndex < keys.length) {
+		const key = keys[keyIndex];
+		const currentIsConditionalSugar = key === "" || key[0] !== ".";
+		if (i++ === 0) isConditionalSugar = currentIsConditionalSugar;
+		else if (isConditionalSugar !== currentIsConditionalSugar) throw new ERR_INVALID_PACKAGE_CONFIG(fileURLToPath(packageJsonUrl), base, "\"exports\" cannot contain some keys starting with '.' and some not. The exports object must either be an object of package subpath keys or an object of main entry condition name keys only.");
+	}
+	return isConditionalSugar;
+}
+/**
+* @param {string} match
+* @param {URL} pjsonUrl
+* @param {URL} base
+*/
+function emitTrailingSlashPatternDeprecation(match, pjsonUrl, base) {
+	if (process$1.noDeprecation) return;
+	const pjsonPath = fileURLToPath(pjsonUrl);
+	if (emittedPackageWarnings.has(pjsonPath + "|" + match)) return;
+	emittedPackageWarnings.add(pjsonPath + "|" + match);
+	process$1.emitWarning(`Use of deprecated trailing slash pattern mapping "${match}" in the "exports" field module resolution of the package at ${pjsonPath}${base ? ` imported from ${fileURLToPath(base)}` : ""}. Mapping specifiers ending in "/" is no longer supported.`, "DeprecationWarning", "DEP0155");
+}
+/**
+* @param {URL} packageJsonUrl
+* @param {string} packageSubpath
+* @param {Record<string, unknown>} packageConfig
+* @param {URL} base
+* @param {Set<string> | undefined} conditions
+* @returns {URL}
+*/
+function packageExportsResolve(packageJsonUrl, packageSubpath, packageConfig, base, conditions) {
+	let exports = packageConfig.exports;
+	if (isConditionalExportsMainSugar(exports, packageJsonUrl, base)) exports = { ".": exports };
+	if (own.call(exports, packageSubpath) && !packageSubpath.includes("*") && !packageSubpath.endsWith("/")) {
+		const target = exports[packageSubpath];
+		const resolveResult = resolvePackageTarget(packageJsonUrl, target, "", packageSubpath, base, false, false, false, conditions);
+		if (resolveResult === null || resolveResult === void 0) throw exportsNotFound(packageSubpath, packageJsonUrl, base);
+		return resolveResult;
+	}
+	let bestMatch = "";
+	let bestMatchSubpath = "";
+	const keys = Object.getOwnPropertyNames(exports);
+	let i = -1;
+	while (++i < keys.length) {
+		const key = keys[i];
+		const patternIndex = key.indexOf("*");
+		if (patternIndex !== -1 && packageSubpath.startsWith(key.slice(0, patternIndex))) {
+			if (packageSubpath.endsWith("/")) emitTrailingSlashPatternDeprecation(packageSubpath, packageJsonUrl, base);
+			const patternTrailer = key.slice(patternIndex + 1);
+			if (packageSubpath.length >= key.length && packageSubpath.endsWith(patternTrailer) && patternKeyCompare(bestMatch, key) === 1 && key.lastIndexOf("*") === patternIndex) {
+				bestMatch = key;
+				bestMatchSubpath = packageSubpath.slice(patternIndex, packageSubpath.length - patternTrailer.length);
+			}
+		}
+	}
+	if (bestMatch) {
+		const target = exports[bestMatch];
+		const resolveResult = resolvePackageTarget(packageJsonUrl, target, bestMatchSubpath, bestMatch, base, true, false, packageSubpath.endsWith("/"), conditions);
+		if (resolveResult === null || resolveResult === void 0) throw exportsNotFound(packageSubpath, packageJsonUrl, base);
+		return resolveResult;
+	}
+	throw exportsNotFound(packageSubpath, packageJsonUrl, base);
+}
+/**
+* @param {string} a
+* @param {string} b
+*/
+function patternKeyCompare(a, b) {
+	const aPatternIndex = a.indexOf("*");
+	const bPatternIndex = b.indexOf("*");
+	const baseLengthA = aPatternIndex === -1 ? a.length : aPatternIndex + 1;
+	const baseLengthB = bPatternIndex === -1 ? b.length : bPatternIndex + 1;
+	if (baseLengthA > baseLengthB) return -1;
+	if (baseLengthB > baseLengthA) return 1;
+	if (aPatternIndex === -1) return 1;
+	if (bPatternIndex === -1) return -1;
+	if (a.length > b.length) return -1;
+	if (b.length > a.length) return 1;
+	return 0;
+}
+/**
+* @param {string} name
+* @param {URL} base
+* @param {Set<string>} [conditions]
+* @returns {URL}
+*/
+function packageImportsResolve(name, base, conditions) {
+	if (name === "#" || name.startsWith("#/") || name.endsWith("/")) throw new ERR_INVALID_MODULE_SPECIFIER(name, "is not a valid internal imports specifier name", fileURLToPath(base));
+	/** @type {URL | undefined} */
+	let packageJsonUrl;
+	const packageConfig = getPackageScopeConfig(base);
+	if (packageConfig.exists) {
+		packageJsonUrl = pathToFileURL(packageConfig.pjsonPath);
+		const imports = packageConfig.imports;
+		if (imports) if (own.call(imports, name) && !name.includes("*")) {
+			const resolveResult = resolvePackageTarget(packageJsonUrl, imports[name], "", name, base, false, true, false, conditions);
+			if (resolveResult !== null && resolveResult !== void 0) return resolveResult;
+		} else {
+			let bestMatch = "";
+			let bestMatchSubpath = "";
+			const keys = Object.getOwnPropertyNames(imports);
+			let i = -1;
+			while (++i < keys.length) {
+				const key = keys[i];
+				const patternIndex = key.indexOf("*");
+				if (patternIndex !== -1 && name.startsWith(key.slice(0, -1))) {
+					const patternTrailer = key.slice(patternIndex + 1);
+					if (name.length >= key.length && name.endsWith(patternTrailer) && patternKeyCompare(bestMatch, key) === 1 && key.lastIndexOf("*") === patternIndex) {
+						bestMatch = key;
+						bestMatchSubpath = name.slice(patternIndex, name.length - patternTrailer.length);
+					}
+				}
+			}
+			if (bestMatch) {
+				const target = imports[bestMatch];
+				const resolveResult = resolvePackageTarget(packageJsonUrl, target, bestMatchSubpath, bestMatch, base, true, true, false, conditions);
+				if (resolveResult !== null && resolveResult !== void 0) return resolveResult;
+			}
+		}
+	}
+	throw importNotDefined(name, packageJsonUrl, base);
+}
+/**
+* @param {string} specifier
+* @param {URL} base
+*/
+function parsePackageName(specifier, base) {
+	let separatorIndex = specifier.indexOf("/");
+	let validPackageName = true;
+	let isScoped = false;
+	if (specifier[0] === "@") {
+		isScoped = true;
+		if (separatorIndex === -1 || specifier.length === 0) validPackageName = false;
+		else separatorIndex = specifier.indexOf("/", separatorIndex + 1);
+	}
+	const packageName = separatorIndex === -1 ? specifier : specifier.slice(0, separatorIndex);
+	if (invalidPackageNameRegEx.exec(packageName) !== null) validPackageName = false;
+	if (!validPackageName) throw new ERR_INVALID_MODULE_SPECIFIER(specifier, "is not a valid package name", fileURLToPath(base));
+	return {
+		packageName,
+		packageSubpath: "." + (separatorIndex === -1 ? "" : specifier.slice(separatorIndex)),
+		isScoped
+	};
+}
+/**
+* @param {string} specifier
+* @param {URL} base
+* @param {Set<string> | undefined} conditions
+* @returns {URL}
+*/
+function packageResolve(specifier, base, conditions) {
+	if (builtinModules.includes(specifier)) return new URL("node:" + specifier);
+	const { packageName, packageSubpath, isScoped } = parsePackageName(specifier, base);
+	const packageConfig = getPackageScopeConfig(base);
+	/* c8 ignore next 16 */
+	if (packageConfig.exists) {
+		const packageJsonUrl = pathToFileURL(packageConfig.pjsonPath);
+		if (packageConfig.name === packageName && packageConfig.exports !== void 0 && packageConfig.exports !== null) return packageExportsResolve(packageJsonUrl, packageSubpath, packageConfig, base, conditions);
+	}
+	let packageJsonUrl = new URL("./node_modules/" + packageName + "/package.json", base);
+	let packageJsonPath = fileURLToPath(packageJsonUrl);
+	/** @type {string} */
+	let lastPath;
+	do {
+		const stat = tryStatSync(packageJsonPath.slice(0, -13));
+		if (!stat || !stat.isDirectory()) {
+			lastPath = packageJsonPath;
+			packageJsonUrl = new URL((isScoped ? "../../../../node_modules/" : "../../../node_modules/") + packageName + "/package.json", packageJsonUrl);
+			packageJsonPath = fileURLToPath(packageJsonUrl);
+			continue;
+		}
+		const packageConfig = read(packageJsonPath, {
+			base,
+			specifier
+		});
+		if (packageConfig.exports !== void 0 && packageConfig.exports !== null) return packageExportsResolve(packageJsonUrl, packageSubpath, packageConfig, base, conditions);
+		if (packageSubpath === ".") return legacyMainResolve(packageJsonUrl, packageConfig, base);
+		return new URL(packageSubpath, packageJsonUrl);
+	} while (packageJsonPath.length !== lastPath.length);
+	throw new ERR_MODULE_NOT_FOUND(packageName, fileURLToPath(base), false);
+}
+/**
+* @param {string} specifier
+* @returns {boolean}
+*/
+function isRelativeSpecifier(specifier) {
+	if (specifier[0] === ".") {
+		if (specifier.length === 1 || specifier[1] === "/") return true;
+		if (specifier[1] === "." && (specifier.length === 2 || specifier[2] === "/")) return true;
+	}
+	return false;
+}
+/**
+* @param {string} specifier
+* @returns {boolean}
+*/
+function shouldBeTreatedAsRelativeOrAbsolutePath(specifier) {
+	if (specifier === "") return false;
+	if (specifier[0] === "/") return true;
+	return isRelativeSpecifier(specifier);
+}
+/**
+* The “Resolver Algorithm Specification” as detailed in the Node docs (which is
+* sync and slightly lower-level than `resolve`).
+*
+* @param {string} specifier
+*   `/example.js`, `./example.js`, `../example.js`, `some-package`, `fs`, etc.
+* @param {URL} base
+*   Full URL (to a file) that `specifier` is resolved relative from.
+* @param {Set<string>} [conditions]
+*   Conditions.
+* @param {boolean} [preserveSymlinks]
+*   Keep symlinks instead of resolving them.
+* @returns {URL}
+*   A URL object to the found thing.
+*/
+function moduleResolve(specifier, base, conditions, preserveSymlinks) {
+	if (conditions === void 0) conditions = getConditionsSet();
+	const protocol = base.protocol;
+	const isRemote = protocol === "data:" || protocol === "http:" || protocol === "https:";
+	/** @type {URL | undefined} */
+	let resolved;
+	if (shouldBeTreatedAsRelativeOrAbsolutePath(specifier)) try {
+		resolved = new URL(specifier, base);
+	} catch (error_) {
+		const error = new ERR_UNSUPPORTED_RESOLVE_REQUEST(specifier, base);
+		error.cause = error_;
+		throw error;
+	}
+	else if (protocol === "file:" && specifier[0] === "#") resolved = packageImportsResolve(specifier, base, conditions);
+	else try {
+		resolved = new URL(specifier);
+	} catch (error_) {
+		if (isRemote && !builtinModules.includes(specifier)) {
+			const error = new ERR_UNSUPPORTED_RESOLVE_REQUEST(specifier, base);
+			error.cause = error_;
+			throw error;
+		}
+		resolved = packageResolve(specifier, base, conditions);
+	}
+	assert.ok(resolved !== void 0, "expected to be defined");
+	if (resolved.protocol !== "file:") return resolved;
+	return finalizeResolution(resolved, base, preserveSymlinks);
+}
+/**
+* @param {string} specifier
+* @param {URL | undefined} parsed
+* @param {URL | undefined} parsedParentURL
+*/
+function checkIfDisallowedImport(specifier, parsed, parsedParentURL) {
+	if (parsedParentURL) {
+		const parentProtocol = parsedParentURL.protocol;
+		if (parentProtocol === "http:" || parentProtocol === "https:") {
+			if (shouldBeTreatedAsRelativeOrAbsolutePath(specifier)) {
+				const parsedProtocol = parsed?.protocol;
+				if (parsedProtocol && parsedProtocol !== "https:" && parsedProtocol !== "http:") throw new ERR_NETWORK_IMPORT_DISALLOWED(specifier, parsedParentURL, "remote imports cannot import from a local location.");
+				return { url: parsed?.href || "" };
+			}
+			if (builtinModules.includes(specifier)) throw new ERR_NETWORK_IMPORT_DISALLOWED(specifier, parsedParentURL, "remote imports cannot import from a local location.");
+			throw new ERR_NETWORK_IMPORT_DISALLOWED(specifier, parsedParentURL, "only relative and absolute specifiers are supported.");
+		}
+	}
+}
+/**
+* Checks if a value has the shape of a WHATWG URL object.
+*
+* Using a symbol or instanceof would not be able to recognize URL objects
+* coming from other implementations (e.g. in Electron), so instead we are
+* checking some well known properties for a lack of a better test.
+*
+* We use `href` and `protocol` as they are the only properties that are
+* easy to retrieve and calculate due to the lazy nature of the getters.
+*
+* @template {unknown} Value
+* @param {Value} self
+* @returns {Value is URL}
+*/
+function isURL(self) {
+	return Boolean(self && typeof self === "object" && "href" in self && typeof self.href === "string" && "protocol" in self && typeof self.protocol === "string" && self.href && self.protocol);
+}
+/**
+* Validate user-input in `context` supplied by a custom loader.
+*
+* @param {unknown} parentURL
+* @returns {asserts parentURL is URL | string | undefined}
+*/
+function throwIfInvalidParentURL(parentURL) {
+	if (parentURL === void 0) return;
+	if (typeof parentURL !== "string" && !isURL(parentURL)) throw new codes.ERR_INVALID_ARG_TYPE("parentURL", ["string", "URL"], parentURL);
+}
+/**
+* @param {string} specifier
+* @param {{parentURL?: string, conditions?: Array<string>}} context
+* @returns {{url: string, format?: string | null}}
+*/
+function defaultResolve(specifier, context = {}) {
+	const { parentURL } = context;
+	assert.ok(parentURL !== void 0, "expected `parentURL` to be defined");
+	throwIfInvalidParentURL(parentURL);
+	/** @type {URL | undefined} */
+	let parsedParentURL;
+	if (parentURL) try {
+		parsedParentURL = new URL(parentURL);
+	} catch {}
+	/** @type {URL | undefined} */
+	let parsed;
+	/** @type {string | undefined} */
+	let protocol;
+	try {
+		parsed = shouldBeTreatedAsRelativeOrAbsolutePath(specifier) ? new URL(specifier, parsedParentURL) : new URL(specifier);
+		protocol = parsed.protocol;
+		if (protocol === "data:") return {
+			url: parsed.href,
+			format: null
+		};
+	} catch {}
+	const maybeReturn = checkIfDisallowedImport(specifier, parsed, parsedParentURL);
+	if (maybeReturn) return maybeReturn;
+	if (protocol === void 0 && parsed) protocol = parsed.protocol;
+	if (protocol === "node:") return { url: specifier };
+	if (parsed && parsed.protocol === "node:") return { url: specifier };
+	const conditions = getConditionsSet(context.conditions);
+	const url = moduleResolve(specifier, new URL(parentURL), conditions, false);
+	return {
+		url: url.href,
+		format: defaultGetFormatWithoutErrors(url, { parentURL })
+	};
+}
+//#endregion
+//#region ../node_modules/import-meta-resolve/index.js
+/**
+* @typedef {import('./lib/errors.js').ErrnoException} ErrnoException
+*/
+/**
+* Match `import.meta.resolve` except that `parent` is required (you can pass
+* `import.meta.url`).
+*
+* @param {string} specifier
+*   The module specifier to resolve relative to parent
+*   (`/example.js`, `./example.js`, `../example.js`, `some-package`, `fs`,
+*   etc).
+* @param {string} parent
+*   The absolute parent module URL to resolve from.
+*   You must pass `import.meta.url` or something else.
+* @returns {string}
+*   Returns a string to a full `file:`, `data:`, or `node:` URL
+*   to the found thing.
+*/
+function resolve$1(specifier, parent) {
+	if (!parent) throw new Error("Please pass `parent`: `import-meta-resolve` cannot ponyfill that");
+	try {
+		return defaultResolve(specifier, { parentURL: parent }).url;
+	} catch (error) {
+		const exception = error;
+		if ((exception.code === "ERR_UNSUPPORTED_DIR_IMPORT" || exception.code === "ERR_MODULE_NOT_FOUND") && typeof exception.url === "string") return exception.url;
+		throw error;
+	}
+}
+//#endregion
+//#region ../node_modules/semver/internal/lrucache.js
+var require_lrucache = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var LRUCache = class {
+		constructor() {
+			this.max = 1e3;
+			this.map = /* @__PURE__ */ new Map();
+		}
+		get(key) {
+			const value = this.map.get(key);
+			if (value === void 0) return;
+			else {
+				this.map.delete(key);
+				this.map.set(key, value);
+				return value;
+			}
+		}
+		delete(key) {
+			return this.map.delete(key);
+		}
+		set(key, value) {
+			if (!this.delete(key) && value !== void 0) {
+				if (this.map.size >= this.max) {
+					const firstKey = this.map.keys().next().value;
+					this.delete(firstKey);
+				}
+				this.map.set(key, value);
+			}
+			return this;
+		}
+	};
+	module.exports = LRUCache;
+}));
+//#endregion
+//#region ../node_modules/semver/internal/parse-options.js
+var require_parse_options = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var looseOption = Object.freeze({ loose: true });
+	var emptyOpts = Object.freeze({});
+	var parseOptions = (options) => {
+		if (!options) return emptyOpts;
+		if (typeof options !== "object") return looseOption;
+		return options;
+	};
+	module.exports = parseOptions;
+}));
+//#endregion
+//#region ../node_modules/semver/internal/constants.js
+var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var SEMVER_SPEC_VERSION = "2.0.0";
+	var MAX_LENGTH = 256;
+	var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
+	module.exports = {
+		MAX_LENGTH,
+		MAX_SAFE_COMPONENT_LENGTH: 16,
+		MAX_SAFE_BUILD_LENGTH: MAX_LENGTH - 6,
+		MAX_SAFE_INTEGER,
+		RELEASE_TYPES: [
+			"major",
+			"premajor",
+			"minor",
+			"preminor",
+			"patch",
+			"prepatch",
+			"prerelease"
+		],
+		SEMVER_SPEC_VERSION,
+		FLAG_INCLUDE_PRERELEASE: 1,
+		FLAG_LOOSE: 2
+	};
+}));
+//#endregion
+//#region ../node_modules/semver/internal/debug.js
+var require_debug = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {};
+}));
+//#endregion
+//#region ../node_modules/semver/internal/re.js
+var require_re = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var { MAX_SAFE_COMPONENT_LENGTH, MAX_SAFE_BUILD_LENGTH, MAX_LENGTH } = require_constants();
+	var debug = require_debug();
+	exports = module.exports = {};
+	var re = exports.re = [];
+	var safeRe = exports.safeRe = [];
+	var src = exports.src = [];
+	var safeSrc = exports.safeSrc = [];
+	var t = exports.t = {};
+	var R = 0;
+	var LETTERDASHNUMBER = "[a-zA-Z0-9-]";
+	var safeRegexReplacements = [
+		["\\s", 1],
+		["\\d", MAX_LENGTH],
+		[LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
+	];
+	var makeSafeRegex = (value) => {
+		for (const [token, max] of safeRegexReplacements) value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
+		return value;
+	};
+	var createToken = (name, value, isGlobal) => {
+		const safe = makeSafeRegex(value);
+		const index = R++;
+		debug(name, index, value);
+		t[name] = index;
+		src[index] = value;
+		safeSrc[index] = safe;
+		re[index] = new RegExp(value, isGlobal ? "g" : void 0);
+		safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
+	};
+	createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
+	createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
+	createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
+	createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})`);
+	createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})`);
+	createToken("PRERELEASEIDENTIFIER", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIER]})`);
+	createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t.NONNUMERICIDENTIFIER]}|${src[t.NUMERICIDENTIFIERLOOSE]})`);
+	createToken("PRERELEASE", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
+	createToken("PRERELEASELOOSE", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
+	createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
+	createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
+	createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
+	createToken("FULL", `^${src[t.FULLPLAIN]}$`);
+	createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);
+	createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`);
+	createToken("GTLT", "((?:<|>)?=?)");
+	createToken("XRANGEIDENTIFIERLOOSE", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
+	createToken("XRANGEIDENTIFIER", `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
+	createToken("XRANGEPLAIN", `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?)?)?`);
+	createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?)?)?`);
+	createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
+	createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
+	createToken("COERCEPLAIN", `(^|[^\\d])(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
+	createToken("COERCE", `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
+	createToken("COERCEFULL", src[t.COERCEPLAIN] + `(?:${src[t.PRERELEASE]})?(?:${src[t.BUILD]})?(?:$|[^\\d])`);
+	createToken("COERCERTL", src[t.COERCE], true);
+	createToken("COERCERTLFULL", src[t.COERCEFULL], true);
+	createToken("LONETILDE", "(?:~>?)");
+	createToken("TILDETRIM", `(\\s*)${src[t.LONETILDE]}\\s+`, true);
+	exports.tildeTrimReplace = "$1~";
+	createToken("TILDE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
+	createToken("TILDELOOSE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
+	createToken("LONECARET", "(?:\\^)");
+	createToken("CARETTRIM", `(\\s*)${src[t.LONECARET]}\\s+`, true);
+	exports.caretTrimReplace = "$1^";
+	createToken("CARET", `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
+	createToken("CARETLOOSE", `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
+	createToken("COMPARATORLOOSE", `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
+	createToken("COMPARATOR", `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
+	createToken("COMPARATORTRIM", `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
+	exports.comparatorTrimReplace = "$1$2$3";
+	createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})\\s+-\\s+(${src[t.XRANGEPLAIN]})\\s*$`);
+	createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t.XRANGEPLAINLOOSE]})\\s*$`);
+	createToken("STAR", "(<|>)?=?\\s*\\*");
+	createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
+	createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
+}));
+//#endregion
+//#region ../node_modules/semver/internal/identifiers.js
+var require_identifiers = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var numeric = /^[0-9]+$/;
+	var compareIdentifiers = (a, b) => {
+		if (typeof a === "number" && typeof b === "number") return a === b ? 0 : a < b ? -1 : 1;
+		const anum = numeric.test(a);
+		const bnum = numeric.test(b);
+		if (anum && bnum) {
+			a = +a;
+			b = +b;
+		}
+		return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
+	};
+	var rcompareIdentifiers = (a, b) => compareIdentifiers(b, a);
+	module.exports = {
+		compareIdentifiers,
+		rcompareIdentifiers
+	};
+}));
+//#endregion
+//#region ../node_modules/semver/classes/semver.js
+var require_semver = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var debug = require_debug();
+	var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants();
+	var { safeRe: re, t } = require_re();
+	var parseOptions = require_parse_options();
+	var { compareIdentifiers } = require_identifiers();
+	var isPrereleaseIdentifier = (prerelease, identifier) => {
+		const identifiers = identifier.split(".");
+		if (identifiers.length > prerelease.length) return false;
+		for (let i = 0; i < identifiers.length; i++) if (compareIdentifiers(prerelease[i], identifiers[i]) !== 0) return false;
+		return true;
+	};
+	module.exports = class SemVer {
+		constructor(version, options) {
+			options = parseOptions(options);
+			if (version instanceof SemVer) if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) return version;
+			else version = version.version;
+			else if (typeof version !== "string") throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`);
+			if (version.length > MAX_LENGTH) throw new TypeError(`version is longer than ${MAX_LENGTH} characters`);
+			debug("SemVer", version, options);
+			this.options = options;
+			this.loose = !!options.loose;
+			this.includePrerelease = !!options.includePrerelease;
+			const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
+			if (!m) throw new TypeError(`Invalid Version: ${version}`);
+			this.raw = version;
+			this.major = +m[1];
+			this.minor = +m[2];
+			this.patch = +m[3];
+			if (this.major > MAX_SAFE_INTEGER || this.major < 0) throw new TypeError("Invalid major version");
+			if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) throw new TypeError("Invalid minor version");
+			if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) throw new TypeError("Invalid patch version");
+			if (!m[4]) this.prerelease = [];
+			else this.prerelease = m[4].split(".").map((id) => {
+				if (/^[0-9]+$/.test(id)) {
+					const num = +id;
+					if (num >= 0 && num < MAX_SAFE_INTEGER) return num;
+				}
+				return id;
+			});
+			this.build = m[5] ? m[5].split(".") : [];
+			this.format();
+		}
+		format() {
+			this.version = `${this.major}.${this.minor}.${this.patch}`;
+			if (this.prerelease.length) this.version += `-${this.prerelease.join(".")}`;
+			return this.version;
+		}
+		toString() {
+			return this.version;
+		}
+		compare(other) {
+			debug("SemVer.compare", this.version, this.options, other);
+			if (!(other instanceof SemVer)) {
+				if (typeof other === "string" && other === this.version) return 0;
+				other = new SemVer(other, this.options);
+			}
+			if (other.version === this.version) return 0;
+			return this.compareMain(other) || this.comparePre(other);
+		}
+		compareMain(other) {
+			if (!(other instanceof SemVer)) other = new SemVer(other, this.options);
+			if (this.major < other.major) return -1;
+			if (this.major > other.major) return 1;
+			if (this.minor < other.minor) return -1;
+			if (this.minor > other.minor) return 1;
+			if (this.patch < other.patch) return -1;
+			if (this.patch > other.patch) return 1;
+			return 0;
+		}
+		comparePre(other) {
+			if (!(other instanceof SemVer)) other = new SemVer(other, this.options);
+			if (this.prerelease.length && !other.prerelease.length) return -1;
+			else if (!this.prerelease.length && other.prerelease.length) return 1;
+			else if (!this.prerelease.length && !other.prerelease.length) return 0;
+			let i = 0;
+			do {
+				const a = this.prerelease[i];
+				const b = other.prerelease[i];
+				debug("prerelease compare", i, a, b);
+				if (a === void 0 && b === void 0) return 0;
+				else if (b === void 0) return 1;
+				else if (a === void 0) return -1;
+				else if (a === b) continue;
+				else return compareIdentifiers(a, b);
+			} while (++i);
+		}
+		compareBuild(other) {
+			if (!(other instanceof SemVer)) other = new SemVer(other, this.options);
+			let i = 0;
+			do {
+				const a = this.build[i];
+				const b = other.build[i];
+				debug("build compare", i, a, b);
+				if (a === void 0 && b === void 0) return 0;
+				else if (b === void 0) return 1;
+				else if (a === void 0) return -1;
+				else if (a === b) continue;
+				else return compareIdentifiers(a, b);
+			} while (++i);
+		}
+		inc(release, identifier, identifierBase) {
+			if (release.startsWith("pre")) {
+				if (!identifier && identifierBase === false) throw new Error("invalid increment argument: identifier is empty");
+				if (identifier) {
+					const match = `-${identifier}`.match(this.options.loose ? re[t.PRERELEASELOOSE] : re[t.PRERELEASE]);
+					if (!match || match[1] !== identifier) throw new Error(`invalid identifier: ${identifier}`);
+				}
+			}
+			switch (release) {
+				case "premajor":
+					this.prerelease.length = 0;
+					this.patch = 0;
+					this.minor = 0;
+					this.major++;
+					this.inc("pre", identifier, identifierBase);
+					break;
+				case "preminor":
+					this.prerelease.length = 0;
+					this.patch = 0;
+					this.minor++;
+					this.inc("pre", identifier, identifierBase);
+					break;
+				case "prepatch":
+					this.prerelease.length = 0;
+					this.inc("patch", identifier, identifierBase);
+					this.inc("pre", identifier, identifierBase);
+					break;
+				case "prerelease":
+					if (this.prerelease.length === 0) this.inc("patch", identifier, identifierBase);
+					this.inc("pre", identifier, identifierBase);
+					break;
+				case "release":
+					if (this.prerelease.length === 0) throw new Error(`version ${this.raw} is not a prerelease`);
+					this.prerelease.length = 0;
+					break;
+				case "major":
+					if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) this.major++;
+					this.minor = 0;
+					this.patch = 0;
+					this.prerelease = [];
+					break;
+				case "minor":
+					if (this.patch !== 0 || this.prerelease.length === 0) this.minor++;
+					this.patch = 0;
+					this.prerelease = [];
+					break;
+				case "patch":
+					if (this.prerelease.length === 0) this.patch++;
+					this.prerelease = [];
+					break;
+				case "pre": {
+					const base = Number(identifierBase) ? 1 : 0;
+					if (this.prerelease.length === 0) this.prerelease = [base];
+					else {
+						let i = this.prerelease.length;
+						while (--i >= 0) if (typeof this.prerelease[i] === "number") {
+							this.prerelease[i]++;
+							i = -2;
+						}
+						if (i === -1) {
+							if (identifier === this.prerelease.join(".") && identifierBase === false) throw new Error("invalid increment argument: identifier already exists");
+							this.prerelease.push(base);
+						}
+					}
+					if (identifier) {
+						let prerelease = [identifier, base];
+						if (identifierBase === false) prerelease = [identifier];
+						if (isPrereleaseIdentifier(this.prerelease, identifier)) {
+							const prereleaseBase = this.prerelease[identifier.split(".").length];
+							if (isNaN(prereleaseBase)) this.prerelease = prerelease;
+						} else this.prerelease = prerelease;
+					}
+					break;
+				}
+				default: throw new Error(`invalid increment argument: ${release}`);
+			}
+			this.raw = this.format();
+			if (this.build.length) this.raw += `+${this.build.join(".")}`;
+			return this;
+		}
+	};
+}));
+//#endregion
+//#region ../node_modules/semver/functions/compare.js
+var require_compare = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var SemVer = require_semver();
+	var compare = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose));
+	module.exports = compare;
+}));
+//#endregion
+//#region ../node_modules/semver/functions/eq.js
+var require_eq = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var compare = require_compare();
+	var eq = (a, b, loose) => compare(a, b, loose) === 0;
+	module.exports = eq;
+}));
+//#endregion
+//#region ../node_modules/semver/functions/neq.js
+var require_neq = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var compare = require_compare();
+	var neq = (a, b, loose) => compare(a, b, loose) !== 0;
+	module.exports = neq;
+}));
+//#endregion
+//#region ../node_modules/semver/functions/gt.js
+var require_gt = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var compare = require_compare();
+	var gt = (a, b, loose) => compare(a, b, loose) > 0;
+	module.exports = gt;
+}));
+//#endregion
+//#region ../node_modules/semver/functions/gte.js
+var require_gte = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var compare = require_compare();
+	var gte = (a, b, loose) => compare(a, b, loose) >= 0;
+	module.exports = gte;
+}));
+//#endregion
+//#region ../node_modules/semver/functions/lt.js
+var require_lt = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var compare = require_compare();
+	var lt = (a, b, loose) => compare(a, b, loose) < 0;
+	module.exports = lt;
+}));
+//#endregion
+//#region ../node_modules/semver/functions/lte.js
+var require_lte = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var compare = require_compare();
+	var lte = (a, b, loose) => compare(a, b, loose) <= 0;
+	module.exports = lte;
+}));
+//#endregion
+//#region ../node_modules/semver/functions/cmp.js
+var require_cmp = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var eq = require_eq();
+	var neq = require_neq();
+	var gt = require_gt();
+	var gte = require_gte();
+	var lt = require_lt();
+	var lte = require_lte();
+	var cmp = (a, op, b, loose) => {
+		switch (op) {
+			case "===":
+				if (typeof a === "object") a = a.version;
+				if (typeof b === "object") b = b.version;
+				return a === b;
+			case "!==":
+				if (typeof a === "object") a = a.version;
+				if (typeof b === "object") b = b.version;
+				return a !== b;
+			case "":
+			case "=":
+			case "==": return eq(a, b, loose);
+			case "!=": return neq(a, b, loose);
+			case ">": return gt(a, b, loose);
+			case ">=": return gte(a, b, loose);
+			case "<": return lt(a, b, loose);
+			case "<=": return lte(a, b, loose);
+			default: throw new TypeError(`Invalid operator: ${op}`);
+		}
+	};
+	module.exports = cmp;
+}));
+//#endregion
+//#region ../node_modules/semver/classes/comparator.js
+var require_comparator = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var ANY = Symbol("SemVer ANY");
+	module.exports = class Comparator {
+		static get ANY() {
+			return ANY;
+		}
+		constructor(comp, options) {
+			options = parseOptions(options);
+			if (comp instanceof Comparator) if (comp.loose === !!options.loose) return comp;
+			else comp = comp.value;
+			comp = comp.trim().split(/\s+/).join(" ");
+			debug("comparator", comp, options);
+			this.options = options;
+			this.loose = !!options.loose;
+			this.parse(comp);
+			if (this.semver === ANY) this.value = "";
+			else this.value = this.operator + this.semver.version;
+			debug("comp", this);
+		}
+		parse(comp) {
+			const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
+			const m = comp.match(r);
+			if (!m) throw new TypeError(`Invalid comparator: ${comp}`);
+			this.operator = m[1] !== void 0 ? m[1] : "";
+			if (this.operator === "=") this.operator = "";
+			if (!m[2]) this.semver = ANY;
+			else this.semver = new SemVer(m[2], this.options.loose);
+		}
+		toString() {
+			return this.value;
+		}
+		test(version) {
+			debug("Comparator.test", version, this.options.loose);
+			if (this.semver === ANY || version === ANY) return true;
+			if (typeof version === "string") try {
+				version = new SemVer(version, this.options);
+			} catch (er) {
+				return false;
+			}
+			return cmp(version, this.operator, this.semver, this.options);
+		}
+		intersects(comp, options) {
+			if (!(comp instanceof Comparator)) throw new TypeError("a Comparator is required");
+			if (this.operator === "") {
+				if (this.value === "") return true;
+				return new Range(comp.value, options).test(this.value);
+			} else if (comp.operator === "") {
+				if (comp.value === "") return true;
+				return new Range(this.value, options).test(comp.semver);
+			}
+			options = parseOptions(options);
+			if (options.includePrerelease && (this.value === "<0.0.0-0" || comp.value === "<0.0.0-0")) return false;
+			if (!options.includePrerelease && (this.value.startsWith("<0.0.0") || comp.value.startsWith("<0.0.0"))) return false;
+			if (this.operator.startsWith(">") && comp.operator.startsWith(">")) return true;
+			if (this.operator.startsWith("<") && comp.operator.startsWith("<")) return true;
+			if (this.semver.version === comp.semver.version && this.operator.includes("=") && comp.operator.includes("=")) return true;
+			if (cmp(this.semver, "<", comp.semver, options) && this.operator.startsWith(">") && comp.operator.startsWith("<")) return true;
+			if (cmp(this.semver, ">", comp.semver, options) && this.operator.startsWith("<") && comp.operator.startsWith(">")) return true;
+			return false;
+		}
+	};
+	var parseOptions = require_parse_options();
+	var { safeRe: re, t } = require_re();
+	var cmp = require_cmp();
+	var debug = require_debug();
+	var SemVer = require_semver();
+	var Range = require_range();
+}));
+//#endregion
+//#region ../node_modules/semver/classes/range.js
+var require_range = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var SPACE_CHARACTERS = /\s+/g;
+	module.exports = class Range {
+		constructor(range, options) {
+			options = parseOptions(options);
+			if (range instanceof Range) if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) return range;
+			else return new Range(range.raw, options);
+			if (range instanceof Comparator) {
+				this.raw = range.value;
+				this.set = [[range]];
+				this.formatted = void 0;
+				return this;
+			}
+			this.options = options;
+			this.loose = !!options.loose;
+			this.includePrerelease = !!options.includePrerelease;
+			this.raw = range.trim().replace(SPACE_CHARACTERS, " ");
+			this.set = this.raw.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length);
+			if (!this.set.length) throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
+			if (this.set.length > 1) {
+				const first = this.set[0];
+				this.set = this.set.filter((c) => !isNullSet(c[0]));
+				if (this.set.length === 0) this.set = [first];
+				else if (this.set.length > 1) {
+					for (const c of this.set) if (c.length === 1 && isAny(c[0])) {
+						this.set = [c];
+						break;
+					}
+				}
+			}
+			this.formatted = void 0;
+		}
+		get range() {
+			if (this.formatted === void 0) {
+				this.formatted = "";
+				for (let i = 0; i < this.set.length; i++) {
+					if (i > 0) this.formatted += "||";
+					const comps = this.set[i];
+					for (let k = 0; k < comps.length; k++) {
+						if (k > 0) this.formatted += " ";
+						this.formatted += comps[k].toString().trim();
+					}
+				}
+			}
+			return this.formatted;
+		}
+		format() {
+			return this.range;
+		}
+		toString() {
+			return this.range;
+		}
+		parseRange(range) {
+			range = range.replace(BUILDSTRIPRE, "");
+			const memoKey = ((this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE)) + ":" + range;
+			const cached = cache.get(memoKey);
+			if (cached) return cached;
+			const loose = this.options.loose;
+			const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
+			range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
+			debug("hyphen replace", range);
+			range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
+			debug("comparator trim", range);
+			range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
+			debug("tilde trim", range);
+			range = range.replace(re[t.CARETTRIM], caretTrimReplace);
+			debug("caret trim", range);
+			let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
+			if (loose) rangeList = rangeList.filter((comp) => {
+				debug("loose invalid filter", comp, this.options);
+				return !!comp.match(re[t.COMPARATORLOOSE]);
+			});
+			debug("range list", rangeList);
+			const rangeMap = /* @__PURE__ */ new Map();
+			const comparators = rangeList.map((comp) => new Comparator(comp, this.options));
+			for (const comp of comparators) {
+				if (isNullSet(comp)) return [comp];
+				rangeMap.set(comp.value, comp);
+			}
+			if (rangeMap.size > 1 && rangeMap.has("")) rangeMap.delete("");
+			const result = [...rangeMap.values()];
+			cache.set(memoKey, result);
+			return result;
+		}
+		intersects(range, options) {
+			if (!(range instanceof Range)) throw new TypeError("a Range is required");
+			return this.set.some((thisComparators) => {
+				return isSatisfiable(thisComparators, options) && range.set.some((rangeComparators) => {
+					return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => {
+						return rangeComparators.every((rangeComparator) => {
+							return thisComparator.intersects(rangeComparator, options);
+						});
+					});
+				});
+			});
+		}
+		test(version) {
+			if (!version) return false;
+			if (typeof version === "string") try {
+				version = new SemVer(version, this.options);
+			} catch (er) {
+				return false;
+			}
+			for (let i = 0; i < this.set.length; i++) if (testSet(this.set[i], version, this.options)) return true;
+			return false;
+		}
+	};
+	var cache = new (require_lrucache())();
+	var parseOptions = require_parse_options();
+	var Comparator = require_comparator();
+	var debug = require_debug();
+	var SemVer = require_semver();
+	var { safeRe: re, src, t, comparatorTrimReplace, tildeTrimReplace, caretTrimReplace } = require_re();
+	var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants();
+	var BUILDSTRIPRE = new RegExp(src[t.BUILD], "g");
+	var isNullSet = (c) => c.value === "<0.0.0-0";
+	var isAny = (c) => c.value === "";
+	var isSatisfiable = (comparators, options) => {
+		let result = true;
+		const remainingComparators = comparators.slice();
+		let testComparator = remainingComparators.pop();
+		while (result && remainingComparators.length) {
+			result = remainingComparators.every((otherComparator) => {
+				return testComparator.intersects(otherComparator, options);
+			});
+			testComparator = remainingComparators.pop();
+		}
+		return result;
+	};
+	var parseComparator = (comp, options) => {
+		comp = comp.replace(re[t.BUILD], "");
+		debug("comp", comp, options);
+		comp = replaceCarets(comp, options);
+		debug("caret", comp);
+		comp = replaceTildes(comp, options);
+		debug("tildes", comp);
+		comp = replaceXRanges(comp, options);
+		debug("xrange", comp);
+		comp = replaceStars(comp, options);
+		debug("stars", comp);
+		return comp;
+	};
+	var isX = (id) => !id || id.toLowerCase() === "x" || id === "*";
+	var invalidXRangeOrder = (M, m, p) => isX(M) && !isX(m) || isX(m) && p && !isX(p);
+	var replaceTildes = (comp, options) => {
+		return comp.trim().split(/\s+/).map((c) => replaceTilde(c, options)).join(" ");
+	};
+	var replaceTilde = (comp, options) => {
+		const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
+		const z = options.includePrerelease ? "-0" : "";
+		return comp.replace(r, (_, M, m, p, pr) => {
+			debug("tilde", comp, _, M, m, p, pr);
+			let ret;
+			if (isX(M)) ret = "";
+			else if (isX(m)) ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
+			else if (isX(p)) ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
+			else if (pr) {
+				debug("replaceTilde pr", pr);
+				ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+			} else ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
+			debug("tilde return", ret);
+			return ret;
+		});
+	};
+	var replaceCarets = (comp, options) => {
+		return comp.trim().split(/\s+/).map((c) => replaceCaret(c, options)).join(" ");
+	};
+	var replaceCaret = (comp, options) => {
+		debug("caret", comp, options);
+		const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
+		const z = options.includePrerelease ? "-0" : "";
+		return comp.replace(r, (_, M, m, p, pr) => {
+			debug("caret", comp, _, M, m, p, pr);
+			let ret;
+			if (isX(M)) ret = "";
+			else if (isX(m)) ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
+			else if (isX(p)) if (M === "0") ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
+			else ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
+			else if (pr) {
+				debug("replaceCaret pr", pr);
+				if (M === "0") if (m === "0") ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`;
+				else ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+				else ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`;
+			} else {
+				debug("no pr");
+				if (M === "0") if (m === "0") ret = `>=${M}.${m}.${p} <${M}.${m}.${+p + 1}-0`;
+				else ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
+				else ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
+			}
+			debug("caret return", ret);
+			return ret;
+		});
+	};
+	var replaceXRanges = (comp, options) => {
+		debug("replaceXRanges", comp, options);
+		return comp.split(/\s+/).map((c) => replaceXRange(c, options)).join(" ");
+	};
+	var replaceXRange = (comp, options) => {
+		comp = comp.trim();
+		const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
+		return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
+			debug("xRange", comp, ret, gtlt, M, m, p, pr);
+			if (invalidXRangeOrder(M, m, p)) return comp;
+			const xM = isX(M);
+			const xm = xM || isX(m);
+			const xp = xm || isX(p);
+			const anyX = xp;
+			if (gtlt === "=" && anyX) gtlt = "";
+			pr = options.includePrerelease ? "-0" : "";
+			if (xM) if (gtlt === ">" || gtlt === "<") ret = "<0.0.0-0";
+			else ret = "*";
+			else if (gtlt && anyX) {
+				if (xm) m = 0;
+				p = 0;
+				if (gtlt === ">") {
+					gtlt = ">=";
+					if (xm) {
+						M = +M + 1;
+						m = 0;
+						p = 0;
+					} else {
+						m = +m + 1;
+						p = 0;
+					}
+				} else if (gtlt === "<=") {
+					gtlt = "<";
+					if (xm) M = +M + 1;
+					else m = +m + 1;
+				}
+				if (gtlt === "<") pr = "-0";
+				ret = `${gtlt + M}.${m}.${p}${pr}`;
+			} else if (xm) ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
+			else if (xp) ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`;
+			debug("xRange return", ret);
+			return ret;
+		});
+	};
+	var replaceStars = (comp, options) => {
+		debug("replaceStars", comp, options);
+		return comp.trim().replace(re[t.STAR], "");
+	};
+	var replaceGTE0 = (comp, options) => {
+		debug("replaceGTE0", comp, options);
+		return comp.trim().replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], "");
+	};
+	var hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => {
+		if (isX(fM)) from = "";
+		else if (isX(fm)) from = `>=${fM}.0.0${incPr ? "-0" : ""}`;
+		else if (isX(fp)) from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`;
+		else if (fpr) from = `>=${from}`;
+		else from = `>=${from}${incPr ? "-0" : ""}`;
+		if (isX(tM)) to = "";
+		else if (isX(tm)) to = `<${+tM + 1}.0.0-0`;
+		else if (isX(tp)) to = `<${tM}.${+tm + 1}.0-0`;
+		else if (tpr) to = `<=${tM}.${tm}.${tp}-${tpr}`;
+		else if (incPr) to = `<${tM}.${tm}.${+tp + 1}-0`;
+		else to = `<=${to}`;
+		return `${from} ${to}`.trim();
+	};
+	var testSet = (set, version, options) => {
+		for (let i = 0; i < set.length; i++) if (!set[i].test(version)) return false;
+		if (version.prerelease.length && !options.includePrerelease) {
+			for (let i = 0; i < set.length; i++) {
+				debug(set[i].semver);
+				if (set[i].semver === Comparator.ANY) continue;
+				if (set[i].semver.prerelease.length > 0) {
+					const allowed = set[i].semver;
+					if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) return true;
+				}
+			}
+			return false;
+		}
+		return true;
+	};
+}));
+//#endregion
+//#region ../node_modules/semver/functions/satisfies.js
+var require_satisfies = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Range = require_range();
+	var satisfies = (version, range, options) => {
+		try {
+			range = new Range(range, options);
+		} catch (er) {
+			return false;
+		}
+		return range.test(version);
+	};
+	module.exports = satisfies;
+}));
+//#endregion
+//#region ../node_modules/semver/ranges/valid.js
+var require_valid = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Range = require_range();
+	var validRange = (range, options) => {
+		try {
+			return new Range(range, options).range || "*";
+		} catch (er) {
+			return null;
+		}
+	};
+	module.exports = validRange;
+}));
+//#endregion
+//#region src/index.ts
+var import_satisfies = /* @__PURE__ */ __toESM(require_satisfies(), 1);
+var import_valid = /* @__PURE__ */ __toESM(require_valid(), 1);
+var semverSatisfies = __resolveDefaultExport(import_satisfies.default, false);
+var semverValidRange = __resolveDefaultExport(import_valid.default, false);
+globalThis.__screwUpIsInCJS_2e87ba0361d8 = false;
+function __resolveDefaultExport(module, isESM) {
+	const __isInCJS = typeof globalThis !== "undefined" && globalThis.__screwUpIsInCJS_2e87ba0361d8 === true;
+	const maybe = module;
+	const hasDefault = !!(maybe && typeof maybe === "object" && "default" in maybe);
+	const unwrapNamespaceDefault = (value) => {
+		if (!value || typeof value !== "object") return value;
+		const inner = value;
+		if ((inner.__esModule === true || typeof Symbol !== "undefined" && inner[Symbol.toStringTag] === "Module") && "default" in inner) return inner.default;
+		return value;
+	};
+	const resolvedDefault = hasDefault ? unwrapNamespaceDefault(maybe.default) : void 0;
+	if (__isInCJS) return hasDefault ? resolvedDefault ?? module : module;
+	if (isESM) {
+		if (hasDefault) return resolvedDefault;
+		throw new Error("Default export not found.");
+	}
+	return hasDefault ? resolvedDefault ?? module : module;
+}
+var protocolName = "muon-node/1";
+var supportedNodeRange = "^20.19.0 || >=22.12.0";
+var maximumFramePayloadLength = 16 * 1024 * 1024;
+var signed64Minimum = -(2n ** 63n);
+var signed64Maximum = 2n ** 63n - 1n;
+var unsigned64Maximum = 2n ** 64n - 1n;
+var reservedModuleExportNames = new Set(["$release", "then"]);
+var utf8Decoder = new TextDecoder("utf-8", { fatal: true });
+var createBridgeError = (code, message) => {
+	const error = new Error(message);
+	error.code = code;
+	return error;
+};
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isNodeError = (value) => value instanceof Error;
+var isProjectRelativeSpecifier = (specifier) => specifier === "." || specifier === ".." || specifier.startsWith("./") || specifier.startsWith("../");
+var getErrorCode = (error, fallbackCode) => {
+	if (isNodeError(error) && typeof error.code === "string" && error.code.length !== 0) return error.code;
+	return fallbackCode;
+};
+var getErrorMessage = (error) => error instanceof Error ? error.message : String(error);
+var requireRecord = (value, code, description) => {
+	if (!isRecord(value)) throw createBridgeError(code, `${description} must be an object.`);
+	return value;
+};
+var requireString = (value, code, description) => {
+	if (typeof value !== "string" || value.length === 0) throw createBridgeError(code, `${description} must be a non-empty string.`);
+	return value;
+};
+var requireArray = (value, code, description) => {
+	if (!Array.isArray(value)) throw createBridgeError(code, `${description} must be an array.`);
+	return value;
+};
+var encodeFrame = (message) => {
+	const payload = Buffer.from(JSON.stringify(message), "utf8");
+	if (payload.length > maximumFramePayloadLength) throw createBridgeError("ERR_MUON_NODE_FRAME_TOO_LARGE", "The encoded protocol frame is too large.");
+	const header = Buffer.allocUnsafe(4);
+	header.writeUInt32BE(payload.length);
+	return Buffer.concat([header, payload]);
+};
+var decodeIntegerTag = (value, kind) => {
+	const decimal = value.value;
+	if (typeof decimal !== "string" || !/^(?:0|-?[1-9][0-9]*)$/.test(decimal)) throw createBridgeError("ERR_MUON_NODE_UNSUPPORTED_VALUE", `${kind} values must contain a canonical decimal string.`);
+	let decoded;
+	try {
+		decoded = BigInt(decimal);
+	} catch {
+		throw createBridgeError("ERR_MUON_NODE_UNSUPPORTED_VALUE", `${kind} contains an invalid integer.`);
+	}
+	if (!(kind === "i64" ? decoded >= signed64Minimum && decoded <= signed64Maximum : decoded >= 0n && decoded <= unsigned64Maximum)) throw createBridgeError("ERR_MUON_NODE_UNSUPPORTED_VALUE", `${kind} is outside its supported range.`);
+	return decoded;
+};
+var decodeBufferTag = (value) => {
+	const data = value.data;
+	if (typeof data !== "string") throw createBridgeError("ERR_MUON_NODE_UNSUPPORTED_VALUE", "buffer values must contain base64 data.");
+	const decoded = Buffer.from(data, "base64");
+	if (decoded.toString("base64") !== data) throw createBridgeError("ERR_MUON_NODE_UNSUPPORTED_VALUE", "buffer contains non-canonical base64 data.");
+	return decoded;
+};
+var arrayBufferByteLengthGetter = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "byteLength")?.get;
+var hasArrayBufferInternalSlot = (value) => {
+	if (arrayBufferByteLengthGetter === void 0) return false;
+	try {
+		Reflect.apply(arrayBufferByteLengthGetter, value, []);
+		return true;
+	} catch {
+		return false;
+	}
+};
+var getBinaryView = (value) => {
+	if (Buffer.isBuffer(value)) return value;
+	if (hasArrayBufferInternalSlot(value)) return Buffer.from(value);
+	if (ArrayBuffer.isView(value)) return Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+};
+var getBinaryViewSafely = (value) => {
+	try {
+		return getBinaryView(value);
+	} catch {
+		throw createBridgeError("ERR_MUON_NODE_UNSUPPORTED_VALUE", "The bridge value could not be inspected safely.");
+	}
+};
+var unsupportedJsonErrors = /* @__PURE__ */ new WeakSet();
+var throwUnsupportedJsonValue = (message) => {
+	const error = createBridgeError("ERR_MUON_NODE_UNSUPPORTED_VALUE", message);
+	unsupportedJsonErrors.add(error);
+	throw error;
+};
+var requireJsonDataProperty = (descriptor, description) => {
+	if (descriptor === void 0 || !descriptor.enumerable || !Object.prototype.hasOwnProperty.call(descriptor, "value")) return throwUnsupportedJsonValue(`${description} must be an enumerable data property.`);
+	return descriptor.value;
+};
+var normalizeStrictJsonValue = (value, ancestors) => {
+	if (value === null || typeof value === "boolean" || typeof value === "string") return value;
+	if (typeof value === "number") {
+		if (!Number.isFinite(value) || Object.is(value, -0)) return throwUnsupportedJsonValue("JSON containers support only finite number values other than negative zero.");
+		return value;
+	}
+	if (typeof value !== "object") return throwUnsupportedJsonValue("JSON containers can contain only JSON-compatible values.");
+	if (ancestors.has(value)) return throwUnsupportedJsonValue("JSON containers cannot contain circular references.");
+	ancestors.add(value);
+	try {
+		if (Array.isArray(value)) {
+			if (Object.getPrototypeOf(value) !== Array.prototype) return throwUnsupportedJsonValue("JSON arrays must use Array.prototype.");
+			const keys = Reflect.ownKeys(value);
+			const lengthDescriptor = Object.getOwnPropertyDescriptor(value, "length");
+			if (lengthDescriptor === void 0 || lengthDescriptor.enumerable || !Object.prototype.hasOwnProperty.call(lengthDescriptor, "value") || typeof lengthDescriptor.value !== "number" || !Number.isInteger(lengthDescriptor.value) || lengthDescriptor.value < 0 || lengthDescriptor.value > 4294967295) return throwUnsupportedJsonValue("JSON arrays must have a valid length data property.");
+			const length = lengthDescriptor.value;
+			if (keys.length !== length + 1) return throwUnsupportedJsonValue("JSON arrays must be dense and cannot contain additional properties.");
+			const stringKeys = /* @__PURE__ */ new Set();
+			for (const key of keys) {
+				if (typeof key !== "string") return throwUnsupportedJsonValue("JSON arrays must be dense and cannot contain additional properties.");
+				stringKeys.add(key);
+			}
+			if (!stringKeys.has("length")) return throwUnsupportedJsonValue("JSON arrays must have a length property.");
+			const normalized = new Array(length);
+			for (let index = 0; index < length; index += 1) {
+				const key = String(index);
+				if (!stringKeys.has(key)) return throwUnsupportedJsonValue("JSON arrays must be dense and cannot contain additional properties.");
+				const element = requireJsonDataProperty(Object.getOwnPropertyDescriptor(value, key), `JSON array element ${key}`);
+				Object.defineProperty(normalized, key, {
+					value: normalizeStrictJsonValue(element, ancestors),
+					enumerable: true,
+					configurable: true,
+					writable: true
+				});
+			}
+			return normalized;
+		}
+		const prototype = Object.getPrototypeOf(value);
+		if (prototype !== Object.prototype && prototype !== null) return throwUnsupportedJsonValue("JSON objects must use Object.prototype or a null prototype.");
+		const normalized = {};
+		for (const key of Reflect.ownKeys(value)) {
+			if (typeof key !== "string") return throwUnsupportedJsonValue("JSON objects cannot contain symbol properties.");
+			const property = requireJsonDataProperty(Object.getOwnPropertyDescriptor(value, key), `JSON object property ${JSON.stringify(key)}`);
+			Object.defineProperty(normalized, key, {
+				value: normalizeStrictJsonValue(property, ancestors),
+				enumerable: true,
+				configurable: true,
+				writable: true
+			});
+		}
+		return normalized;
+	} finally {
+		ancestors.delete(value);
+	}
+};
+var normalizeStrictJsonContainer = (value) => {
+	try {
+		if (typeof value !== "object" || value === null) return throwUnsupportedJsonValue("A JSON bridge value must be an object or array.");
+		return normalizeStrictJsonValue(value, /* @__PURE__ */ new Set());
+	} catch (error) {
+		if (error !== null && (typeof error === "object" || typeof error === "function") && unsupportedJsonErrors.has(error)) throw error;
+		throw createBridgeError("ERR_MUON_NODE_UNSUPPORTED_VALUE", "The JSON bridge value could not be inspected safely.");
+	}
+};
+var encodeScalarWireValue = (value) => {
+	if (value === void 0) return { kind: "undefined" };
+	if (value === null || typeof value === "boolean" || typeof value === "string") return value;
+	if (typeof value === "number") {
+		if (!Number.isFinite(value) || Object.is(value, -0)) throw createBridgeError("ERR_MUON_NODE_UNSUPPORTED_VALUE", "Only finite number values other than negative zero are supported.");
+		return value;
+	}
+	if (typeof value === "bigint") {
+		if (value >= signed64Minimum && value <= signed64Maximum) return {
+			kind: "i64",
+			value: value.toString()
+		};
+		if (value >= 0n && value <= unsigned64Maximum) return {
+			kind: "u64",
+			value: value.toString()
+		};
+		throw createBridgeError("ERR_MUON_NODE_UNSUPPORTED_VALUE", "The bigint value is outside the i64/u64 range.");
+	}
+	const binary = getBinaryViewSafely(value);
+	if (binary !== void 0) return {
+		kind: "buffer",
+		data: binary.toString("base64")
+	};
+	throw createBridgeError("ERR_MUON_NODE_UNSUPPORTED_VALUE", "Only primitive, i64, u64, and buffer values can cross the bridge.");
+};
+var encodeWireValue = (value) => {
+	if (value !== null && typeof value === "object") {
+		if (getBinaryViewSafely(value) === void 0) return {
+			kind: "json",
+			value: normalizeStrictJsonContainer(value)
+		};
+	}
+	return encodeScalarWireValue(value);
+};
+var tokensMatch = (actual, expected) => {
+	const actualBytes = Buffer.from(actual, "utf8");
+	const expectedBytes = Buffer.from(expected, "utf8");
+	return actualBytes.length === expectedBytes.length && timingSafeEqual(actualBytes, expectedBytes);
+};
+var readPackageManifest = async (projectRoot) => {
+	const packageFile = join(projectRoot, "package.json");
+	let source;
+	try {
+		source = await readFile(packageFile, "utf8");
+	} catch (error) {
+		throw createBridgeError("ERR_MUON_NODE_PROJECT", `Unable to read the Node project package.json: ${getErrorMessage(error)}`);
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(source);
+	} catch (error) {
+		throw createBridgeError("ERR_MUON_NODE_PROJECT", `The Node project package.json is invalid: ${getErrorMessage(error)}`);
+	}
+	return requireRecord(parsed, "ERR_MUON_NODE_PROJECT", "The Node project package.json");
+};
+var validateNodeEngine = (manifest) => {
+	const enginesValue = manifest.engines;
+	if (enginesValue === void 0) return;
+	const nodeRange = requireRecord(enginesValue, "ERR_MUON_NODE_ENGINE", "package.json engines").node;
+	if (nodeRange === void 0) return;
+	if (typeof nodeRange !== "string" || nodeRange.length === 0) throw createBridgeError("ERR_MUON_NODE_ENGINE", "package.json engines.node must be a non-empty string.");
+	if (semverValidRange(nodeRange) === null) throw createBridgeError("ERR_MUON_NODE_ENGINE", `package.json engines.node is not a valid range: ${nodeRange}.`);
+	if (!semverSatisfies(process.version, nodeRange)) throw createBridgeError("ERR_MUON_NODE_ENGINE", `Node ${process.version} does not satisfy engines.node ${nodeRange}.`);
+};
+var validateHostedNodeEngine = () => {
+	if (!semverSatisfies(process.version, supportedNodeRange)) throw createBridgeError("ERR_MUON_NODE_ENGINE", `Node ${process.version} is not supported by the muon Node sidecar; expected ${supportedNodeRange}.`);
+};
+var initializeProject = async (params, expectedToken, changeWorkingDirectory) => {
+	const requestedProtocol = requireString(params.protocol, "ERR_MUON_NODE_PROTOCOL", "initialize protocol");
+	if (requestedProtocol !== protocolName) throw createBridgeError("ERR_MUON_NODE_PROTOCOL", `Unsupported muon Node protocol ${requestedProtocol}.`);
+	if (expectedToken !== void 0) {
+		if (!tokensMatch(requireString(params.token, "ERR_MUON_NODE_AUTH", "initialize token"), expectedToken)) throw createBridgeError("ERR_MUON_NODE_AUTH", "The initialize token is invalid.");
+	}
+	validateHostedNodeEngine();
+	const requestedRoot = requireString(params.projectRoot, "ERR_MUON_NODE_PROJECT", "initialize projectRoot");
+	let root;
+	try {
+		root = await realpath(resolve(requestedRoot));
+	} catch (error) {
+		throw createBridgeError("ERR_MUON_NODE_PROJECT", `Unable to resolve the Node project: ${getErrorMessage(error)}`);
+	}
+	validateNodeEngine(await readPackageManifest(root));
+	if (changeWorkingDirectory) try {
+		process.chdir(root);
+	} catch (error) {
+		throw createBridgeError("ERR_MUON_NODE_PROJECT", `Unable to use the Node project as the working directory: ${getErrorMessage(error)}`);
+	}
+	return {
+		root,
+		parentUrl: pathToFileURL(join(root, "package.json")).href
+	};
+};
+var isCommonJsFile = async (filePath) => {
+	const extension = extname(filePath);
+	if (extension === ".cjs") return true;
+	if (extension === ".mjs") return false;
+	if (extension !== ".js") return false;
+	let directory = dirname(filePath);
+	const filesystemRoot = parse(directory).root;
+	while (true) {
+		try {
+			const source = await readFile(join(directory, "package.json"), "utf8");
+			const manifest = JSON.parse(source);
+			return !isRecord(manifest) || manifest.type !== "module";
+		} catch (error) {
+			if (!isNodeError(error) || error.code !== "ENOENT") throw error;
+		}
+		if (directory === filesystemRoot) return true;
+		directory = dirname(directory);
+	}
+};
+var importNamespaceWithoutThenableAssimilation = async (specifier) => {
+	const wrapperSource = [`import * as namespace from ${JSON.stringify(specifier)};`, "export default { namespace };"].join("\n");
+	return { namespace: requireRecord(requireRecord((await import(
+		/* @vite-ignore */
+		`data:text/javascript;charset=utf-8,${encodeURIComponent(wrapperSource)}`
+)).default, "ERR_MUON_NODE_MODULE_SPECIFIER", "Internal module namespace holder").namespace, "ERR_MUON_NODE_MODULE_SPECIFIER", "Imported module namespace") };
+};
+var importProjectModule = async (project, specifier) => {
+	if (specifier.startsWith("node:")) {
+		if (!isBuiltin(specifier)) throw createBridgeError("ERR_MUON_NODE_BUILTIN_SPECIFIER", `${specifier} is not a Node built-in module.`);
+		return {
+			namespace: (await importNamespaceWithoutThenableAssimilation(specifier)).namespace,
+			resolvedFile: void 0
+		};
+	}
+	if (isBuiltin(specifier)) throw createBridgeError("ERR_MUON_NODE_BUILTIN_SPECIFIER", `Node built-in modules must use the node: prefix: node:${specifier}.`);
+	if (isAbsolute(specifier) || /^[A-Za-z][A-Za-z+.-]*:/.test(specifier)) throw createBridgeError("ERR_MUON_NODE_MODULE_OUTSIDE_PROJECT", "Absolute module specifiers are not supported.");
+	let resolvedUrl;
+	if (specifier === ".") try {
+		resolvedUrl = pathToFileURL(createRequire(project.parentUrl).resolve(project.root));
+	} catch (error) {
+		throw createBridgeError(getErrorCode(error, "ERR_MUON_NODE_MODULE_NOT_FOUND"), getErrorMessage(error));
+	}
+	else try {
+		resolvedUrl = new URL(resolve$1(specifier, project.parentUrl));
+	} catch (error) {
+		throw createBridgeError(getErrorCode(error, "ERR_MUON_NODE_MODULE_NOT_FOUND"), getErrorMessage(error));
+	}
+	if (resolvedUrl.protocol !== "file:") throw createBridgeError("ERR_MUON_NODE_MODULE_SPECIFIER", `Unsupported resolved module protocol ${resolvedUrl.protocol}.`);
+	const resolvedFile = fileURLToPath(resolvedUrl);
+	if (isProjectRelativeSpecifier(specifier)) {
+		if (resolvedFile !== project.root && !resolvedFile.startsWith(`${project.root}${sep}`)) throw createBridgeError("ERR_MUON_NODE_MODULE_OUTSIDE_PROJECT", "Project-relative imports cannot leave the configured project root.");
+	}
+	return {
+		namespace: (await importNamespaceWithoutThenableAssimilation(resolvedUrl.href)).namespace,
+		resolvedFile
+	};
+};
+var collectModuleExports = async (imported) => {
+	const exports = /* @__PURE__ */ new Map();
+	for (const name of Object.keys(imported.namespace)) exports.set(name, {
+		value: imported.namespace[name],
+		receiver: void 0
+	});
+	if (imported.resolvedFile !== void 0 && await isCommonJsFile(imported.resolvedFile)) {
+		const commonJsExports = imported.namespace.default;
+		if (commonJsExports !== null && (typeof commonJsExports === "object" || typeof commonJsExports === "function")) for (const name of Object.keys(commonJsExports)) {
+			if (name === "default") continue;
+			exports.set(name, {
+				value: Reflect.get(commonJsExports, name),
+				receiver: commonJsExports
+			});
+		}
+	}
+	return { exports };
+};
+var describeModuleExports = (exports) => {
+	const descriptor = [];
+	const names = [...exports.keys()].sort();
+	for (const name of names) {
+		const value = exports.get(name)?.value;
+		if (typeof value === "function") {
+			descriptor.push({
+				name,
+				kind: "function",
+				value: void 0
+			});
+			continue;
+		}
+		try {
+			descriptor.push({
+				name,
+				kind: "primitive",
+				value: encodeScalarWireValue(value)
+			});
+		} catch (error) {
+			if (getErrorCode(error, "") !== "ERR_MUON_NODE_UNSUPPORTED_VALUE") throw error;
+		}
+	}
+	return descriptor.map((entry) => entry.kind === "function" ? {
+		name: entry.name,
+		kind: entry.kind
+	} : entry);
+};
+var parseRequest = (value) => {
+	const message = requireRecord(value, "ERR_MUON_NODE_PROTOCOL", "Protocol message");
+	if (message.kind !== "request") throw createBridgeError("ERR_MUON_NODE_PROTOCOL", "Expected a request or callbackResult message.");
+	return {
+		kind: "request",
+		id: requireString(message.id, "ERR_MUON_NODE_PROTOCOL", "Request id"),
+		command: requireString(message.command, "ERR_MUON_NODE_PROTOCOL", "Request command"),
+		params: requireRecord(message.params, "ERR_MUON_NODE_PROTOCOL", "Request params")
+	};
+};
+var parseCallbackResult = (value) => {
+	const message = requireRecord(value, "ERR_MUON_NODE_PROTOCOL", "Callback result");
+	const id = requireString(message.id, "ERR_MUON_NODE_PROTOCOL", "Callback result id");
+	if (typeof message.ok !== "boolean") throw createBridgeError("ERR_MUON_NODE_PROTOCOL", "Callback result ok must be a boolean.");
+	if (message.ok) return {
+		kind: "callbackResult",
+		id,
+		ok: true,
+		value: message.value,
+		error: null
+	};
+	const error = requireRecord(message.error, "ERR_MUON_NODE_PROTOCOL", "Callback result error");
+	return {
+		kind: "callbackResult",
+		id,
+		ok: false,
+		value: void 0,
+		error: {
+			code: requireString(error.code, "ERR_MUON_NODE_PROTOCOL", "Callback error code"),
+			message: requireString(error.message, "ERR_MUON_NODE_PROTOCOL", "Callback error message")
+		}
+	};
+};
+/**
+* Creates a host for framed muon Node requests.
+*
+* @param options - Streams and optional transport authentication token.
+* @returns A bridge whose lifecycle remains owned by the caller.
+*/
+var createMuonNodeBridge = (options) => {
+	let pendingInput = Buffer.alloc(0);
+	let project = void 0;
+	let nextModuleId = 1;
+	let nextCallbackId = 1;
+	let initializationDrain = void 0;
+	let closeOperation = void 0;
+	let closing = false;
+	let shutdownRequested = false;
+	let shutdownSettled = false;
+	const requests = [];
+	const activeRequests = /* @__PURE__ */ new Set();
+	const modules = /* @__PURE__ */ new Map();
+	const releasedModules = /* @__PURE__ */ new Set();
+	const pendingCallbacks = /* @__PURE__ */ new Map();
+	let resolveShutdown = () => void 0;
+	let rejectShutdown = () => void 0;
+	const shutdown = new Promise((resolvePromise, rejectPromise) => {
+		resolveShutdown = resolvePromise;
+		rejectShutdown = rejectPromise;
+	});
+	const signalShutdown = (error) => {
+		if (shutdownSettled) return;
+		shutdownSettled = true;
+		if (error === void 0) resolveShutdown();
+		else rejectShutdown(error);
+	};
+	const writeMessage = async (message) => {
+		const frame = encodeFrame(message);
+		await new Promise((resolvePromise, rejectPromise) => {
+			options.output.write(frame, (error) => {
+				if (error !== void 0 && error !== null) {
+					rejectPromise(error);
+					return;
+				}
+				resolvePromise();
+			});
+		});
+	};
+	const rejectPendingCallbacks = (error) => {
+		for (const callback of pendingCallbacks.values()) callback.reject(error);
+		pendingCallbacks.clear();
+	};
+	const invokeRemoteCallback = async (handle, argumentsValue) => {
+		if (closing) throw createBridgeError("ERR_MUON_NODE_CLOSED", "The muon Node bridge is closing.");
+		const id = `callback-${nextCallbackId}`;
+		nextCallbackId += 1;
+		const encodedArguments = argumentsValue.map((value) => encodeWireValue(value));
+		const result = new Promise((resolvePromise, rejectPromise) => {
+			pendingCallbacks.set(id, {
+				resolve: resolvePromise,
+				reject: rejectPromise
+			});
+		});
+		try {
+			const [, callbackResult] = await Promise.all([writeMessage({
+				kind: "callback",
+				id,
+				handle,
+				arguments: encodedArguments
+			}), result]);
+			return callbackResult;
+		} finally {
+			pendingCallbacks.delete(id);
+		}
+	};
+	const decodeWireValue = (value) => {
+		if (value === null || typeof value === "boolean" || typeof value === "string") return value;
+		if (typeof value === "number") {
+			if (!Number.isFinite(value) || Object.is(value, -0)) throw createBridgeError("ERR_MUON_NODE_UNSUPPORTED_VALUE", "Only finite number values other than negative zero are supported.");
+			return value;
+		}
+		const tagged = requireRecord(value, "ERR_MUON_NODE_UNSUPPORTED_VALUE", "Wire value");
+		if (tagged.kind === "undefined") return;
+		if (tagged.kind === "i64" || tagged.kind === "u64") return decodeIntegerTag(tagged, tagged.kind);
+		if (tagged.kind === "buffer") return decodeBufferTag(tagged);
+		if (tagged.kind === "json") return normalizeStrictJsonContainer(tagged.value);
+		if (tagged.kind === "function") {
+			const handle = requireString(tagged.handle, "ERR_MUON_NODE_UNSUPPORTED_VALUE", "Function handle");
+			return async (...argumentsValue) => await invokeRemoteCallback(handle, argumentsValue);
+		}
+		throw createBridgeError("ERR_MUON_NODE_UNSUPPORTED_VALUE", "Arbitrary object values cannot cross the muon Node bridge.");
+	};
+	const requireProject = () => {
+		if (project === void 0) throw createBridgeError("ERR_MUON_NODE_NOT_INITIALIZED", "The muon Node bridge has not been initialized.");
+		return project;
+	};
+	const importModule = async (params) => {
+		const collected = await collectModuleExports(await importProjectModule(requireProject(), requireString(params.specifier, "ERR_MUON_NODE_MODULE_SPECIFIER", "Module specifier")));
+		for (const reservedName of reservedModuleExportNames) if (collected.exports.has(reservedName)) throw createBridgeError("ERR_MUON_NODE_RESERVED_EXPORT", `Module export ${reservedName} is reserved by the muon Node facade.`);
+		const descriptor = { exports: describeModuleExports(collected.exports) };
+		const moduleId = `module-${nextModuleId}`;
+		nextModuleId += 1;
+		modules.set(moduleId, { exports: collected.exports });
+		return {
+			moduleId,
+			descriptor
+		};
+	};
+	const callModuleExport = async (params) => {
+		requireProject();
+		const moduleId = requireString(params.moduleId, "ERR_MUON_NODE_UNKNOWN_HANDLE", "Module id");
+		if (releasedModules.has(moduleId)) throw createBridgeError("ERR_MUON_NODE_RELEASED_HANDLE", `Module handle ${moduleId} has been released.`);
+		const module = modules.get(moduleId);
+		if (module === void 0) throw createBridgeError("ERR_MUON_NODE_UNKNOWN_HANDLE", `Unknown module handle ${moduleId}.`);
+		const exportName = requireString(params.exportName, "ERR_MUON_NODE_EXPORT", "Export name");
+		const exported = module.exports.get(exportName);
+		if (exported === void 0 || typeof exported.value !== "function") throw createBridgeError("ERR_MUON_NODE_NOT_CALLABLE", `Module export ${exportName} is not callable.`);
+		const argumentsValue = requireArray(params.arguments, "ERR_MUON_NODE_UNSUPPORTED_VALUE", "Call arguments").map((value) => decodeWireValue(value));
+		return encodeWireValue(await Reflect.apply(exported.value, exported.receiver, argumentsValue));
+	};
+	const releaseHandle = (params) => {
+		requireProject();
+		const kind = requireString(params.kind, "ERR_MUON_NODE_UNKNOWN_HANDLE", "Release kind");
+		const handle = requireString(params.handle, "ERR_MUON_NODE_UNKNOWN_HANDLE", "Release handle");
+		if (kind === "module") {
+			const released = modules.delete(handle);
+			releasedModules.add(handle);
+			return { released };
+		}
+		throw createBridgeError("ERR_MUON_NODE_UNKNOWN_HANDLE", `Unsupported release kind ${kind}.`);
+	};
+	const executeCommand = async (request) => {
+		if (shutdownRequested) throw createBridgeError("ERR_MUON_NODE_CLOSED", "The muon Node bridge is shutting down.");
+		switch (request.command) {
+			case "initialize":
+				if (project !== void 0) throw createBridgeError("ERR_MUON_NODE_ALREADY_INITIALIZED", "The muon Node bridge is already initialized.");
+				project = await initializeProject(request.params, options.expectedToken, options.changeWorkingDirectory);
+				return {
+					value: {
+						protocol: protocolName,
+						nodeVersion: process.version
+					},
+					shutdown: false,
+					responseFailure: void 0
+				};
+			case "importModule": {
+				const imported = await importModule(request.params);
+				return {
+					value: imported,
+					shutdown: false,
+					responseFailure: () => {
+						modules.delete(imported.moduleId);
+					}
+				};
+			}
+			case "call": return {
+				value: await callModuleExport(request.params),
+				shutdown: false,
+				responseFailure: void 0
+			};
+			case "release": return {
+				value: releaseHandle(request.params),
+				shutdown: false,
+				responseFailure: void 0
+			};
+			case "shutdown":
+				requireProject();
+				shutdownRequested = true;
+				return {
+					value: { shutdown: true },
+					shutdown: true,
+					responseFailure: void 0
+				};
+			default: throw createBridgeError("ERR_MUON_NODE_UNKNOWN_COMMAND", `Unknown muon Node command ${request.command}.`);
+		}
+	};
+	const processRequest = async (request) => {
+		const writeFailure = async (error) => {
+			if (closing) return;
+			await writeMessage({
+				kind: "response",
+				id: request.id,
+				ok: false,
+				error: {
+					code: getErrorCode(error, "ERR_MUON_NODE_REQUEST"),
+					message: getErrorMessage(error)
+				}
+			});
+		};
+		let result;
+		try {
+			result = await executeCommand(request);
+		} catch (error) {
+			await writeFailure(error);
+			return;
+		}
+		if (closing) {
+			result.responseFailure?.();
+			return;
+		}
+		try {
+			await writeMessage({
+				kind: "response",
+				id: request.id,
+				ok: true,
+				value: result.value
+			});
+		} catch (error) {
+			result.responseFailure?.();
+			if (getErrorCode(error, "") !== "ERR_MUON_NODE_FRAME_TOO_LARGE") throw error;
+			await writeFailure(error);
+			return;
+		}
+		if (result.shutdown) signalShutdown(void 0);
+	};
+	const handleCallbackResult = (result) => {
+		const callback = pendingCallbacks.get(result.id);
+		if (callback === void 0) throw createBridgeError("ERR_MUON_NODE_UNKNOWN_CALLBACK", `Unknown callback result id ${result.id}.`);
+		pendingCallbacks.delete(result.id);
+		if (result.ok) {
+			try {
+				callback.resolve(decodeWireValue(result.value));
+			} catch (error) {
+				callback.reject(error instanceof Error ? error : new Error(String(error)));
+			}
+			return;
+		}
+		const callbackError = result.error;
+		if (callbackError === null) {
+			callback.reject(createBridgeError("ERR_MUON_NODE_PROTOCOL", "A failed callback result omitted its error."));
+			return;
+		}
+		callback.reject(createBridgeError(callbackError.code, callbackError.message));
+	};
+	const parseInputFrames = () => {
+		while (pendingInput.length >= 4) {
+			const payloadLength = pendingInput.readUInt32BE(0);
+			if (payloadLength > maximumFramePayloadLength) throw createBridgeError("ERR_MUON_NODE_FRAME_TOO_LARGE", "The incoming protocol frame is too large.");
+			const frameLength = payloadLength + 4;
+			if (pendingInput.length < frameLength) return;
+			const payload = pendingInput.subarray(4, frameLength);
+			pendingInput = pendingInput.subarray(frameLength);
+			let source;
+			try {
+				source = utf8Decoder.decode(payload);
+			} catch {
+				throw createBridgeError("ERR_MUON_NODE_PROTOCOL", "The protocol frame payload is not valid UTF-8.");
+			}
+			let decoded;
+			try {
+				decoded = JSON.parse(source);
+			} catch (error) {
+				throw createBridgeError("ERR_MUON_NODE_PROTOCOL", `The protocol frame is not valid JSON: ${getErrorMessage(error)}`);
+			}
+			if (isRecord(decoded) && decoded.kind === "callbackResult") handleCallbackResult(parseCallbackResult(decoded));
+			else requests.push(parseRequest(decoded));
+		}
+	};
+	const handleFatalError = (error) => {
+		if (closing) return;
+		closing = true;
+		options.input.pause();
+		const fatalError = createBridgeError(getErrorCode(error, "ERR_MUON_NODE_PROTOCOL"), getErrorMessage(error));
+		rejectPendingCallbacks(fatalError);
+		signalShutdown(fatalError);
+	};
+	const runActiveRequest = async (activeRequest, request) => {
+		try {
+			await processRequest(request);
+		} catch (error) {
+			handleFatalError(error);
+		} finally {
+			activeRequests.delete(activeRequest);
+		}
+	};
+	const startActiveRequest = (request) => {
+		if (closing) return;
+		const activeRequest = { operation: void 0 };
+		activeRequests.add(activeRequest);
+		activeRequest.operation = runActiveRequest(activeRequest, request);
+	};
+	const scheduleRequests = () => {
+		if (closing || requests.length === 0 || initializationDrain !== void 0) return;
+		if (project !== void 0) for (;;) {
+			const request = requests.shift();
+			if (request === void 0) return;
+			startActiveRequest(request);
+		}
+		initializationDrain = drainInitializationRequests();
+	};
+	const drainInitializationRequests = async () => {
+		try {
+			while (!closing && project === void 0) {
+				const request = requests.shift();
+				if (request === void 0) return;
+				await processRequest(request);
+			}
+			if (!closing) for (;;) {
+				const request = requests.shift();
+				if (request === void 0) return;
+				startActiveRequest(request);
+			}
+		} catch (error) {
+			handleFatalError(error);
+		} finally {
+			initializationDrain = void 0;
+			scheduleRequests();
+		}
+	};
+	const consumeInput = (chunk) => {
+		const bytes = typeof chunk === "string" ? Buffer.from(chunk) : Buffer.isBuffer(chunk) ? chunk : chunk instanceof Uint8Array ? Buffer.from(chunk) : void 0;
+		if (bytes === void 0) throw createBridgeError("ERR_MUON_NODE_PROTOCOL", "The protocol input emitted a non-binary chunk.");
+		pendingInput = Buffer.concat([pendingInput, bytes]);
+		parseInputFrames();
+		scheduleRequests();
+	};
+	const handleInputData = (chunk) => {
+		try {
+			consumeInput(chunk);
+		} catch (error) {
+			handleFatalError(error);
+		}
+	};
+	const handleInputEnd = () => {
+		if (pendingInput.length !== 0) {
+			handleFatalError(createBridgeError("ERR_MUON_NODE_PROTOCOL", "The protocol input ended with an incomplete frame."));
+			return;
+		}
+		closing = true;
+		rejectPendingCallbacks(createBridgeError("ERR_MUON_NODE_CLOSED", "The muon Node protocol input ended."));
+		signalShutdown(void 0);
+	};
+	const handleStreamError = (error) => {
+		handleFatalError(error);
+	};
+	options.input.on("data", handleInputData);
+	options.input.on("end", handleInputEnd);
+	options.input.on("error", handleStreamError);
+	options.output.on("error", handleStreamError);
+	const performClose = async () => {
+		closing = true;
+		options.input.removeListener("data", handleInputData);
+		options.input.removeListener("end", handleInputEnd);
+		options.input.removeListener("error", handleStreamError);
+		rejectPendingCallbacks(createBridgeError("ERR_MUON_NODE_CLOSED", "The muon Node bridge was closed."));
+		options.output.removeListener("error", handleStreamError);
+		requests.splice(0);
+		activeRequests.clear();
+		modules.clear();
+		signalShutdown(void 0);
+	};
+	return {
+		waitForShutdown: async () => {
+			await shutdown;
+		},
+		close: async () => {
+			if (closeOperation === void 0) closeOperation = performClose();
+			await closeOperation;
+		}
+	};
+};
+//#endregion
+//#region src/cli.ts
+var requireEnvironment = (name) => {
+	const value = process.env[name];
+	if (value === void 0 || value.length === 0) throw new Error(`${name} must contain a non-empty value.`);
+	return value;
+};
+var finishWritable = async (output) => {
+	if (output.destroyed || output.writableEnded) return;
+	await new Promise((resolvePromise, rejectPromise) => {
+		const handleError = (error) => {
+			output.removeListener("finish", handleFinish);
+			rejectPromise(error);
+		};
+		const handleFinish = () => {
+			output.removeListener("error", handleError);
+			resolvePromise();
+		};
+		output.once("error", handleError);
+		output.once("finish", handleFinish);
+		output.end();
+	});
+};
+var writeStandardError = async (message) => {
+	await new Promise((resolvePromise, rejectPromise) => {
+		process.stderr.write(message, (error) => {
+			if (error !== null && error !== void 0) {
+				rejectPromise(error);
+				return;
+			}
+			resolvePromise();
+		});
+	});
+};
+var parseInheritedFileDescriptor = (source) => {
+	if (!/^[0-9]+$/.test(source)) throw new Error("MUON_NODE_FD must be a decimal file descriptor.");
+	const fileDescriptor = Number(source);
+	if (!Number.isSafeInteger(fileDescriptor) || fileDescriptor < 3) throw new Error("MUON_NODE_FD must identify an inherited descriptor.");
+	return fileDescriptor;
+};
+var openInheritedFileDescriptor = (fileDescriptor) => {
+	const socket = new Socket({
+		fd: fileDescriptor,
+		readable: true,
+		writable: true,
+		allowHalfOpen: true
+	});
+	let closed = false;
+	return {
+		input: socket,
+		output: socket,
+		close: async () => {
+			if (closed) return;
+			closed = true;
+			try {
+				await finishWritable(socket);
+			} finally {
+				socket.destroy();
+			}
+		}
+	};
+};
+var waitForSocketConnection = async (socket) => {
+	await new Promise((resolvePromise, rejectPromise) => {
+		const handleConnect = () => {
+			socket.removeListener("error", handleError);
+			resolvePromise();
+		};
+		const handleError = (error) => {
+			socket.removeListener("connect", handleConnect);
+			rejectPromise(error);
+		};
+		socket.once("connect", handleConnect);
+		socket.once("error", handleError);
+	});
+};
+var openWindowsNamedPipe = async (pipeName) => {
+	const socket = createConnection({
+		path: pipeName,
+		allowHalfOpen: true
+	});
+	try {
+		await waitForSocketConnection(socket);
+	} catch (error) {
+		socket.destroy();
+		throw error;
+	}
+	let closed = false;
+	return {
+		input: socket,
+		output: socket,
+		close: async () => {
+			if (closed) return;
+			closed = true;
+			try {
+				await finishWritable(socket);
+			} finally {
+				socket.destroy();
+			}
+		}
+	};
+};
+var openSidecarConnection = async () => {
+	if (process.platform === "win32") return await openWindowsNamedPipe(requireEnvironment("MUON_NODE_PIPE"));
+	return openInheritedFileDescriptor(parseInheritedFileDescriptor(requireEnvironment("MUON_NODE_FD")));
+};
+var runSidecar = async () => {
+	const expectedToken = requireEnvironment("MUON_NODE_TOKEN");
+	delete process.env.MUON_NODE_TOKEN;
+	const connection = await openSidecarConnection();
+	const bridge = createMuonNodeBridge({
+		input: connection.input,
+		output: connection.output,
+		expectedToken,
+		changeWorkingDirectory: true
+	});
+	try {
+		await bridge.waitForShutdown();
+	} finally {
+		try {
+			await bridge.close();
+		} finally {
+			await connection.close();
+		}
+	}
+};
+try {
+	await runSidecar();
+	process.exit(0);
+} catch (error) {
+	const message = error instanceof Error ? error.stack ?? error.message : String(error);
+	try {
+		await writeStandardError(`muon Node sidecar failed: ${message}\n`);
+	} finally {
+		process.exit(1);
+	}
+}
+//#endregion