@quiteer/vite 0.0.7 → 0.1.0

package/dist/bin/dist-Bvgk2hb8.mjs

@@ -1,187 +0,0 @@
-//#region ../../node_modules/.pnpm/birpc@2.7.0/node_modules/birpc/dist/index.mjs
-const TYPE_REQUEST = "q";
-const TYPE_RESPONSE = "s";
-const DEFAULT_TIMEOUT = 6e4;
-function defaultSerialize(i) {
-	return i;
-}
-const defaultDeserialize = defaultSerialize;
-const { clearTimeout, setTimeout } = globalThis;
-const random = Math.random.bind(Math);
-function createBirpc(functions, options) {
-	const { post, on, off = () => {}, eventNames = [], serialize = defaultSerialize, deserialize = defaultDeserialize, resolver, bind = "rpc", timeout = DEFAULT_TIMEOUT } = options;
-	const rpcPromiseMap = /* @__PURE__ */ new Map();
-	let _promiseInit;
-	let closed = false;
-	const rpc = new Proxy({}, { get(_, method) {
-		if (method === "$functions") return functions;
-		if (method === "$close") return close;
-		if (method === "$rejectPendingCalls") return rejectPendingCalls;
-		if (method === "$closed") return closed;
-		if (method === "then" && !eventNames.includes("then") && !("then" in functions)) return void 0;
-		const sendEvent = async (...args) => {
-			await post(serialize({
-				m: method,
-				a: args,
-				t: TYPE_REQUEST
-			}));
-		};
-		if (eventNames.includes(method)) {
-			sendEvent.asEvent = sendEvent;
-			return sendEvent;
-		}
-		const sendCall = async (...args) => {
-			if (closed) throw new Error(`[birpc] rpc is closed, cannot call "${method}"`);
-			if (_promiseInit) try {
-				await _promiseInit;
-			} finally {
-				_promiseInit = void 0;
-			}
-			let { promise, resolve, reject } = createPromiseWithResolvers();
-			const id = nanoid();
-			let timeoutId;
-			const _req = {
-				m: method,
-				a: args,
-				i: id,
-				t: TYPE_REQUEST
-			};
-			async function handler(req = _req) {
-				if (timeout >= 0) {
-					timeoutId = setTimeout(() => {
-						try {
-							if (options.onTimeoutError?.(method, args) !== true) throw new Error(`[birpc] timeout on calling "${method}"`);
-						} catch (e) {
-							reject(e);
-						}
-						rpcPromiseMap.delete(id);
-					}, timeout);
-					if (typeof timeoutId === "object") timeoutId = timeoutId.unref?.();
-				}
-				rpcPromiseMap.set(id, {
-					resolve,
-					reject,
-					timeoutId,
-					method
-				});
-				await post(serialize(req));
-				return promise;
-			}
-			try {
-				if (options.onRequest) await options.onRequest(_req, handler, resolve);
-				else await handler();
-			} catch (e) {
-				clearTimeout(timeoutId);
-				rpcPromiseMap.delete(id);
-				if (options.onGeneralError?.(e) !== true) throw e;
-				return;
-			}
-			return promise;
-		};
-		sendCall.asEvent = sendEvent;
-		return sendCall;
-	} });
-	function close(customError) {
-		closed = true;
-		rpcPromiseMap.forEach(({ reject, method }) => {
-			const error = /* @__PURE__ */ new Error(`[birpc] rpc is closed, cannot call "${method}"`);
-			if (customError) {
-				customError.cause ??= error;
-				return reject(customError);
-			}
-			reject(error);
-		});
-		rpcPromiseMap.clear();
-		off(onMessage);
-	}
-	function rejectPendingCalls(handler) {
-		const handlerResults = Array.from(rpcPromiseMap.values()).map(({ method, reject }) => {
-			if (!handler) return reject(/* @__PURE__ */ new Error(`[birpc]: rejected pending call "${method}".`));
-			return handler({
-				method,
-				reject
-			});
-		});
-		rpcPromiseMap.clear();
-		return handlerResults;
-	}
-	async function onMessage(data, ...extra) {
-		let msg;
-		try {
-			msg = deserialize(data);
-		} catch (e) {
-			if (options.onGeneralError?.(e) !== true) throw e;
-			return;
-		}
-		if (msg.t === TYPE_REQUEST) {
-			const { m: method, a: args } = msg;
-			let result, error;
-			const fn = await (resolver ? resolver(method, functions[method]) : functions[method]);
-			if (!fn) error = /* @__PURE__ */ new Error(`[birpc] function "${method}" not found`);
-			else try {
-				result = await fn.apply(bind === "rpc" ? rpc : functions, args);
-			} catch (e) {
-				error = e;
-			}
-			if (msg.i) {
-				if (error && options.onError) options.onError(error, method, args);
-				if (error && options.onFunctionError) {
-					if (options.onFunctionError(error, method, args) === true) return;
-				}
-				if (!error) try {
-					await post(serialize({
-						t: TYPE_RESPONSE,
-						i: msg.i,
-						r: result
-					}), ...extra);
-					return;
-				} catch (e) {
-					error = e;
-					if (options.onGeneralError?.(e, method, args) !== true) throw e;
-				}
-				try {
-					await post(serialize({
-						t: TYPE_RESPONSE,
-						i: msg.i,
-						e: error
-					}), ...extra);
-				} catch (e) {
-					if (options.onGeneralError?.(e, method, args) !== true) throw e;
-				}
-			}
-		} else {
-			const { i: ack, r: result, e: error } = msg;
-			const promise = rpcPromiseMap.get(ack);
-			if (promise) {
-				clearTimeout(promise.timeoutId);
-				if (error) promise.reject(error);
-				else promise.resolve(result);
-			}
-			rpcPromiseMap.delete(ack);
-		}
-	}
-	_promiseInit = on(onMessage);
-	return rpc;
-}
-function createPromiseWithResolvers() {
-	let resolve;
-	let reject;
-	return {
-		promise: new Promise((res, rej) => {
-			resolve = res;
-			reject = rej;
-		}),
-		resolve,
-		reject
-	};
-}
-const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
-function nanoid(size = 21) {
-	let id = "";
-	let i = size;
-	while (i--) id += urlAlphabet[random() * 64 | 0];
-	return id;
-}
-
-//#endregion
-export { DEFAULT_TIMEOUT, createBirpc };

