@statewalker/webrun-bundler 0.0.0-stage → 0.1.1

package/dist/index.mjs

@@ -0,0 +1,630 @@
+import { normalizePath, readText, tryReadText } from "@statewalker/webrun-files";
+import { exports, imports } from "resolve.exports";
+//#region src/paths.ts
+/** `path` joined to `dir`, with `.` and `..` resolved; `undefined` when it leaves `root`. */
+function joinWithin(root, dir, path) {
+	const parts = (path.startsWith("/") ? path : `${dir}/${path}`).split("/");
+	const out = [];
+	for (const p of parts) {
+		if (!p || p === ".") continue;
+		if (p === "..") {
+			if (!out.length) return void 0;
+			out.pop();
+		} else out.push(p);
+	}
+	const joined = `/${out.join("/")}`;
+	const r = normalizePath(root);
+	return r === "/" || joined === r || joined.startsWith(`${r}/`) ? joined : void 0;
+}
+const dirOf = (path) => path.slice(0, path.lastIndexOf("/")) || "/";
+/** The id of a mount's file: `<prefix>/<path below root>`. */
+function idOf(mount, path) {
+	const r = normalizePath(mount.root);
+	const rel = r === "/" ? path : path.slice(r.length);
+	return `${mount.prefix}${rel || "/"}`;
+}
+/** A mount's file from its id; `undefined` when the id is not the mount's. */
+function pathOf(mount, id) {
+	if (!id.startsWith(`${mount.prefix}/`)) return void 0;
+	const r = normalizePath(mount.root);
+	const rel = id.slice(mount.prefix.length);
+	return r === "/" ? rel : `${r}${rel}`;
+}
+async function isFile(mount, path) {
+	return (await mount.files.stats(path))?.kind === "file";
+}
+async function readManifest(files, dir) {
+	const text = await tryReadText(files, `${dir === "/" ? "" : dir}/package.json`);
+	if (text === void 0) return void 0;
+	try {
+		return JSON.parse(text);
+	} catch {
+		return;
+	}
+}
+/** `react` → `{ name: "react" }`; `@a/b/c.js` → `{ name: "@a/b", subpath: "c.js" }`. */
+function parsePackageSpecifier(spec) {
+	const parts = spec.split("/");
+	const n = spec.startsWith("@") ? 2 : 1;
+	const name = parts.slice(0, n).join("/");
+	const subpath = parts.slice(n).join("/");
+	return subpath ? {
+		name,
+		subpath
+	} : { name };
+}
+//#endregion
+//#region src/input-maps.ts
+const MAP_COMMENT = /\/\/[#@]\s*sourceMappingURL=(\S+)\s*$/;
+const toBase64$1 = (text) => {
+	const bytes = new TextEncoder().encode(text);
+	let bin = "";
+	for (let i = 0; i < bytes.length; i += 32768) bin += String.fromCharCode(...bytes.subarray(i, i + 32768));
+	return btoa(bin);
+};
+const fromBase64 = (b64) => new TextDecoder().decode(Uint8Array.from(atob(b64), (c) => c.charCodeAt(0)));
+/**
+* A file's own source map, made usable by esbuild, which reads only maps inlined in
+* the file it loads (it cannot follow a linked `.map` through a FilesApi):
+*
+* - a linked map (`//# sourceMappingURL=index.js.map`) is read from the same tree and
+*   inlined; an inline `data:` map is kept;
+* - its sources become ids of the same tree (`npm:pkg@1.0.0/src/index.ts`), so the
+*   bundle's map names the package's original files, not the published JavaScript;
+* - missing `sourcesContent` is filled from the tree when the original file ships
+*   with the package.
+*
+* esbuild then composes it with its own: a bundled line traces to the original source.
+* A map that is missing or unreadable is dropped (the file maps to itself).
+*/
+/**
+* `code` without its trailing `sourceMappingURL` comment (and without reading the map): for
+* bundles built with no source map, where an inlined input map would only add to what esbuild
+* parses and holds (a package's maps, with their sources' text, can outweigh its code).
+*/
+function withoutInputMap(code) {
+	const end = code.trimEnd();
+	const nl = end.lastIndexOf("\n");
+	return MAP_COMMENT.test(end.slice(nl + 1)) ? end.slice(0, Math.max(0, nl)) : code;
+}
+async function inlineInputMap(mount, path, code) {
+	const lines = code.trimEnd().split("\n");
+	const last = lines[lines.length - 1] ?? "";
+	const match = MAP_COMMENT.exec(last);
+	if (!match) return code;
+	const url = match[1];
+	const body = lines.slice(0, -1).join("\n");
+	let text;
+	let mapDir = dirOf(path);
+	if (url.startsWith("data:")) {
+		const comma = url.indexOf(",");
+		const meta = url.slice(5, comma);
+		const payload = url.slice(comma + 1);
+		try {
+			text = meta.endsWith(";base64") ? fromBase64(payload) : decodeURIComponent(payload);
+		} catch {
+			text = void 0;
+		}
+	} else if (!/^[a-z][a-z0-9+.-]*:/i.test(url)) {
+		const mapPath = joinWithin(mount.root, dirOf(path), decodeURIComponent(url));
+		if (mapPath) {
+			text = await tryReadText(mount.files, mapPath);
+			mapDir = dirOf(mapPath);
+		}
+	}
+	let map;
+	try {
+		map = JSON.parse(text ?? "");
+	} catch {
+		return body;
+	}
+	const sourceDir = map.sourceRoot ? joinWithin("/", mapDir, map.sourceRoot.replace(/\/$/, "")) ?? mapDir : mapDir;
+	const contents = map.sourcesContent ? [...map.sourcesContent] : [];
+	const sources = [];
+	for (let i = 0; i < map.sources.length; i++) {
+		const src = map.sources[i];
+		const local = /^[a-z][a-z0-9+.-]*:/i.test(src) ? void 0 : joinWithin(mount.root, sourceDir, src);
+		sources.push(local ? idOf(mount, local) : src);
+		if (contents[i] == null && local) contents[i] = await tryReadText(mount.files, local) ?? null;
+	}
+	const fixed = {
+		...map,
+		sources,
+		sourcesContent: contents
+	};
+	delete fixed.sourceRoot;
+	return `${body}\n//# sourceMappingURL=data:application/json;base64,${toBase64$1(JSON.stringify(fixed))}\n`;
+}
+//#endregion
+//#region src/packages.ts
+const mountPrefix = (name, version) => `npm:${name}@${version ?? "0.0.0"}`;
+/**
+* Packages from `node_modules` folders, found as Node finds them: in the importing
+* file's directory and each parent, inside the importer's own FilesApi. A package
+* installed in the project (or in another package's `node_modules`) is read where it is.
+*
+* pnpm layouts: a package's own dependencies sit next to its real directory in
+* `node_modules/.pnpm`, which Node reaches through the symlink's real path and a FilesApi
+* cannot see. When the walk finds nothing, each ancestor's `node_modules/.pnpm/node_modules`
+* (pnpm's hoisted links to every installed package) is tried too.
+*/
+function nodeModulesPackages() {
+	const mounts = /* @__PURE__ */ new Map();
+	const at = async (files, root, name) => {
+		const known = mounts.get(root);
+		if (known && known.files === files) return known;
+		const manifest = await readManifest(files, root);
+		if (!manifest) return void 0;
+		const mount = {
+			prefix: mountPrefix(name, manifest.version),
+			files,
+			root,
+			manifest
+		};
+		mounts.set(root, mount);
+		return mount;
+	};
+	const ancestors = (path) => {
+		const dirs = [];
+		for (let dir = dirOf(path);; dir = dirOf(dir)) {
+			dirs.push(dir === "/" ? "" : dir);
+			if (dir === "/") return dirs;
+		}
+	};
+	return { async get(name, importer) {
+		const files = importer.mount.files;
+		const dirs = ancestors(importer.path);
+		for (const dir of dirs) {
+			const m = await at(files, `${dir}/node_modules/${name}`, name);
+			if (m) return m;
+		}
+		for (const dir of dirs) {
+			const m = await at(files, `${dir}/node_modules/.pnpm/node_modules/${name}`, name);
+			if (m) return m;
+		}
+	} };
+}
+const DEPENDENCY_FIELDS = [
+	"dependencies",
+	"peerDependencies",
+	"optionalDependencies",
+	"devDependencies"
+];
+/** The version range `importer`'s `package.json` gives `name`, if any. */
+function rangeFor(name, importer) {
+	const m = importer.mount.manifest;
+	for (const field of DEPENDENCY_FIELDS) {
+		const range = m?.[field]?.[name];
+		if (range) return range;
+	}
+}
+/**
+* Packages fetched on demand (default: the npm registry, through webrun-modules'
+* `npmRegistrySource`) and kept in memory: each one is its own FilesApi tree. The
+* version is the range the importer's `package.json` declares (the project's for the
+* project's files), else the latest; one range loads once.
+*/
+function npmPackages(opts = {}) {
+	let registry;
+	const source = opts.source ?? {
+		matches: (ref) => "pkg" in ref,
+		load: async (ref) => {
+			registry ??= import("@statewalker/webrun-modules").then((m) => m.npmRegistrySource());
+			return (await registry).load(ref);
+		}
+	};
+	const byRange = /* @__PURE__ */ new Map();
+	const byVersion = /* @__PURE__ */ new Map();
+	return { get(name, importer) {
+		const range = rangeFor(name, importer);
+		const key = `${name}@${range ?? "latest"}`;
+		let mount = byRange.get(key);
+		if (!mount) {
+			mount = source.load({
+				pkg: name,
+				version: range
+			}).then((p) => {
+				const prefix = mountPrefix(p.name, p.version);
+				const seen = byVersion.get(prefix);
+				if (seen) return seen;
+				const m = {
+					prefix,
+					files: p.files,
+					root: "/",
+					manifest: p.manifest
+				};
+				byVersion.set(prefix, m);
+				return m;
+			});
+			byRange.set(key, mount);
+		}
+		return mount;
+	} };
+}
+/** The first store that has the package wins (`node_modules` first, then the registry). */
+function chainPackages(...stores) {
+	return { async get(name, importer) {
+		let failure;
+		for (const s of stores) try {
+			const m = await s.get(name, importer);
+			if (m) return m;
+		} catch (e) {
+			failure ??= e;
+		}
+		if (failure) throw failure;
+	} };
+}
+//#endregion
+//#region src/resolve.ts
+/** Extensions tried, in order, for a path written without one (or with `.js` for a `.ts` file). */
+const EXTENSIONS = [
+	".ts",
+	".tsx",
+	".mts",
+	".cts",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs",
+	".json"
+];
+/** `path` as written, else with an extension, else its `index` file. */
+async function resolveFile(mount, path) {
+	if (await isFile(mount, path)) return path;
+	const js = /\.(m|c)?jsx?$/.exec(path);
+	if (js) {
+		const base = path.slice(0, -js[0].length);
+		for (const ext of [`.${js[1] ?? ""}ts`, ".tsx"]) if (await isFile(mount, base + ext)) return base + ext;
+	}
+	for (const ext of EXTENSIONS) if (await isFile(mount, path + ext)) return path + ext;
+	const dir = path.endsWith("/") ? path.slice(0, -1) : path;
+	for (const ext of EXTENSIONS) if (await isFile(mount, `${dir}/index${ext}`)) return `${dir}/index${ext}`;
+}
+function exportsTarget(manifest, entry, c) {
+	try {
+		return exports(manifest, entry, {
+			conditions: c.conditions,
+			require: c.require,
+			browser: c.browser
+		})?.[0];
+	} catch {
+		return;
+	}
+}
+/** A package's file for `subpath`: `exports` first, then `module`/`main` (and `browser` when it is a string). */
+async function resolvePackageEntry(mount, subpath, c) {
+	const manifest = mount.manifest ?? {};
+	const entry = subpath ? `./${subpath}` : ".";
+	if (manifest.exports !== void 0) {
+		const target = exportsTarget(manifest, entry, c);
+		if (!target) return void 0;
+		return joinWithin(mount.root, mount.root, target);
+	}
+	if (subpath) return resolveFile(mount, joinWithin(mount.root, mount.root, subpath) ?? "");
+	const fields = [
+		...c.browser && typeof manifest.browser === "string" ? [manifest.browser] : [],
+		...c.require ? [] : [manifest.module],
+		manifest.main,
+		"index.js"
+	].filter((f) => typeof f === "string");
+	for (const f of fields) {
+		const p = joinWithin(mount.root, mount.root, f);
+		const file = p && await resolveFile(mount, p);
+		if (file) return file;
+	}
+}
+/**
+* Resolves `spec` as written in `importer`: a path of the same tree (`./x`, `../y.js`,
+* `/z`), a `#imports` alias of the importer's package, or a package found by `packages`
+* (with its `exports`, `module` and `main`).
+*/
+async function resolveSpecifier(spec, importer, packages, c) {
+	const { mount } = importer;
+	if (spec.startsWith("./") || spec.startsWith("../") || spec.startsWith("/") || spec === ".") {
+		const base = spec.startsWith("/") ? mount.root : dirOf(importer.path);
+		const target = joinWithin(mount.root, base, spec.startsWith("/") ? spec.slice(1) : spec);
+		const path = target && await resolveFile(mount, target);
+		return path ? {
+			mount,
+			path
+		} : void 0;
+	}
+	if (spec.startsWith("#")) try {
+		const target = imports(mount.manifest ?? {}, spec, {
+			conditions: c.conditions,
+			require: c.require,
+			browser: c.browser
+		})?.[0];
+		if (!target) return void 0;
+		if (!target.startsWith(".")) return resolveSpecifier(target, importer, packages, c);
+		const path = joinWithin(mount.root, mount.root, target);
+		return path && await isFile(mount, path) ? {
+			mount,
+			path
+		} : void 0;
+	} catch {
+		return;
+	}
+	const { name, subpath } = parsePackageSpecifier(spec);
+	const pkg = await packages.get(name, importer);
+	if (!pkg) return void 0;
+	const path = await resolvePackageEntry(pkg, subpath, c);
+	return path && await isFile(pkg, path) ? {
+		mount: pkg,
+		path
+	} : void 0;
+}
+//#endregion
+//#region src/bundle.ts
+/** esbuild's namespace for the files the bundler serves; its source-map names drop it. */
+const NS = "webrun";
+/** esbuild's namespace for the host's modules (`modules`): `virtual:<specifier>` in maps. */
+const VNS = "webrun-virtual";
+/** Marks an `inject` entry, so that it resolves like an import, not like the entry point. */
+const INJECT = "webrun-inject:";
+/** esbuild `supported` flags that lower `await` to generators. */
+const LOWER_AWAIT = {
+	"async-await": false,
+	"async-generator": false,
+	"for-await": false
+};
+const LOADERS = {
+	ts: "ts",
+	mts: "ts",
+	cts: "ts",
+	tsx: "tsx",
+	jsx: "jsx",
+	js: "js",
+	mjs: "js",
+	cjs: "js",
+	json: "json",
+	css: "css",
+	txt: "text",
+	wasm: "binary"
+};
+const loaderFor = (path) => LOADERS[/\.([a-z0-9]+)$/i.exec(path)?.[1]?.toLowerCase() ?? ""] ?? "js";
+const isExternal = (spec, patterns) => /^(https?:|data:)/.test(spec) || patterns.some((p) => typeof p === "string" ? p.endsWith("*") ? spec.startsWith(p.slice(0, -1)) : spec === p : p.test(spec));
+/** A source name of esbuild's map → the file id it stands for. */
+const sourceId = (s) => s.replace(/^(\.\.\/)*/, "").replace(new RegExp(`^${VNS}:`), "virtual:").replace(new RegExp(`^${NS}:`), "").replace("?type=module.mjs", "");
+const toBase64 = (text) => {
+	const bytes = new TextEncoder().encode(text);
+	let bin = "";
+	for (let i = 0; i < bytes.length; i += 32768) bin += String.fromCharCode(...bytes.subarray(i, i + 32768));
+	return btoa(bin);
+};
+/** `code` with its trailing map link replaced: by `map` inlined, or by a link to `name`. */
+function linkMap(code, map, how, name) {
+	return `${code.replace(/\n?\/\/# sourceMappingURL=\S+\s*$/, "")}\n//# sourceMappingURL=${how === "inline" ? `data:application/json;base64,${toBase64(JSON.stringify(map))}` : `${name.split("/").pop()}.map`}\n`;
+}
+/**
+* Bundles `entry` of a project into one module with esbuild (esbuild-wasm in browsers).
+* Every file is read through FilesApi (the project's, or a package's from `packages`):
+* esbuild resolves and loads nothing itself. esbuild transpiles TypeScript and JSX,
+* converts CommonJS, lowers `await` when asked, and bundles, all in one pass, and its
+* source map goes back through each step to the files it read; where a package ships
+* its own map (TypeScript compiled to `.js`), to the package's original source. The
+* map's sources are file ids: `~/src/app.ts`, `npm:pkg@1.2.3/src/index.ts`.
+*/
+/** Marks the id of a `.js` file in a `"type": "module"` package scope (see `moduleTypeOf`). */
+const ESM_SUFFIX = "?type=module.mjs";
+async function bundle(opts) {
+	const root = opts.root ?? "/";
+	const project = {
+		prefix: "~",
+		files: opts.files,
+		root,
+		manifest: await readManifest(opts.files, root)
+	};
+	const packages = opts.packages ?? nodeModulesPackages();
+	const external = opts.external ?? [];
+	const browser = (opts.platform ?? "browser") === "browser";
+	const conditions = opts.conditions ?? ["browser"];
+	const outfile = opts.outfile ?? "bundle.js";
+	const mounts = /* @__PURE__ */ new Map([[project.prefix, project]]);
+	const supplied = opts.modules;
+	const virtualSource = (spec) => typeof supplied === "function" ? supplied(spec) : supplied?.[spec];
+	/** The mount and path of a file id; the longest prefix wins (`npm:@a/b@1.0.0/…`). */
+	/**
+	* The module type of a `.js` file, as Node.js decides it: the `type` of the nearest
+	* `package.json` (tslib ships `modules/package.json` with `"type": "module"`). esbuild reads
+	* that only for files on its own file system; for ours, a file in a `"type": "module"` scope
+	* gets an id ending in ESM_SUFFIX (`.mjs`), so that esbuild gives its imports of CommonJS
+	* modules Node's interop: the default import is `module.exports`, even with `__esModule`.
+	* Vite gets the same from esbuild by pre-bundling dependencies from disk.
+	*/
+	const scopeTypes = /* @__PURE__ */ new Map();
+	const moduleTypeOf = async (mount, path) => {
+		const root = mount.root.replace(/\/$/, "");
+		for (let dir = dirOf(path); dir.length >= root.length; dir = dirOf(dir)) {
+			const key = `${mount.prefix}:${dir}`;
+			if (scopeTypes.has(key)) return scopeTypes.get(key);
+			const pj = `${dir === "/" ? "" : dir}/package.json`;
+			if (await isFile(mount, pj)) {
+				let type;
+				try {
+					type = JSON.parse(await readText(mount.files, pj)).type;
+				} catch {}
+				scopeTypes.set(key, type);
+				return type;
+			}
+			if (dir === root || dir === "/" || !dir) break;
+		}
+	};
+	const locate = (id) => {
+		if (id.endsWith(ESM_SUFFIX)) id = id.slice(0, -16);
+		let best;
+		for (const m of mounts.values()) if (id.startsWith(`${m.prefix}/`) && (!best || m.prefix.length > best.prefix.length)) best = m;
+		const path = best && pathOf(best, id);
+		if (!best || !path) throw new Error(`webrun-bundler: no file ${id}`);
+		return {
+			mount: best,
+			path
+		};
+	};
+	const plugin = {
+		name: "webrun-files",
+		setup(b) {
+			b.onResolve({ filter: /.*/ }, async (args) => {
+				const injected = args.path.startsWith(INJECT);
+				const spec = injected ? args.path.slice(14) : args.path;
+				if (args.kind === "entry-point" && !injected) {
+					const path = joinWithin(root, root, args.path.replace(/^\/+/, ""));
+					if (!path) return { errors: [{ text: `entry ${args.path} is outside the project` }] };
+					return {
+						path: idOf(project, path),
+						namespace: NS
+					};
+				}
+				if (virtualSource(spec) !== void 0) return {
+					path: spec,
+					namespace: VNS
+				};
+				if (isExternal(spec, external)) return {
+					path: spec,
+					external: true
+				};
+				const importer = injected || args.namespace === VNS ? {
+					mount: project,
+					path: `${root === "/" ? "" : root}/`
+				} : locate(args.importer);
+				const require = args.kind === "require-call" || args.kind === "require-resolve";
+				const failed = (why) => ({ errors: [{ text: `Could not resolve "${spec}" (imported by ${args.importer || "inject"})${why ? `: ${why}` : ""}` }] });
+				let r;
+				try {
+					r = await resolveSpecifier(spec, importer, packages, {
+						conditions,
+						require,
+						browser
+					});
+				} catch (e) {
+					return failed(e?.message ?? String(e));
+				}
+				if (!r) return failed();
+				mounts.set(r.mount.prefix, r.mount);
+				const esm = /\.js$/.test(r.path) && await moduleTypeOf(r.mount, r.path) === "module";
+				return {
+					path: idOf(r.mount, r.path) + (esm ? ESM_SUFFIX : ""),
+					namespace: NS
+				};
+			});
+			b.onLoad({
+				filter: /.*/,
+				namespace: VNS
+			}, (args) => ({
+				contents: virtualSource(args.path) ?? "",
+				loader: "js"
+			}));
+			b.onLoad({
+				filter: /.*/,
+				namespace: NS
+			}, async (args) => {
+				const { mount, path } = locate(args.path);
+				const loader = loaderFor(path);
+				if (loader === "binary") {
+					const chunks = [];
+					for await (const c of mount.files.read(path)) chunks.push(c);
+					const bytes = new Uint8Array(chunks.reduce((n, c) => n + c.length, 0));
+					let at = 0;
+					for (const c of chunks) {
+						bytes.set(c, at);
+						at += c.length;
+					}
+					return {
+						contents: bytes,
+						loader
+					};
+				}
+				const text = await readText(mount.files, path);
+				if (!(loader === "js" || loader === "ts" || loader === "jsx" || loader === "tsx")) return {
+					contents: text,
+					loader
+				};
+				if (opts.sourcemap === false) return {
+					contents: withoutInputMap(text),
+					loader
+				};
+				return {
+					contents: await inlineInputMap(mount, path, text),
+					loader
+				};
+			});
+		}
+	};
+	const { plugins: extraPlugins = [], ...rest } = opts.esbuildOptions ?? {};
+	const result = await opts.esbuild.build({
+		entryPoints: [opts.entry],
+		bundle: true,
+		write: false,
+		format: opts.format ?? "esm",
+		platform: opts.platform ?? "browser",
+		target: opts.target ?? "es2022",
+		outfile,
+		absWorkingDir: "/",
+		metafile: true,
+		logLevel: "silent",
+		minify: opts.minify,
+		define: opts.define,
+		...opts.lowerAwait ? { supported: LOWER_AWAIT } : {},
+		...rest,
+		...opts.inject?.length ? { inject: opts.inject.map((s) => INJECT + s) } : {},
+		sourcemap: opts.sourcemap === false ? false : "external",
+		sourcesContent: opts.sourcemap !== false,
+		plugins: [...extraPlugins, plugin]
+	});
+	const out = result.outputFiles ?? [];
+	const jsFile = out.find((f) => !f.path.endsWith(".map"));
+	const mapFile = out.find((f) => f.path.endsWith(".map"));
+	if (!jsFile) throw new Error("webrun-bundler: esbuild produced no output");
+	if (!mapFile) return {
+		code: jsFile.text,
+		map: {
+			version: 3,
+			sources: [],
+			names: [],
+			mappings: ""
+		},
+		metafile: result.metafile,
+		warnings: result.warnings
+	};
+	const raw = JSON.parse(mapFile.text);
+	const map = {
+		...raw,
+		file: outfile.split("/").pop(),
+		sources: raw.sources.map(sourceId)
+	};
+	delete map.sourceRoot;
+	return {
+		code: linkMap(jsFile.text, map, opts.sourcemap || "external", outfile),
+		map,
+		metafile: result.metafile,
+		warnings: result.warnings
+	};
+}
+/**
+* Transpiles one file (TypeScript, JSX, modern syntax down to `target`; `await` lowered
+* when asked) with a source map back to it. A map the code carries (`sourceMappingURL`,
+* inline) is composed in, so the result still traces to the original.
+*/
+async function transpile(code, opts) {
+	const r = await opts.esbuild.transform(code, {
+		loader: loaderFor(opts.path),
+		sourcefile: opts.path,
+		sourcemap: "external",
+		sourcesContent: true,
+		format: opts.format,
+		target: opts.target ?? "es2022",
+		minify: opts.minify,
+		define: opts.define,
+		...opts.lowerAwait ? { supported: LOWER_AWAIT } : {}
+	});
+	const map = JSON.parse(r.map);
+	return {
+		code: linkMap(r.code, map, opts.sourcemap ?? "external", opts.path.replace(/\.[^./]+$/, ".js")),
+		map,
+		warnings: r.warnings
+	};
+}
+//#endregion
+export { bundle, chainPackages, inlineInputMap, loaderFor, nodeModulesPackages, npmPackages, resolveSpecifier, transpile };
+
+//# sourceMappingURL=index.mjs.map