@systemfsoftware/stryker-js-vitest-runner 6.0.0 → 7.0.0

package/dist/src-js-DRK8boNV.mjs

@@ -0,0 +1,1009 @@
+import { createRequire } from "node:module";
+import { createRequire as createRequire$1 } from "module";
+//#region ../../node_modules/.pnpm/oxc-parser@0.140.0/node_modules/oxc-parser/src-js/bindings.js
+const require$1 = createRequire$1(import.meta.url);
+new URL(".", import.meta.url).pathname;
+const { readFileSync } = require$1("fs");
+let nativeBinding = null;
+const loadErrors = [];
+const isMusl = () => {
+	let musl = false;
+	if (process.platform === "linux") {
+		musl = isMuslFromFilesystem();
+		if (musl === null) musl = isMuslFromReport();
+		if (musl === null) musl = isMuslFromChildProcess();
+	}
+	return musl;
+};
+const isFileMusl = (f) => f.includes("libc.musl-") || f.includes("ld-musl-");
+const isMuslFromFilesystem = () => {
+	try {
+		return readFileSync("/usr/bin/ldd", "utf-8").includes("musl");
+	} catch {
+		return null;
+	}
+};
+const isMuslFromReport = () => {
+	let report = null;
+	if (process.report && typeof process.report.getReport === "function") {
+		process.report.excludeNetwork = true;
+		report = process.report.getReport();
+	}
+	if (!report) return null;
+	if (report.header && report.header.glibcVersionRuntime) return false;
+	if (Array.isArray(report.sharedObjects)) {
+		if (report.sharedObjects.some(isFileMusl)) return true;
+	}
+	return false;
+};
+const isMuslFromChildProcess = () => {
+	try {
+		return require$1("child_process").execSync("ldd --version", { encoding: "utf8" }).includes("musl");
+	} catch (e) {
+		return false;
+	}
+};
+function requireNative() {
+	if (process.env.NAPI_RS_NATIVE_LIBRARY_PATH) try {
+		return require$1(process.env.NAPI_RS_NATIVE_LIBRARY_PATH);
+	} catch (err) {
+		loadErrors.push(err);
+	}
+	else if (process.platform === "android") {
+		if (process.arch === "arm64") {
+			try {
+				return require$1("./parser.android-arm64.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = require$1("@oxc-parser/binding-android-arm64");
+				const bindingPackageVersion = require$1("@oxc-parser/binding-android-arm64/package.json").version;
+				if (bindingPackageVersion !== "0.140.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 0.140.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else if (process.arch === "arm") {
+			try {
+				return require$1("./parser.android-arm-eabi.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = require$1("@oxc-parser/binding-android-arm-eabi");
+				const bindingPackageVersion = require$1("@oxc-parser/binding-android-arm-eabi/package.json").version;
+				if (bindingPackageVersion !== "0.140.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 0.140.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else loadErrors.push(/* @__PURE__ */ new Error(`Unsupported architecture on Android ${process.arch}`));
+	} else if (process.platform === "win32") {
+		if (process.arch === "x64") {
+			if (process.config && process.config.variables && process.config.variables.shlib_suffix === "dll.a" || process.config && process.config.variables && process.config.variables.node_target_type === "shared_library") {
+				try {
+					return require$1("./parser.win32-x64-gnu.node");
+				} catch (e) {
+					loadErrors.push(e);
+				}
+				try {
+					const binding = require$1("@oxc-parser/binding-win32-x64-gnu");
+					const bindingPackageVersion = require$1("@oxc-parser/binding-win32-x64-gnu/package.json").version;
+					if (bindingPackageVersion !== "0.140.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 0.140.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+					return binding;
+				} catch (e) {
+					loadErrors.push(e);
+				}
+			} else {
+				try {
+					return require$1("./parser.win32-x64-msvc.node");
+				} catch (e) {
+					loadErrors.push(e);
+				}
+				try {
+					const binding = require$1("@oxc-parser/binding-win32-x64-msvc");
+					const bindingPackageVersion = require$1("@oxc-parser/binding-win32-x64-msvc/package.json").version;
+					if (bindingPackageVersion !== "0.140.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 0.140.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+					return binding;
+				} catch (e) {
+					loadErrors.push(e);
+				}
+			}
+		} else if (process.arch === "ia32") {
+			try {
+				return require$1("./parser.win32-ia32-msvc.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = require$1("@oxc-parser/binding-win32-ia32-msvc");
+				const bindingPackageVersion = require$1("@oxc-parser/binding-win32-ia32-msvc/package.json").version;
+				if (bindingPackageVersion !== "0.140.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 0.140.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else if (process.arch === "arm64") {
+			try {
+				return require$1("./parser.win32-arm64-msvc.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = require$1("@oxc-parser/binding-win32-arm64-msvc");
+				const bindingPackageVersion = require$1("@oxc-parser/binding-win32-arm64-msvc/package.json").version;
+				if (bindingPackageVersion !== "0.140.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 0.140.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else loadErrors.push(/* @__PURE__ */ new Error(`Unsupported architecture on Windows: ${process.arch}`));
+	} else if (process.platform === "darwin") {
+		try {
+			return require$1("./parser.darwin-universal.node");
+		} catch (e) {
+			loadErrors.push(e);
+		}
+		try {
+			const binding = require$1("@oxc-parser/binding-darwin-universal");
+			const bindingPackageVersion = require$1("@oxc-parser/binding-darwin-universal/package.json").version;
+			if (bindingPackageVersion !== "0.140.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 0.140.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+			return binding;
+		} catch (e) {
+			loadErrors.push(e);
+		}
+		if (process.arch === "x64") {
+			try {
+				return require$1("./parser.darwin-x64.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = require$1("@oxc-parser/binding-darwin-x64");
+				const bindingPackageVersion = require$1("@oxc-parser/binding-darwin-x64/package.json").version;
+				if (bindingPackageVersion !== "0.140.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 0.140.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else if (process.arch === "arm64") {
+			try {
+				return require$1("./parser.darwin-arm64.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = require$1("@oxc-parser/binding-darwin-arm64");
+				const bindingPackageVersion = require$1("@oxc-parser/binding-darwin-arm64/package.json").version;
+				if (bindingPackageVersion !== "0.140.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 0.140.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else loadErrors.push(/* @__PURE__ */ new Error(`Unsupported architecture on macOS: ${process.arch}`));
+	} else if (process.platform === "freebsd") {
+		if (process.arch === "x64") {
+			try {
+				return require$1("./parser.freebsd-x64.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = require$1("@oxc-parser/binding-freebsd-x64");
+				const bindingPackageVersion = require$1("@oxc-parser/binding-freebsd-x64/package.json").version;
+				if (bindingPackageVersion !== "0.140.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 0.140.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else if (process.arch === "arm64") {
+			try {
+				return require$1("./parser.freebsd-arm64.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = require$1("@oxc-parser/binding-freebsd-arm64");
+				const bindingPackageVersion = require$1("@oxc-parser/binding-freebsd-arm64/package.json").version;
+				if (bindingPackageVersion !== "0.140.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 0.140.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else loadErrors.push(/* @__PURE__ */ new Error(`Unsupported architecture on FreeBSD: ${process.arch}`));
+	} else if (process.platform === "linux") {
+		if (process.arch === "x64") {
+			if (isMusl()) {
+				try {
+					return require$1("./parser.linux-x64-musl.node");
+				} catch (e) {
+					loadErrors.push(e);
+				}
+				try {
+					const binding = require$1("@oxc-parser/binding-linux-x64-musl");
+					const bindingPackageVersion = require$1("@oxc-parser/binding-linux-x64-musl/package.json").version;
+					if (bindingPackageVersion !== "0.140.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 0.140.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+					return binding;
+				} catch (e) {
+					loadErrors.push(e);
+				}
+			} else {
+				try {
+					return require$1("./parser.linux-x64-gnu.node");
+				} catch (e) {
+					loadErrors.push(e);
+				}
+				try {
+					const binding = require$1("@oxc-parser/binding-linux-x64-gnu");
+					const bindingPackageVersion = require$1("@oxc-parser/binding-linux-x64-gnu/package.json").version;
+					if (bindingPackageVersion !== "0.140.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 0.140.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+					return binding;
+				} catch (e) {
+					loadErrors.push(e);
+				}
+			}
+		} else if (process.arch === "arm64") {
+			if (isMusl()) {
+				try {
+					return require$1("./parser.linux-arm64-musl.node");
+				} catch (e) {
+					loadErrors.push(e);
+				}
+				try {
+					const binding = require$1("@oxc-parser/binding-linux-arm64-musl");
+					const bindingPackageVersion = require$1("@oxc-parser/binding-linux-arm64-musl/package.json").version;
+					if (bindingPackageVersion !== "0.140.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 0.140.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+					return binding;
+				} catch (e) {
+					loadErrors.push(e);
+				}
+			} else {
+				try {
+					return require$1("./parser.linux-arm64-gnu.node");
+				} catch (e) {
+					loadErrors.push(e);
+				}
+				try {
+					const binding = require$1("@oxc-parser/binding-linux-arm64-gnu");
+					const bindingPackageVersion = require$1("@oxc-parser/binding-linux-arm64-gnu/package.json").version;
+					if (bindingPackageVersion !== "0.140.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 0.140.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+					return binding;
+				} catch (e) {
+					loadErrors.push(e);
+				}
+			}
+		} else if (process.arch === "arm") {
+			if (isMusl()) {
+				try {
+					return require$1("./parser.linux-arm-musleabihf.node");
+				} catch (e) {
+					loadErrors.push(e);
+				}
+				try {
+					const binding = require$1("@oxc-parser/binding-linux-arm-musleabihf");
+					const bindingPackageVersion = require$1("@oxc-parser/binding-linux-arm-musleabihf/package.json").version;
+					if (bindingPackageVersion !== "0.140.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 0.140.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+					return binding;
+				} catch (e) {
+					loadErrors.push(e);
+				}
+			} else {
+				try {
+					return require$1("./parser.linux-arm-gnueabihf.node");
+				} catch (e) {
+					loadErrors.push(e);
+				}
+				try {
+					const binding = require$1("@oxc-parser/binding-linux-arm-gnueabihf");
+					const bindingPackageVersion = require$1("@oxc-parser/binding-linux-arm-gnueabihf/package.json").version;
+					if (bindingPackageVersion !== "0.140.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 0.140.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+					return binding;
+				} catch (e) {
+					loadErrors.push(e);
+				}
+			}
+		} else if (process.arch === "loong64") {
+			if (isMusl()) {
+				try {
+					return require$1("./parser.linux-loong64-musl.node");
+				} catch (e) {
+					loadErrors.push(e);
+				}
+				try {
+					const binding = require$1("@oxc-parser/binding-linux-loong64-musl");
+					const bindingPackageVersion = require$1("@oxc-parser/binding-linux-loong64-musl/package.json").version;
+					if (bindingPackageVersion !== "0.140.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 0.140.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+					return binding;
+				} catch (e) {
+					loadErrors.push(e);
+				}
+			} else {
+				try {
+					return require$1("./parser.linux-loong64-gnu.node");
+				} catch (e) {
+					loadErrors.push(e);
+				}
+				try {
+					const binding = require$1("@oxc-parser/binding-linux-loong64-gnu");
+					const bindingPackageVersion = require$1("@oxc-parser/binding-linux-loong64-gnu/package.json").version;
+					if (bindingPackageVersion !== "0.140.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 0.140.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+					return binding;
+				} catch (e) {
+					loadErrors.push(e);
+				}
+			}
+		} else if (process.arch === "riscv64") {
+			if (isMusl()) {
+				try {
+					return require$1("./parser.linux-riscv64-musl.node");
+				} catch (e) {
+					loadErrors.push(e);
+				}
+				try {
+					const binding = require$1("@oxc-parser/binding-linux-riscv64-musl");
+					const bindingPackageVersion = require$1("@oxc-parser/binding-linux-riscv64-musl/package.json").version;
+					if (bindingPackageVersion !== "0.140.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 0.140.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+					return binding;
+				} catch (e) {
+					loadErrors.push(e);
+				}
+			} else {
+				try {
+					return require$1("./parser.linux-riscv64-gnu.node");
+				} catch (e) {
+					loadErrors.push(e);
+				}
+				try {
+					const binding = require$1("@oxc-parser/binding-linux-riscv64-gnu");
+					const bindingPackageVersion = require$1("@oxc-parser/binding-linux-riscv64-gnu/package.json").version;
+					if (bindingPackageVersion !== "0.140.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 0.140.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+					return binding;
+				} catch (e) {
+					loadErrors.push(e);
+				}
+			}
+		} else if (process.arch === "ppc64") {
+			try {
+				return require$1("./parser.linux-ppc64-gnu.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = require$1("@oxc-parser/binding-linux-ppc64-gnu");
+				const bindingPackageVersion = require$1("@oxc-parser/binding-linux-ppc64-gnu/package.json").version;
+				if (bindingPackageVersion !== "0.140.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 0.140.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else if (process.arch === "s390x") {
+			try {
+				return require$1("./parser.linux-s390x-gnu.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = require$1("@oxc-parser/binding-linux-s390x-gnu");
+				const bindingPackageVersion = require$1("@oxc-parser/binding-linux-s390x-gnu/package.json").version;
+				if (bindingPackageVersion !== "0.140.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 0.140.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else loadErrors.push(/* @__PURE__ */ new Error(`Unsupported architecture on Linux: ${process.arch}`));
+	} else if (process.platform === "openharmony") {
+		if (process.arch === "arm64") {
+			try {
+				return require$1("./parser.openharmony-arm64.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = require$1("@oxc-parser/binding-openharmony-arm64");
+				const bindingPackageVersion = require$1("@oxc-parser/binding-openharmony-arm64/package.json").version;
+				if (bindingPackageVersion !== "0.140.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 0.140.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else if (process.arch === "x64") {
+			try {
+				return require$1("./parser.openharmony-x64.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = require$1("@oxc-parser/binding-openharmony-x64");
+				const bindingPackageVersion = require$1("@oxc-parser/binding-openharmony-x64/package.json").version;
+				if (bindingPackageVersion !== "0.140.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 0.140.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else if (process.arch === "arm") {
+			try {
+				return require$1("./parser.openharmony-arm.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = require$1("@oxc-parser/binding-openharmony-arm");
+				const bindingPackageVersion = require$1("@oxc-parser/binding-openharmony-arm/package.json").version;
+				if (bindingPackageVersion !== "0.140.0" && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0") throw new Error(`Native binding package version mismatch, expected 0.140.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else loadErrors.push(/* @__PURE__ */ new Error(`Unsupported architecture on OpenHarmony: ${process.arch}`));
+	} else loadErrors.push(/* @__PURE__ */ new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`));
+}
+nativeBinding = requireNative();
+const forceWasi = process.env.NAPI_RS_FORCE_WASI === "true" || process.env.NAPI_RS_FORCE_WASI === "error";
+if (!nativeBinding || forceWasi) {
+	let wasiBinding = null;
+	let wasiBindingError = null;
+	try {
+		wasiBinding = require$1("./parser.wasi.cjs");
+		nativeBinding = wasiBinding;
+	} catch (err) {
+		if (forceWasi) wasiBindingError = err;
+	}
+	if (!nativeBinding || forceWasi) try {
+		wasiBinding = require$1("@oxc-parser/binding-wasm32-wasi");
+		nativeBinding = wasiBinding;
+	} catch (err) {
+		if (forceWasi) {
+			if (!wasiBindingError) wasiBindingError = err;
+			else wasiBindingError.cause = err;
+			loadErrors.push(err);
+		}
+	}
+	if (process.env.NAPI_RS_FORCE_WASI === "error" && !wasiBinding) {
+		const error = /* @__PURE__ */ new Error("WASI binding not found and NAPI_RS_FORCE_WASI is set to error");
+		error.cause = wasiBindingError;
+		throw error;
+	}
+}
+if (!nativeBinding && globalThis.process?.versions?.["webcontainer"]) try {
+	nativeBinding = require$1("./webcontainer-fallback.cjs");
+} catch (err) {
+	loadErrors.push(err);
+}
+if (!nativeBinding) {
+	if (loadErrors.length > 0) {
+		const error = /* @__PURE__ */ new Error("Cannot find native binding. npm has a bug related to optional dependencies (https://github.com/npm/cli/issues/4828). Please try `npm i` again after removing both package-lock.json and node_modules directory.");
+		error.cause = loadErrors.reduce((err, cur) => {
+			cur.cause = err;
+			return cur;
+		});
+		throw error;
+	}
+	throw new Error(`Failed to load native binding`);
+}
+const { Severity, ParseResult, ExportExportNameKind, ExportImportNameKind, ExportLocalNameKind, ImportNameKind, parse: parse$1, parseSync: parseSync$1, rawTransferSupported: rawTransferSupported$1 } = nativeBinding;
+const { getBufferOffset, parseRaw: parseRaw$1, parseRawSync } = nativeBinding;
+//#endregion
+//#region ../../node_modules/.pnpm/oxc-parser@0.140.0/node_modules/oxc-parser/src-js/wrap.js
+function wrap(result) {
+	let program, module, comments, errors;
+	return {
+		get program() {
+			if (!program) program = jsonParseAst(result.program);
+			return program;
+		},
+		get module() {
+			if (!module) module = result.module;
+			return module;
+		},
+		get comments() {
+			if (!comments) comments = result.comments;
+			return comments;
+		},
+		get errors() {
+			if (!errors) errors = result.errors;
+			return errors;
+		}
+	};
+}
+function jsonParseAst(programJson) {
+	const { node: program, fixes } = JSON.parse(programJson);
+	for (const fixPath of fixes) applyFix(program, fixPath);
+	return program;
+}
+function applyFix(program, fixPath) {
+	let node = program;
+	for (const key of fixPath) node = node[key];
+	if (node.bigint) node.value = BigInt(node.bigint);
+	else try {
+		node.value = RegExp(node.regex.pattern, node.regex.flags);
+	} catch {}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/oxc-parser@0.140.0/node_modules/oxc-parser/src-js/generated/visit/keys.js
+const { freeze } = Object;
+const $EMPTY = freeze([]);
+const DECORATORS__KEY__TYPE_ANNOTATION__VALUE = freeze([
+	"decorators",
+	"key",
+	"typeAnnotation",
+	"value"
+]);
+const LEFT__RIGHT = freeze(["left", "right"]);
+const ARGUMENT = freeze(["argument"]);
+const BODY = freeze(["body"]);
+const LABEL = freeze(["label"]);
+const CALLEE__TYPE_ARGUMENTS__ARGUMENTS = freeze([
+	"callee",
+	"typeArguments",
+	"arguments"
+]);
+const EXPRESSION = freeze(["expression"]);
+const DECORATORS__ID__TYPE_PARAMETERS__SUPER_CLASS__SUPER_TYPE_ARGUMENTS__IMPLEMENTS__BODY = freeze([
+	"decorators",
+	"id",
+	"typeParameters",
+	"superClass",
+	"superTypeArguments",
+	"implements",
+	"body"
+]);
+const TEST__CONSEQUENT__ALTERNATE = freeze([
+	"test",
+	"consequent",
+	"alternate"
+]);
+const LEFT__RIGHT__BODY = freeze([
+	"left",
+	"right",
+	"body"
+]);
+const ID__TYPE_PARAMETERS__PARAMS__RETURN_TYPE__BODY = freeze([
+	"id",
+	"typeParameters",
+	"params",
+	"returnType",
+	"body"
+]);
+const KEY__VALUE = freeze(["key", "value"]);
+const LOCAL = freeze(["local"]);
+const OBJECT__PROPERTY = freeze(["object", "property"]);
+const DECORATORS__KEY__TYPE_ANNOTATION = freeze([
+	"decorators",
+	"key",
+	"typeAnnotation"
+]);
+const EXPRESSION__TYPE_ANNOTATION = freeze(["expression", "typeAnnotation"]);
+const TYPE_PARAMETERS__PARAMS__RETURN_TYPE = freeze([
+	"typeParameters",
+	"params",
+	"returnType"
+]);
+const EXPRESSION__TYPE_ARGUMENTS = freeze(["expression", "typeArguments"]);
+const MEMBERS = freeze(["members"]);
+const ID__BODY = freeze(["id", "body"]);
+const TYPES = freeze(["types"]);
+const TYPE_ANNOTATION = freeze(["typeAnnotation"]);
+const PARAMS = freeze(["params"]);
+var keys_default = freeze({
+	DebuggerStatement: $EMPTY,
+	EmptyStatement: $EMPTY,
+	Literal: $EMPTY,
+	PrivateIdentifier: $EMPTY,
+	Super: $EMPTY,
+	TemplateElement: $EMPTY,
+	ThisExpression: $EMPTY,
+	JSXClosingFragment: $EMPTY,
+	JSXEmptyExpression: $EMPTY,
+	JSXIdentifier: $EMPTY,
+	JSXOpeningFragment: $EMPTY,
+	JSXText: $EMPTY,
+	TSAnyKeyword: $EMPTY,
+	TSBigIntKeyword: $EMPTY,
+	TSBooleanKeyword: $EMPTY,
+	TSIntrinsicKeyword: $EMPTY,
+	TSJSDocUnknownType: $EMPTY,
+	TSNeverKeyword: $EMPTY,
+	TSNullKeyword: $EMPTY,
+	TSNumberKeyword: $EMPTY,
+	TSObjectKeyword: $EMPTY,
+	TSStringKeyword: $EMPTY,
+	TSSymbolKeyword: $EMPTY,
+	TSThisType: $EMPTY,
+	TSUndefinedKeyword: $EMPTY,
+	TSUnknownKeyword: $EMPTY,
+	TSVoidKeyword: $EMPTY,
+	AccessorProperty: DECORATORS__KEY__TYPE_ANNOTATION__VALUE,
+	ArrayExpression: freeze(["elements"]),
+	ArrayPattern: freeze([
+		"decorators",
+		"elements",
+		"typeAnnotation"
+	]),
+	ArrowFunctionExpression: freeze([
+		"typeParameters",
+		"params",
+		"returnType",
+		"body"
+	]),
+	AssignmentExpression: LEFT__RIGHT,
+	AssignmentPattern: freeze([
+		"decorators",
+		"left",
+		"right",
+		"typeAnnotation"
+	]),
+	AwaitExpression: ARGUMENT,
+	BinaryExpression: LEFT__RIGHT,
+	BlockStatement: BODY,
+	BreakStatement: LABEL,
+	CallExpression: CALLEE__TYPE_ARGUMENTS__ARGUMENTS,
+	CatchClause: freeze(["param", "body"]),
+	ChainExpression: EXPRESSION,
+	ClassBody: BODY,
+	ClassDeclaration: DECORATORS__ID__TYPE_PARAMETERS__SUPER_CLASS__SUPER_TYPE_ARGUMENTS__IMPLEMENTS__BODY,
+	ClassExpression: DECORATORS__ID__TYPE_PARAMETERS__SUPER_CLASS__SUPER_TYPE_ARGUMENTS__IMPLEMENTS__BODY,
+	ConditionalExpression: TEST__CONSEQUENT__ALTERNATE,
+	ContinueStatement: LABEL,
+	Decorator: EXPRESSION,
+	DoWhileStatement: freeze(["body", "test"]),
+	ExportAllDeclaration: freeze([
+		"exported",
+		"source",
+		"attributes"
+	]),
+	ExportDefaultDeclaration: freeze(["declaration"]),
+	ExportNamedDeclaration: freeze([
+		"declaration",
+		"specifiers",
+		"source",
+		"attributes"
+	]),
+	ExportSpecifier: freeze(["local", "exported"]),
+	ExpressionStatement: EXPRESSION,
+	ForInStatement: LEFT__RIGHT__BODY,
+	ForOfStatement: LEFT__RIGHT__BODY,
+	ForStatement: freeze([
+		"init",
+		"test",
+		"update",
+		"body"
+	]),
+	FunctionDeclaration: ID__TYPE_PARAMETERS__PARAMS__RETURN_TYPE__BODY,
+	FunctionExpression: ID__TYPE_PARAMETERS__PARAMS__RETURN_TYPE__BODY,
+	Identifier: freeze(["decorators", "typeAnnotation"]),
+	IfStatement: TEST__CONSEQUENT__ALTERNATE,
+	ImportAttribute: KEY__VALUE,
+	ImportDeclaration: freeze([
+		"specifiers",
+		"source",
+		"attributes"
+	]),
+	ImportDefaultSpecifier: LOCAL,
+	ImportExpression: freeze(["source", "options"]),
+	ImportNamespaceSpecifier: LOCAL,
+	ImportSpecifier: freeze(["imported", "local"]),
+	LabeledStatement: freeze(["label", "body"]),
+	LogicalExpression: LEFT__RIGHT,
+	MemberExpression: OBJECT__PROPERTY,
+	MetaProperty: freeze(["meta", "property"]),
+	MethodDefinition: freeze([
+		"decorators",
+		"key",
+		"value"
+	]),
+	NewExpression: CALLEE__TYPE_ARGUMENTS__ARGUMENTS,
+	ObjectExpression: freeze(["properties"]),
+	ObjectPattern: freeze([
+		"decorators",
+		"properties",
+		"typeAnnotation"
+	]),
+	ParenthesizedExpression: EXPRESSION,
+	Program: BODY,
+	Property: KEY__VALUE,
+	PropertyDefinition: DECORATORS__KEY__TYPE_ANNOTATION__VALUE,
+	RestElement: freeze([
+		"decorators",
+		"argument",
+		"typeAnnotation"
+	]),
+	ReturnStatement: ARGUMENT,
+	SequenceExpression: freeze(["expressions"]),
+	SpreadElement: ARGUMENT,
+	StaticBlock: BODY,
+	SwitchCase: freeze(["test", "consequent"]),
+	SwitchStatement: freeze(["discriminant", "cases"]),
+	TaggedTemplateExpression: freeze([
+		"tag",
+		"typeArguments",
+		"quasi"
+	]),
+	TemplateLiteral: freeze(["quasis", "expressions"]),
+	ThrowStatement: ARGUMENT,
+	TryStatement: freeze([
+		"block",
+		"handler",
+		"finalizer"
+	]),
+	UnaryExpression: ARGUMENT,
+	UpdateExpression: ARGUMENT,
+	V8IntrinsicExpression: freeze(["name", "arguments"]),
+	VariableDeclaration: freeze(["declarations"]),
+	VariableDeclarator: freeze(["id", "init"]),
+	WhileStatement: freeze(["test", "body"]),
+	WithStatement: freeze(["object", "body"]),
+	YieldExpression: ARGUMENT,
+	JSXAttribute: freeze(["name", "value"]),
+	JSXClosingElement: freeze(["name"]),
+	JSXElement: freeze([
+		"openingElement",
+		"children",
+		"closingElement"
+	]),
+	JSXExpressionContainer: EXPRESSION,
+	JSXFragment: freeze([
+		"openingFragment",
+		"children",
+		"closingFragment"
+	]),
+	JSXMemberExpression: OBJECT__PROPERTY,
+	JSXNamespacedName: freeze(["namespace", "name"]),
+	JSXOpeningElement: freeze([
+		"name",
+		"typeArguments",
+		"attributes"
+	]),
+	JSXSpreadAttribute: ARGUMENT,
+	JSXSpreadChild: EXPRESSION,
+	TSAbstractAccessorProperty: DECORATORS__KEY__TYPE_ANNOTATION,
+	TSAbstractMethodDefinition: KEY__VALUE,
+	TSAbstractPropertyDefinition: DECORATORS__KEY__TYPE_ANNOTATION,
+	TSArrayType: freeze(["elementType"]),
+	TSAsExpression: EXPRESSION__TYPE_ANNOTATION,
+	TSCallSignatureDeclaration: TYPE_PARAMETERS__PARAMS__RETURN_TYPE,
+	TSClassImplements: EXPRESSION__TYPE_ARGUMENTS,
+	TSConditionalType: freeze([
+		"checkType",
+		"extendsType",
+		"trueType",
+		"falseType"
+	]),
+	TSConstructSignatureDeclaration: TYPE_PARAMETERS__PARAMS__RETURN_TYPE,
+	TSConstructorType: TYPE_PARAMETERS__PARAMS__RETURN_TYPE,
+	TSDeclareFunction: ID__TYPE_PARAMETERS__PARAMS__RETURN_TYPE__BODY,
+	TSEmptyBodyFunctionExpression: freeze([
+		"id",
+		"typeParameters",
+		"params",
+		"returnType"
+	]),
+	TSEnumBody: MEMBERS,
+	TSEnumDeclaration: ID__BODY,
+	TSEnumMember: freeze(["id", "initializer"]),
+	TSExportAssignment: EXPRESSION,
+	TSExternalModuleReference: EXPRESSION,
+	TSFunctionType: TYPE_PARAMETERS__PARAMS__RETURN_TYPE,
+	TSImportEqualsDeclaration: freeze(["id", "moduleReference"]),
+	TSImportType: freeze([
+		"source",
+		"options",
+		"qualifier",
+		"typeArguments"
+	]),
+	TSIndexSignature: freeze(["parameters", "typeAnnotation"]),
+	TSIndexedAccessType: freeze(["objectType", "indexType"]),
+	TSInferType: freeze(["typeParameter"]),
+	TSInstantiationExpression: EXPRESSION__TYPE_ARGUMENTS,
+	TSInterfaceBody: BODY,
+	TSInterfaceDeclaration: freeze([
+		"id",
+		"typeParameters",
+		"extends",
+		"body"
+	]),
+	TSInterfaceHeritage: EXPRESSION__TYPE_ARGUMENTS,
+	TSIntersectionType: TYPES,
+	TSJSDocNonNullableType: TYPE_ANNOTATION,
+	TSJSDocNullableType: TYPE_ANNOTATION,
+	TSLiteralType: freeze(["literal"]),
+	TSMappedType: freeze([
+		"key",
+		"constraint",
+		"nameType",
+		"typeAnnotation"
+	]),
+	TSMethodSignature: freeze([
+		"key",
+		"typeParameters",
+		"params",
+		"returnType"
+	]),
+	TSModuleBlock: BODY,
+	TSModuleDeclaration: ID__BODY,
+	TSNamedTupleMember: freeze(["label", "elementType"]),
+	TSNamespaceExportDeclaration: freeze(["id"]),
+	TSNonNullExpression: EXPRESSION,
+	TSOptionalType: TYPE_ANNOTATION,
+	TSParameterProperty: freeze(["decorators", "parameter"]),
+	TSParenthesizedType: TYPE_ANNOTATION,
+	TSPropertySignature: freeze(["key", "typeAnnotation"]),
+	TSQualifiedName: LEFT__RIGHT,
+	TSRestType: TYPE_ANNOTATION,
+	TSSatisfiesExpression: EXPRESSION__TYPE_ANNOTATION,
+	TSTemplateLiteralType: freeze(["quasis", "types"]),
+	TSTupleType: freeze(["elementTypes"]),
+	TSTypeAliasDeclaration: freeze([
+		"id",
+		"typeParameters",
+		"typeAnnotation"
+	]),
+	TSTypeAnnotation: TYPE_ANNOTATION,
+	TSTypeAssertion: freeze(["typeAnnotation", "expression"]),
+	TSTypeLiteral: MEMBERS,
+	TSTypeOperator: TYPE_ANNOTATION,
+	TSTypeParameter: freeze([
+		"name",
+		"constraint",
+		"default"
+	]),
+	TSTypeParameterDeclaration: PARAMS,
+	TSTypeParameterInstantiation: PARAMS,
+	TSTypePredicate: freeze(["parameterName", "typeAnnotation"]),
+	TSTypeQuery: freeze(["exprName", "typeArguments"]),
+	TSTypeReference: freeze(["typeName", "typeArguments"]),
+	TSUnionType: TYPES
+});
+//#endregion
+//#region ../../node_modules/.pnpm/oxc-parser@0.140.0/node_modules/oxc-parser/src-js/visit/index.js
+let walkProgram = null;
+let addVisitorToCompiled;
+let createCompiledVisitor;
+let finalizeCompiledVisitor;
+/**
+* Visitor class for traversing AST.
+*/
+var Visitor = class {
+	#compiledVisitor = null;
+	constructor(visitor) {
+		if (walkProgram === null) {
+			const require = createRequire(import.meta.url);
+			({walkProgram} = require("../generated/visit/walk.js"));
+			({addVisitorToCompiled, createCompiledVisitor, finalizeCompiledVisitor} = require("./visitor.js"));
+		}
+		const compiledVisitor = createCompiledVisitor();
+		addVisitorToCompiled(visitor);
+		if (finalizeCompiledVisitor()) this.#compiledVisitor = compiledVisitor;
+	}
+	/**
+	* Visit AST.
+	* @param program - The AST to visit.
+	* @returns {undefined}
+	*/
+	visit(program) {
+		const compiledVisitor = this.#compiledVisitor;
+		if (compiledVisitor !== null) walkProgram(program, compiledVisitor);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/oxc-parser@0.140.0/node_modules/oxc-parser/src-js/raw-transfer/supported.js
+let rawTransferIsSupported = null;
+/**
+* Returns `true` if `experimentalRawTransfer` is option is supported.
+*
+* Raw transfer is only supported on 64-bit little-endian systems,
+* and NodeJS >= v22.0.0 or Deno >= v2.0.0.
+*
+* Versions of NodeJS prior to v22.0.0 do not support creating an `ArrayBuffer` larger than 4 GiB.
+* Bun (as at v1.2.4) also does not support creating an `ArrayBuffer` larger than 4 GiB.
+* Support on Deno v1 is unknown and it's EOL, so treating Deno before v2.0.0 as unsupported.
+*
+* No easy way to determining pointer width (64 bit or 32 bit) in JS,
+* so call a function on Rust side to find out.
+*
+* @returns {boolean} - `true` if raw transfer is supported on this platform
+*/
+function rawTransferSupported() {
+	if (rawTransferIsSupported === null) rawTransferIsSupported = rawTransferRuntimeSupported() && rawTransferSupported$1();
+	return rawTransferIsSupported;
+}
+function rawTransferRuntimeSupported() {
+	let global;
+	try {
+		global = globalThis;
+	} catch {
+		return false;
+	}
+	if (!!global.Bun || !!global.process?.versions?.bun) return false;
+	if (!!global.Deno) {
+		const match = Deno.version?.deno?.match(/^(\d+)\./);
+		return !!match && match[1] * 1 >= 2;
+	}
+	if (!(global.process?.release?.name === "node")) return false;
+	const match = process.version?.match(/^v(\d+)\./);
+	return !!match && match[1] * 1 >= 22;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/oxc-parser@0.140.0/node_modules/oxc-parser/src-js/index.js
+const require = createRequire(import.meta.url);
+let parseSyncRaw = null;
+let parseRaw;
+let parseSyncLazy = null;
+let parseLazy;
+let LazyVisitor;
+/**
+* Lazy-load code related to raw transfer.
+* @returns {undefined}
+*/
+function loadRawTransfer() {
+	if (parseSyncRaw === null) ({parseSyncRaw, parse: parseRaw} = require("./raw-transfer/eager.js"));
+}
+/**
+* Lazy-load code related to raw transfer lazy deserialization.
+* @returns {undefined}
+*/
+function loadRawTransferLazy() {
+	if (parseSyncLazy === null) ({parseSyncLazy, parse: parseLazy, Visitor: LazyVisitor} = require("./raw-transfer/lazy.js"));
+}
+/**
+* Parse JS/TS source synchronously on current thread.
+*
+* @param {string} filename - Filename
+* @param {string} sourceText - Source text of file
+* @param {Object|undefined} options - Parsing options
+* @returns {Object} - Object with property getters for `program`, `module`, `comments`, and `errors`
+* @throws {Error} - If `experimentalRawTransfer` or `experimentalLazy` option is enabled,
+*   and raw transfer is not supported on this platform
+*/
+function parseSync(filename, sourceText, options) {
+	if (options?.experimentalRawTransfer) {
+		loadRawTransfer();
+		return parseSyncRaw(filename, sourceText, options);
+	}
+	if (options?.experimentalLazy) {
+		loadRawTransferLazy();
+		return parseSyncLazy(filename, sourceText, options);
+	}
+	return wrap(parseSync$1(filename, sourceText, options));
+}
+/**
+* Parse JS/TS source asynchronously on a separate thread.
+*
+* Note that not all of the workload can happen on a separate thread.
+* Parsing on Rust side does happen in a separate thread, but deserialization of the AST to JS objects
+* has to happen on current thread. This synchronous deserialization work typically outweighs
+* the asynchronous parsing by a factor of between 3 and 20.
+*
+* i.e. the majority of the workload cannot be parallelized by using this method.
+*
+* Generally `parseSync` is preferable to use as it does not have the overhead of spawning a thread.
+* If you need to parallelize parsing multiple files, it is recommended to use worker threads.
+*
+* @param {string} filename - Filename
+* @param {string} sourceText - Source text of file
+* @param {Object|undefined} options - Parsing options
+* @returns {Object} - Object with property getters for `program`, `module`, `comments`, and `errors`
+* @throws {Error} - If `experimentalRawTransfer` or `experimentalLazy` option is enabled,
+*   and raw transfer is not supported on this platform
+*/
+async function parse(filename, sourceText, options) {
+	if (options?.experimentalRawTransfer) {
+		loadRawTransfer();
+		return await parseRaw(filename, sourceText, options);
+	}
+	if (options?.experimentalLazy) {
+		loadRawTransferLazy();
+		return await parseLazy(filename, sourceText, options);
+	}
+	return wrap(await parse$1(filename, sourceText, options));
+}
+/**
+* Get `Visitor` class to construct visitors with.
+* @returns {function} - `Visitor` class
+*/
+function experimentalGetLazyVisitor() {
+	loadRawTransferLazy();
+	return LazyVisitor;
+}
+//#endregion
+export { ExportExportNameKind, ExportImportNameKind, ExportLocalNameKind, ImportNameKind, ParseResult, Severity, Visitor, experimentalGetLazyVisitor, parse, parseSync, rawTransferSupported, keys_default as visitorKeys };