package/dist/bin/dist-CjNY_432.mjs

@@ -1,473 +0,0 @@
-import { a as rolldown } from "./src-BwxUhqZU-Dr1MNcyS.mjs";
-import "./dist-BmyFpZwL.mjs";
-import { createRequire } from "node:module";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import process from "node:process";
-import path from "node:path";
-import { tmpdir } from "node:os";
-import fs, { existsSync } from "node:fs";
-import { spawn } from "node:child_process";
-import { Buffer } from "node:buffer";
-import crypto from "node:crypto";
-
-//#region ../../node_modules/.pnpm/unrun@0.2.6_synckit@0.11.11/node_modules/unrun/dist/src-BW3bFBxp.mjs
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-/**
-* Applies preset-specific handling to the loaded module.
-*/
-function preset(options, module) {
-	if (options.preset === "bundle-require") return module;
-	if (options.preset === "jiti") {
-		const ext = path.extname(options.path);
-		if (module && typeof module === "object" && module[Symbol.toStringTag] === "Module" && Object.keys(module).length === 0) return ext === ".mjs" ? module : {};
-	}
-	if (module && typeof module === "object" && "default" in module) return module.default;
-	return module;
-}
-/**
-* Normalize a path-like input to a string path.
-* @param pathLike The path-like input (string or URL).
-* @returns The normalized string path.
-*/
-function normalizePath(pathLike) {
-	if (!pathLike) return "index.ts";
-	if (pathLike instanceof URL) {
-		if (pathLike.protocol === "file:") return fileURLToPath(pathLike);
-		return pathLike.href;
-	}
-	if (typeof pathLike === "string") {
-		if (!pathLike.startsWith("file:")) return pathLike;
-		try {
-			return fileURLToPath(pathLike);
-		} catch {
-			try {
-				return fileURLToPath(new URL(pathLike));
-			} catch {
-				return pathLike;
-			}
-		}
-	}
-	return String(pathLike);
-}
-function resolveOptions(options = {}) {
-	const resolvedOptions = {
-		path: path.resolve(process.cwd(), normalizePath(options.path)),
-		debug: options.debug || false,
-		preset: options.preset || "none",
-		inputOptions: options.inputOptions,
-		outputOptions: options.outputOptions
-	};
-	if (!fs.existsSync(resolvedOptions.path)) throw new Error(`[unrun] File not found: ${resolvedOptions.path}`);
-	if (!new Set([
-		"none",
-		"jiti",
-		"bundle-require"
-	]).has(resolvedOptions.preset)) throw new Error(`[unrun] Invalid preset "${resolvedOptions.preset}" (expected: none | jiti | bundle-require)`);
-	return resolvedOptions;
-}
-/**
-* Attach a util.inspect customizer to namespace-like module objects produced by rolldown helpers
-* so console.log prints concrete values instead of [Getter], while preserving live bindings.
-*
-* Cleaner strategy: inject a tiny helper at the top of the chunk and minimally augment
-* rolldown helpers (__export and __copyProps) right inside their definitions, before use.
-*/
-function createConsoleOutputCustomizer() {
-	return {
-		name: "unrun-console-output-customizer",
-		generateBundle: { handler(_, bundle$1) {
-			for (const chunk of Object.values(bundle$1)) {
-				if (chunk.type !== "chunk") continue;
-				if (!/__unrun__setInspect\b/.test(chunk.code)) {
-					const helper = [
-						"(function(){",
-						"  function __unrun__fmt(names, getter, np){",
-						"    var onlyDefault = names.length === 1 && names[0] === \"default\";",
-						"    var o = np ? Object.create(null) : {};",
-						"    for (var i = 0; i < names.length; i++) {",
-						"      var n = names[i];",
-						"      try { o[n] = getter(n) } catch {}",
-						"    }",
-						"    if (onlyDefault) {",
-						"      try {",
-						"        var s = JSON.stringify(o.default);",
-						"        if (s !== undefined) {",
-						"          s = s.replace(/\"([^\"]+)\":/g, \"$1: \").replace(/,/g, \", \").replace(/{/g, \"{ \").replace(/}/g, \" }\");",
-						"          return \"[Module: null prototype] { default: \" + s + \" }\";",
-						"        }",
-						"      } catch {}",
-						"      return \"[Module: null prototype] { default: \" + String(o.default) + \" }\";",
-						"    }",
-						"    return o;",
-						"  }",
-						"  function __unrun__setInspect(obj, names, getter, np){",
-						"    try {",
-						"      var __insp = Symbol.for('nodejs.util.inspect.custom')",
-						"      Object.defineProperty(obj, __insp, {",
-						"        value: function(){ return __unrun__fmt(names, getter, np) },",
-						"        enumerable: false, configurable: true",
-						"      })",
-						"    } catch {}",
-						"    return obj;",
-						"  }",
-						"  try { Object.defineProperty(globalThis, \"__unrun__setInspect\", { value: __unrun__setInspect, enumerable: false }) } catch {}",
-						"})();"
-					].join("\n");
-					if (chunk.code.startsWith("#!")) {
-						const nl = chunk.code.indexOf("\n");
-						if (nl !== -1) chunk.code = `${chunk.code.slice(0, nl + 1)}${helper}\n${chunk.code.slice(nl + 1)}`;
-						else chunk.code = `${helper}\n${chunk.code}`;
-					} else chunk.code = `${helper}\n${chunk.code}`;
-				}
-				chunk.code = chunk.code.replace(/var\s+__export\s*=\s*\(all\)\s*=>\s*\{([\s\S]*?)return\s+target;\s*\}/, (_m, body) => {
-					return `var __export = (all) => {\n${[
-						body,
-						"  try {",
-						"    var __names = Object.keys(all).filter(function(n){ return n !== \"__esModule\" })",
-						"    __unrun__setInspect(target, __names, function(n){ return all[n]() }, false)",
-						"  } catch {}",
-						"  return target;"
-					].join("\n")}\n}`;
-				});
-				chunk.code = chunk.code.replace(/var\s+__copyProps\s*=\s*\(to,\s*from,\s*except,\s*desc\)\s*=>\s*\{([\s\S]*?)return\s+to;\s*\};/, (_m, body) => {
-					return `var __copyProps = (to, from, except, desc) => {\n${[
-						body,
-						"  try {",
-						"    var __names = Object.keys(to).filter(function(n){ return n !== \"__esModule\" })",
-						"    __unrun__setInspect(to, __names, function(n){ return to[n] }, true)",
-						"  } catch {}",
-						"  return to;"
-					].join("\n")}\n};`;
-				});
-			}
-		} }
-	};
-}
-/**
-* Minimal JSON loader to mimic jiti/Node behavior expected by tests:
-* - Default export is the parsed JSON object
-* - Also add a self-reference `default` property on the object (so obj.default === obj)
-* - Provide named exports for top-level properties
-*/
-function createJsonLoader() {
-	return {
-		name: "unrun-json-loader",
-		resolveId: { handler(source, importer) {
-			if (!source.endsWith(".json")) return null;
-			const basedir = importer ? path.dirname(importer) : process.cwd();
-			const resolved = path.resolve(basedir, source);
-			let isRequire = false;
-			try {
-				if (importer) {
-					const src = fs.readFileSync(importer, "utf8");
-					const escaped = source.replaceAll(/[.*+?^${}()|[\]\\]/g, (m) => `\\${m}`);
-					const pattern = String.raw`\brequire\s*\(\s*['"]${escaped}['"]\s*\)`;
-					isRequire = new RegExp(pattern).test(src);
-				}
-			} catch {}
-			return { id: `${resolved}?unrun-json.${isRequire ? "cjs" : "mjs"}` };
-		} },
-		load: {
-			filter: { id: /\?unrun-json\.(?:mjs|cjs)$/ },
-			handler(id) {
-				try {
-					const realId = id.replace(/\?unrun-json\.(?:mjs|cjs)$/, "");
-					const src = fs.readFileSync(realId, "utf8");
-					const data = JSON.parse(src);
-					const jsonLiteral = JSON.stringify(data);
-					if (id.endsWith("?unrun-json.cjs")) return { code: `const __data = ${jsonLiteral}\ntry { Object.defineProperty(__data, 'default', { value: __data, enumerable: false, configurable: true }) } catch {}\nmodule.exports = __data\n` };
-					const named = Object.keys(data).filter((k) => /^[$A-Z_]\w*$/i.test(k)).map((k) => `export const ${k} = __data[${JSON.stringify(k)}]`).join("\n");
-					return { code: [
-						`const __data = ${jsonLiteral}`,
-						`try { Object.defineProperty(__data, 'default', { value: __data, enumerable: false, configurable: true }) } catch {}`,
-						named,
-						`export default __data`
-					].filter(Boolean).join("\n") };
-				} catch {
-					return null;
-				}
-			}
-		}
-	};
-}
-/**
-* Transforms code strings containing CommonJS wrappers to be async-friendly.
-*
-* Rolldown may wrap CommonJS modules in a `__commonJS` function that uses
-* arrow functions. If the wrapped code contains top-level `await`, this can lead
-* to syntax errors since the callback function won't be marked as `async`.
-* This function scans for such patterns and modifies the arrow functions to
-* be `async` if they contain `await` expressions.
-*/
-function createMakeCjsWrapperAsyncFriendlyPlugin() {
-	return {
-		name: "unrun-make-cjs-wrapper-async-friendly",
-		generateBundle: { handler(_outputOptions, bundle$1) {
-			for (const chunk of Object.values(bundle$1)) {
-				if (chunk.type !== "chunk") continue;
-				let code = chunk.code;
-				const marker = "__commonJS({";
-				if (!code.includes(marker)) return;
-				let pos = 0;
-				const arrowToken = "(() => {";
-				const asyncArrowToken = "(async () => {";
-				while (true) {
-					const markerIdx = code.indexOf(marker, pos);
-					if (markerIdx === -1) break;
-					const fnStart = code.indexOf(arrowToken, markerIdx);
-					if (fnStart === -1) {
-						pos = markerIdx + 12;
-						continue;
-					}
-					const bodyStart = fnStart + 8;
-					let i = bodyStart;
-					let depth = 1;
-					while (i < code.length && depth > 0) {
-						const ch = code[i++];
-						if (ch === "{") depth++;
-						else if (ch === "}") depth--;
-					}
-					if (depth !== 0) break;
-					const bodyEnd = i - 1;
-					const body = code.slice(bodyStart, bodyEnd);
-					if (/\bawait\b/.test(body) && code.slice(fnStart, fnStart + 14) !== asyncArrowToken) {
-						code = `${code.slice(0, fnStart + 1)}async ${code.slice(fnStart + 1)}`;
-						pos = fnStart + 1 + 6;
-						continue;
-					}
-					pos = bodyEnd;
-				}
-				if (code !== chunk.code) chunk.code = code;
-			}
-		} }
-	};
-}
-/**
-* Fix require.resolve calls to use the correct base path.
-* Replace __require.resolve("./relative") with proper resolution from original file location.
-*/
-function createRequireResolveFix(options) {
-	return {
-		name: "unrun-require-resolve-fix",
-		generateBundle: { handler(_, bundle$1) {
-			for (const chunk of Object.values(bundle$1)) if (chunk.type === "chunk") chunk.code = chunk.code.replaceAll(/__require\.resolve\(["']([^"']+)["']\)/g, (match, id) => {
-				if (id.startsWith("./") || id.startsWith("../")) try {
-					const baseDir = path.dirname(options.path);
-					for (const ext of [
-						"",
-						".ts",
-						".js",
-						".mts",
-						".mjs",
-						".cts",
-						".cjs"
-					]) {
-						const testPath = path.resolve(baseDir, id + ext);
-						if (fs.existsSync(testPath)) return JSON.stringify(testPath);
-					}
-					const resolvedPath = path.resolve(baseDir, id);
-					return JSON.stringify(resolvedPath);
-				} catch {
-					return match;
-				}
-				return match;
-			});
-		} }
-	};
-}
-/**
-* Ensure typeof require in ESM stays undefined to match jiti behavior.
-* Replaces typeof __require with typeof require to maintain compatibility.
-*/
-function createRequireTypeofFix() {
-	return {
-		name: "unrun-require-typeof-fix",
-		generateBundle: { handler(_, bundle$1) {
-			for (const chunk of Object.values(bundle$1)) if (chunk.type === "chunk") chunk.code = chunk.code.replaceAll(/\btypeof\s+__require\b/g, "typeof require");
-		} }
-	};
-}
-/**
-* A rolldown plugin that injects source context shims:
-* - Replaces import.meta.resolve calls with resolved file URLs
-* - Injects per-module __filename/__dirname
-* - Replaces import.meta.url with the source file URL
-*/
-function createSourceContextShimsPlugin() {
-	return {
-		name: "unrun-source-context-shims",
-		load: {
-			filter: { id: /\.(?:m?[jt]s|c?tsx?)(?:$|\?)/ },
-			handler(id) {
-				let code;
-				try {
-					code = fs.readFileSync(id, "utf8");
-				} catch {
-					return null;
-				}
-				let __MODIFIED_CODE__ = false;
-				if (code.includes("import.meta.resolve")) {
-					const replaced = code.replaceAll(/import\.meta\.resolve!?\s*\(\s*(["'])([^"']+)\1\s*\)/g, (_m, _q, spec) => {
-						const url = pathToFileURL(path.resolve(path.dirname(id), spec)).href;
-						return JSON.stringify(url);
-					});
-					if (replaced !== code) {
-						code = replaced;
-						__MODIFIED_CODE__ = true;
-					}
-				}
-				if (/__filename|__dirname|import\s*\.\s*meta\s*\.\s*url/.test(code)) {
-					const file = id;
-					const dir = path.dirname(id);
-					const url = pathToFileURL(id).href;
-					const prologue = `const __filename = ${JSON.stringify(file)}\nconst __dirname = ${JSON.stringify(dir)}\n`;
-					const protectedStrings = [];
-					let protectedCode = code.replaceAll(/(["'])[^"']*import\s*\.\s*meta\s*\.\s*url[^"']*\1\s*:/g, (match) => {
-						const placeholder = `__PROTECTED_STRING_${protectedStrings.length}__`;
-						protectedStrings.push(match);
-						return placeholder;
-					});
-					protectedCode = protectedCode.replaceAll(/\bimport\s*\.\s*meta\s*\.\s*url\b/g, JSON.stringify(url));
-					for (const [i, protectedString] of protectedStrings.entries()) protectedCode = protectedCode.replace(`__PROTECTED_STRING_${i}__`, protectedString);
-					code = prologue + protectedCode;
-					__MODIFIED_CODE__ = true;
-				}
-				return __MODIFIED_CODE__ ? { code } : null;
-			}
-		}
-	};
-}
-async function bundle(options) {
-	const resolvedTsconfigPath = path.resolve(process.cwd(), "tsconfig.json");
-	const tsconfig = existsSync(resolvedTsconfigPath) ? resolvedTsconfigPath : void 0;
-	const inputOptions = {
-		input: options.path,
-		platform: "node",
-		external: (id) => !id.startsWith(".") && !path.isAbsolute(id) && !id.startsWith("#"),
-		plugins: [
-			createMakeCjsWrapperAsyncFriendlyPlugin(),
-			createRequireResolveFix(options),
-			createSourceContextShimsPlugin(),
-			...options.preset === "jiti" ? [
-				createConsoleOutputCustomizer(),
-				createJsonLoader(),
-				createRequireTypeofFix()
-			] : []
-		],
-		transform: { define: {
-			__dirname: JSON.stringify(path.dirname(options.path)),
-			__filename: JSON.stringify(options.path),
-			"import.meta.url": JSON.stringify(pathToFileURL(options.path).href),
-			"import.meta.filename": JSON.stringify(options.path),
-			"import.meta.dirname": JSON.stringify(path.dirname(options.path)),
-			"import.meta.env": "process.env"
-		} },
-		...options.inputOptions
-	};
-	if (tsconfig) inputOptions.tsconfig = tsconfig;
-	const bundle$1 = await rolldown(inputOptions);
-	const outputOptions = {
-		format: "esm",
-		inlineDynamicImports: true,
-		keepNames: true,
-		...options.outputOptions
-	};
-	const rolldownOutput = await bundle$1.generate(outputOptions);
-	if (!rolldownOutput.output[0]) throw new Error("[unrun] No output chunk found");
-	const files = await bundle$1.watchFiles;
-	return {
-		chunk: rolldownOutput.output[0],
-		dependencies: files
-	};
-}
-/**
-* Clean the module file at the given URL.
-* Deletes the file if it exists.
-* @param moduleUrl - The URL of the module file to be cleaned.
-* @param options - Resolved options.
-*/
-function cleanModule(moduleUrl, options) {
-	if (options.debug) return;
-	try {
-		if (moduleUrl.startsWith("file://")) {
-			const filePath = new URL(moduleUrl);
-			fs.unlinkSync(filePath);
-		}
-	} catch (error) {
-		if (error.code !== "ENOENT") throw error;
-	}
-}
-function sanitize(name) {
-	return name.replaceAll(/[^\w.-]/g, "_");
-}
-/**
-* Writes a module to the filesystem.
-* @param code - The JavaScript code to be written as a module.
-* @param options - Resolved options.
-* @returns The file URL of the written module.
-*/
-function writeModule(code, options) {
-	const filenameHint = path.basename(options.path);
-	let moduleUrl = "";
-	try {
-		const randomKey = crypto.randomBytes(16).toString("hex");
-		const fname = `${filenameHint ? `${sanitize(filenameHint)}.` : ""}${randomKey}.mjs`;
-		const projectNodeModules = path.join(process.cwd(), "node_modules");
-		const outDir = path.join(projectNodeModules, ".unrun");
-		const outFile = path.join(outDir, fname);
-		if (!fs.existsSync(outFile)) try {
-			fs.mkdirSync(outDir, { recursive: true });
-			fs.writeFileSync(outFile, code, "utf8");
-		} catch {
-			const fallbackDir = path.join(tmpdir(), "unrun-cache");
-			const fallbackFile = path.join(fallbackDir, fname);
-			fs.mkdirSync(fallbackDir, { recursive: true });
-			fs.writeFileSync(fallbackFile, code, "utf8");
-			moduleUrl = pathToFileURL(fallbackFile).href;
-		}
-		moduleUrl = moduleUrl || pathToFileURL(outFile).href;
-	} catch {
-		moduleUrl = `data:text/javascript;base64,${Buffer.from(code).toString("base64")}`;
-	}
-	return moduleUrl;
-}
-/**
-* Import a JS module from code string.
-* Write ESM code to a temp file (prefer project-local node_modules/.unrun) and import it.
-* @param code - The JavaScript code to be imported as a module.
-* @param options - Resolved options.
-* @returns The imported module.
-*/
-async function loadModule(code, options) {
-	const moduleUrl = writeModule(code, options);
-	let _module;
-	try {
-		_module = await import(moduleUrl);
-	} finally {
-		cleanModule(moduleUrl, options);
-	}
-	return _module;
-}
-/**
-* Loads a module with JIT transpilation based on the provided options.
-*
-* @param options - The options for loading the module.
-* @returns A promise that resolves to the loaded module.
-*/
-async function unrun(options) {
-	const resolvedOptions = resolveOptions(options);
-	const output = await bundle(resolvedOptions);
-	let module;
-	try {
-		module = await loadModule(output.chunk.code, resolvedOptions);
-	} catch (error) {
-		throw new Error(`[unrun] Import failed (code length: ${output.chunk.code.length}): ${error.message}`);
-	}
-	return {
-		module: preset(resolvedOptions, module),
-		dependencies: output.dependencies
-	};
-}
-
-//#endregion
-export { unrun };