env-runner 0.3.0 → 0.3.1

package/dist/_chunks/virtual-loader.mjs

@@ -1,345 +0,0 @@
-import { Buffer } from "node:buffer";
-import { isAbsolute } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
-const VIRTUAL_MODULE_FORMATS = /* @__PURE__ */ new Set([
-	"module",
-	"commonjs",
-	"module-typescript",
-	"commonjs-typescript",
-	"jsx",
-	"tsx",
-	"json",
-	"text",
-	"bytes",
-	"wasm"
-]);
-const EXTENSION_FORMATS = {
-	".cjs": "commonjs",
-	".json": "json",
-	".ts": "module-typescript",
-	".mts": "module-typescript",
-	".cts": "commonjs-typescript",
-	".jsx": "jsx",
-	".tsx": "tsx",
-	".wasm": "wasm"
-};
-function virtualModuleFormat(key, module) {
-	return typeof module === "object" ? module.format : _extensionFormat(key) ?? "module";
-}
-function virtualModuleCodeSource(key, module) {
-	if (module === void 0) return;
-	const format = virtualModuleFormat(key, module);
-	if (format === "json" || format === "text" || _isBinaryFormat(format)) return;
-	return typeof module === "string" ? module : module.source;
-}
-function normalizeVirtualModule(key, content) {
-	const module = typeof content === "string" || content instanceof Uint8Array ? { source: content } : content;
-	const source = module?.source;
-	if (typeof source !== "string" && !(source instanceof Uint8Array)) throw new TypeError(`[env-runner] virtual module "${key}" must be a string, a Uint8Array or { source, format }.`);
-	const binary = typeof source !== "string";
-	const format = module.format ?? _extensionFormat(key) ?? (binary ? "bytes" : "module");
-	if (!VIRTUAL_MODULE_FORMATS.has(format)) throw new TypeError(`[env-runner] virtual module "${key}" has an unknown format "${format}" (expected one of: ${[...VIRTUAL_MODULE_FORMATS].join(", ")}).`);
-	if (binary !== _isBinaryFormat(format)) throw new TypeError(`[env-runner] virtual module "${key}" has format "${format}", which needs ${binary ? "a string" : "a Uint8Array"} source.`);
-	if (format === "wasm" && !WebAssembly.validate(source)) throw new TypeError(`[env-runner] virtual module "${key}" is not a valid WebAssembly binary.`);
-	if (typeof content === "string") return content;
-	return {
-		source: binary ? new Uint8Array(source) : source,
-		format
-	};
-}
-function normalizeVirtualModules(virtual) {
-	const out = {};
-	for (const [key, content] of Object.entries(virtual)) out[key] = normalizeVirtualModule(key, content);
-	return out;
-}
-async function resolveVirtualModules(virtual) {
-	const entries = await Promise.all(Object.entries(virtual).map(async ([key, value]) => {
-		return [key, normalizeVirtualModule(key, typeof value === "function" ? await value() : value)];
-	}));
-	return Object.fromEntries(entries);
-}
-function encodeVirtualModules(virtual) {
-	const out = {};
-	for (const [key, module] of Object.entries(virtual)) out[key] = module !== null && typeof module === "object" && typeof module.source !== "string" ? {
-		source: _toBase64(module.source),
-		format: module.format,
-		encoding: "base64"
-	} : module;
-	return out;
-}
-function decodeVirtualModules(virtual) {
-	const out = {};
-	for (const [key, module] of Object.entries(virtual)) out[key] = module !== null && typeof module === "object" && "encoding" in module ? {
-		source: new Uint8Array(Buffer.from(module.source, "base64")),
-		format: module.format
-	} : module;
-	return out;
-}
-function virtualModuleCode(format, source) {
-	if (format === "text") return `export default ${JSON.stringify(source)};\n`;
-	const bytes = [
-		`const base64 = ${JSON.stringify(_toBase64(source))};`,
-		`let bytes;`,
-		`if (typeof Uint8Array.fromBase64 === "function") {`,
-		`  bytes = Uint8Array.fromBase64(base64);`,
-		`} else {`,
-		`  const binary = atob(base64);`,
-		`  bytes = new Uint8Array(binary.length);`,
-		`  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);`,
-		`}`
-	];
-	const value = format === "wasm" ? "new WebAssembly.Module(bytes)" : "bytes";
-	return `${bytes.join("\n")}\nexport default ${value};\n`;
-}
-function unsupportedVirtualJSXError(key, format, runtime) {
-	return /* @__PURE__ */ new TypeError(`[env-runner] virtual module "${key}" has format "${format}", which ${runtime} can't load from memory; pre-transpile it to JavaScript (and pass { source, format: "module" } to keep the key).`);
-}
-const VIRTUAL_SCHEME = "virtual:";
-function createVirtualHooks(virtual, opts = {}) {
-	const { versions, importers, forcePlainModule } = opts;
-	const baseURL = opts.baseURL ?? _defaultBaseURL();
-	const keyURLs = /* @__PURE__ */ new Map();
-	const urlKeys = /* @__PURE__ */ new Map();
-	for (const key of Object.keys(virtual)) {
-		const url = _virtualKeyURL(key);
-		if (url) {
-			keyURLs.set(key, url);
-			urlKeys.set(url, key);
-		}
-	}
-	const keyOf = (url) => {
-		if (url.startsWith(VIRTUAL_SCHEME)) {
-			const key = _virtualURLKey(url);
-			return key !== void 0 && Object.hasOwn(virtual, key) ? key : void 0;
-		}
-		return urlKeys.size > 0 && url.startsWith("file:") ? urlKeys.get(_bareURL(url)) : void 0;
-	};
-	const moduleFiles = importers && /* @__PURE__ */ new Set();
-	const track = (node, context) => {
-		const { parentURL } = context;
-		if (!importers || !parentURL) return;
-		let importer = keyOf(parentURL);
-		if (importer === void 0 && !context.conditions?.includes("require")) {
-			const file = _bareURL(parentURL);
-			importer = moduleFiles.has(file) ? file : void 0;
-		}
-		if (importer !== void 0 && importer !== node) {
-			let set = importers.get(node);
-			if (!set) importers.set(node, set = /* @__PURE__ */ new Set());
-			set.add(importer);
-		}
-	};
-	const serve = (key, url, context) => {
-		track(key, context);
-		if (opts.opaquePathURL && keyURLs.has(key) && opts.opaquePathURL(keyURLs.get(key))) url = _virtualURL(key) + url.slice(_bareURL(url).length);
-		const version = versions?.get(key);
-		return {
-			url: version ? _appendQuery(url, `v=${version}`) : url,
-			shortCircuit: true
-		};
-	};
-	const resolve = (specifier, context, nextResolve) => {
-		const key = _stripQuery(specifier);
-		if (Object.hasOwn(virtual, key)) {
-			const keyURL = keyURLs.get(key);
-			const url = keyURL ? keyURL + specifier.slice(key.length) : _virtualURL(specifier);
-			return serve(key, url, context);
-		}
-		let parentURL = context.parentURL;
-		if (parentURL?.startsWith(VIRTUAL_SCHEME)) {
-			const parentKey = keyOf(parentURL);
-			parentURL = parentKey !== void 0 && keyURLs.get(parentKey) || baseURL;
-		}
-		if (urlKeys.size > 0) {
-			const url = _resolvePathSpecifier(specifier, parentURL);
-			const pathKey = url && urlKeys.get(_bareURL(url));
-			if (pathKey) return serve(pathKey, url, context);
-		}
-		const result = nextResolve(specifier, parentURL === context.parentURL ? context : {
-			...context,
-			parentURL
-		});
-		const resolvedKey = urlKeys.size > 0 ? urlKeys.get(_bareURL(result.url)) : void 0;
-		if (resolvedKey) return serve(resolvedKey, result.url, context);
-		if (result.url.startsWith("file:")) {
-			const file = _bareURL(result.url);
-			track(file, context);
-			const version = versions?.get(file);
-			if (version) return {
-				...result,
-				url: _appendQuery(result.url, `v=${version}`)
-			};
-		}
-		return result;
-	};
-	const load = (url, context, nextLoad) => {
-		const key = keyOf(url);
-		if (key !== void 0) {
-			const module = virtual[key];
-			if (forcePlainModule) return {
-				format: "module",
-				source: module,
-				shortCircuit: true
-			};
-			return {
-				..._nodeLoadResult(key, module),
-				shortCircuit: true
-			};
-		}
-		const result = nextLoad(url, context);
-		if (moduleFiles && url.startsWith("file:") && _isModuleFormat(result.format)) moduleFiles.add(_bareURL(url));
-		return result;
-	};
-	const updateKeys = (keys) => {
-		for (const key of keys) {
-			const url = keyURLs.get(key) ?? _virtualKeyURL(key);
-			if (!url) continue;
-			if (Object.hasOwn(virtual, key)) {
-				keyURLs.set(key, url);
-				urlKeys.set(url, key);
-				continue;
-			}
-			keyURLs.delete(key);
-			if (urlKeys.get(url) === key) {
-				urlKeys.delete(url);
-				for (const [other, otherURL] of keyURLs) if (otherURL === url) urlKeys.set(url, other);
-			}
-		}
-	};
-	return {
-		resolve,
-		load,
-		updateKeys
-	};
-}
-function _nodeLoadResult(key, module) {
-	const format = virtualModuleFormat(key, module);
-	const source = typeof module === "string" ? module : module.source;
-	if (format === "text" || format === "bytes" || format === "wasm") return {
-		format: "module",
-		source: virtualModuleCode(format, source)
-	};
-	if (format === "jsx" || format === "tsx") throw unsupportedVirtualJSXError(key, format, "Node.js");
-	return {
-		format,
-		source
-	};
-}
-function stripVirtualTypeScript(specifier, source, stripTypeScriptTypes, hints) {
-	if (typeof stripTypeScriptTypes !== "function") throw new TypeError(`[env-runner] virtual TypeScript module "${specifier}" requires \`module.stripTypeScriptTypes\` ${hints.requirement}; ${hints.remedy} or provide a pre-transpiled JavaScript source instead.`);
-	try {
-		return stripTypeScriptTypes(source);
-	} catch (error) {
-		throw new SyntaxError(`[env-runner] failed to strip types from virtual module "${specifier}": ${error?.message || error}`, { cause: error });
-	}
-}
-function expandVirtualInvalidation(virtual, specifier, importers) {
-	const invalidated = [...new Set(typeof specifier === "string" ? [specifier] : specifier)];
-	const seen = new Set(invalidated);
-	const add = (key) => {
-		if (!seen.has(key)) {
-			seen.add(key);
-			invalidated.push(key);
-		}
-	};
-	for (const target of invalidated) {
-		for (const key of importers?.get(target) ?? []) add(key);
-		if (!Object.hasOwn(virtual, target)) continue;
-		const refs = [
-			`"${target}"`,
-			`'${target}'`,
-			"`" + target + "`"
-		];
-		for (const [key, module] of Object.entries(virtual)) {
-			const code = virtualModuleCodeSource(key, module);
-			if (code !== void 0 && refs.some((ref) => code.includes(ref))) add(key);
-		}
-	}
-	return invalidated;
-}
-function findVirtualPathKey(virtual, specifier) {
-	const url = _virtualKeyURL(_stripQuery(specifier));
-	if (!url) return;
-	let match;
-	for (const key of Object.keys(virtual)) if (_virtualKeyURL(key) === url) match = key;
-	return match;
-}
-const _warnedPathCollisions = /* @__PURE__ */ new Set();
-function warnVirtualPathCollisions(keys) {
-	try {
-		const urlKeys = /* @__PURE__ */ new Map();
-		for (const key of keys) {
-			const url = _virtualKeyURL(key);
-			if (!url) continue;
-			const other = urlKeys.get(url);
-			if (other !== void 0 && !_warnedPathCollisions.has(`${other}\0${key}`)) {
-				_warnedPathCollisions.add(`${other}\0${key}`);
-				console.warn(`[env-runner] virtual modules "${other}" and "${key}" name the same file; keep only one of them (which one is served depends on the runtime).`);
-			}
-			urlKeys.set(url, key);
-		}
-	} catch {}
-}
-const virtualKeyURL = _virtualKeyURL;
-function virtualModuleCacheId(key) {
-	const url = _virtualKeyURL(key);
-	return url ? fileURLToPath(url) : _virtualURL(key);
-}
-function _virtualKeyURL(key) {
-	if (key.startsWith("file:")) try {
-		return _bareURL(new URL(key).href);
-	} catch {
-		return;
-	}
-	return isAbsolute(key) ? pathToFileURL(key).href : void 0;
-}
-function _virtualURL(specifier) {
-	return VIRTUAL_SCHEME + specifier.replace(/[\0-\x20"%<>`\x7F-\u{10FFFF}]/gu, encodeURIComponent);
-}
-function _virtualURLKey(url) {
-	try {
-		return decodeURIComponent(_stripQuery(url.slice(8)));
-	} catch {
-		return;
-	}
-}
-function _extensionFormat(key) {
-	const extension = /\.[^./\\]+$/.exec(key)?.[0];
-	return extension === void 0 ? void 0 : EXTENSION_FORMATS[extension];
-}
-function _isBinaryFormat(format) {
-	return format === "bytes" || format === "wasm";
-}
-function _toBase64(bytes) {
-	return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("base64");
-}
-function _isModuleFormat(format) {
-	return format == null || format === "module" || format === "module-typescript";
-}
-function _stripQuery(specifier) {
-	const qIndex = specifier.indexOf("?");
-	return qIndex === -1 ? specifier : specifier.slice(0, qIndex);
-}
-function _bareURL(url) {
-	const index = url.search(/[?#]/);
-	return index === -1 ? url : url.slice(0, index);
-}
-function _appendQuery(url, param) {
-	const hashIndex = url.startsWith(VIRTUAL_SCHEME) ? -1 : url.indexOf("#");
-	const base = hashIndex === -1 ? url : url.slice(0, hashIndex);
-	const hash = hashIndex === -1 ? "" : url.slice(hashIndex);
-	return base + (base.includes("?") ? "&" : "?") + param + hash;
-}
-function _resolvePathSpecifier(specifier, parentURL) {
-	try {
-		if (/^\.{0,2}\//.test(specifier) || specifier.startsWith("file:")) return new URL(specifier, parentURL).href;
-		if (isAbsolute(specifier)) {
-			const path = _stripQuery(specifier);
-			return pathToFileURL(path).href + specifier.slice(path.length);
-		}
-	} catch {}
-}
-function _defaultBaseURL() {
-	return pathToFileURL(process.cwd() + "/").href;
-}
-export { createVirtualHooks, decodeVirtualModules, encodeVirtualModules, expandVirtualInvalidation, findVirtualPathKey, normalizeVirtualModules, resolveVirtualModules, stripVirtualTypeScript, unsupportedVirtualJSXError, virtualKeyURL, virtualModuleCacheId, virtualModuleCode, virtualModuleCodeSource, virtualModuleFormat, warnVirtualPathCollisions };