rolldown-require 2.0.6 → 2.0.8

package/dist/index.mjs

@@ -1,1097 +1,845 @@
-// src/bundler.ts
-import path4 from "path";
-import { pathToFileURL as pathToFileURL2 } from "url";
+import { builtinModules, createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { rolldown } from "rolldown";
-
-// src/collect.ts
+import fs, { readFileSync } from "node:fs";
+import "node:child_process";
+import process from "node:process";
+import { createFilter } from "@rollup/pluginutils";
+import crypto from "node:crypto";
+import fsp from "node:fs/promises";
+import os from "node:os";
+import { promisify } from "node:util";
+import { Buffer as Buffer$1 } from "node:buffer";
+import { getTsconfig } from "get-tsconfig";
+//#region \0rolldown/runtime.js
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+//#endregion
+//#region src/collect.ts
+/**
+* 从 `fileName` 起遍历 chunk 图并收集所有引用的模块 id。
+* Rolldown 在 `inlineDynamicImports` 为 true 时会内联动态导入，
+* 因此只需要遍历已输出的 chunk。
+*/
 function collectReferencedModules(bundle, fileName, allModules, analyzedModules = /* @__PURE__ */ new Set()) {
-  if (analyzedModules.has(fileName)) {
-    return;
-  }
-  analyzedModules.add(fileName);
-  const chunk = bundle[fileName];
-  if (!chunk) {
-    return;
-  }
-  for (const mod of chunk.moduleIds) {
-    allModules.add(mod);
-  }
-  for (const imported of chunk.imports) {
-    collectReferencedModules(bundle, imported, allModules, analyzedModules);
-  }
-  for (const imported of chunk.dynamicImports) {
-    collectReferencedModules(bundle, imported, allModules, analyzedModules);
-  }
-}
-
-// src/externalize.ts
-import fs3 from "fs";
-import { createRequire as createRequire3 } from "module";
-import path3 from "path";
-import { fileURLToPath, pathToFileURL } from "url";
-
-// src/utils.ts
-import { exec } from "child_process";
-import fs2 from "fs";
-import { builtinModules, createRequire as createRequire2 } from "module";
-import path2 from "path";
-import process3 from "process";
-import { createFilter as _createFilter } from "@rollup/pluginutils";
-
-// src/constants.ts
-import { readFileSync } from "fs";
-var { version } = JSON.parse(
-  readFileSync(new URL("../package.json", import.meta.url)).toString()
-);
-
-// src/packages.ts
-import fs from "fs";
-import { createRequire } from "module";
-import path from "path";
-import process from "process";
-var pnp;
-if (process.versions.pnp) {
-  try {
-    pnp = createRequire(import.meta.url)("pnpapi");
-  } catch {
-  }
-}
+	if (analyzedModules.has(fileName)) return;
+	analyzedModules.add(fileName);
+	const chunk = bundle[fileName];
+	if (!chunk) return;
+	for (const mod of chunk.moduleIds) allModules.add(mod);
+	for (const imported of chunk.imports) collectReferencedModules(bundle, imported, allModules, analyzedModules);
+	for (const imported of chunk.dynamicImports) collectReferencedModules(bundle, imported, allModules, analyzedModules);
+}
+//#endregion
+//#region src/constants.ts
+const { version } = JSON.parse(readFileSync(new URL("../package.json", import.meta.url)).toString());
+if (process.versions.pnp) try {
+	createRequire(import.meta.url)("pnpapi");
+} catch {}
 function findNearestPackageData(basedir, packageCache) {
-  const originalBasedir = basedir;
-  while (basedir) {
-    if (packageCache) {
-      const cached = getFnpdCache(packageCache, basedir, originalBasedir);
-      if (cached) {
-        return cached;
-      }
-    }
-    const pkgPath = path.join(basedir, "package.json");
-    if (tryStatSync(pkgPath)?.isFile()) {
-      try {
-        const pkgData = loadPackageData(pkgPath);
-        if (packageCache) {
-          setFnpdCache(packageCache, pkgData, basedir, originalBasedir);
-        }
-        return pkgData;
-      } catch {
-      }
-    }
-    const nextBasedir = path.dirname(basedir);
-    if (nextBasedir === basedir) {
-      break;
-    }
-    basedir = nextBasedir;
-  }
-  return null;
+	const originalBasedir = basedir;
+	while (basedir) {
+		if (packageCache) {
+			const cached = getFnpdCache(packageCache, basedir, originalBasedir);
+			if (cached) return cached;
+		}
+		const pkgPath = path.join(basedir, "package.json");
+		if (tryStatSync(pkgPath)?.isFile()) try {
+			const pkgData = loadPackageData(pkgPath);
+			if (packageCache) setFnpdCache(packageCache, pkgData, basedir, originalBasedir);
+			return pkgData;
+		} catch {}
+		const nextBasedir = path.dirname(basedir);
+		if (nextBasedir === basedir) break;
+		basedir = nextBasedir;
+	}
+	return null;
 }
 function loadPackageData(pkgPath) {
-  const data = JSON.parse(stripBomTag(fs.readFileSync(pkgPath, "utf-8")));
-  const pkgDir = normalizePath(path.dirname(pkgPath));
-  const { sideEffects } = data;
-  let hasSideEffects;
-  if (typeof sideEffects === "boolean") {
-    hasSideEffects = () => sideEffects;
-  } else if (Array.isArray(sideEffects)) {
-    if (sideEffects.length <= 0) {
-      hasSideEffects = () => false;
-    } else {
-      const finalPackageSideEffects = sideEffects.map((sideEffect) => {
-        if (sideEffect.includes("/")) {
-          return sideEffect;
-        }
-        return `**/${sideEffect}`;
-      });
-      hasSideEffects = createFilter(finalPackageSideEffects, null, {
-        resolve: pkgDir
-      });
-    }
-  } else {
-    hasSideEffects = () => null;
-  }
-  const resolvedCache = {};
-  const pkg = {
-    dir: pkgDir,
-    data,
-    hasSideEffects,
-    setResolvedCache(key, entry, options) {
-      resolvedCache[getResolveCacheKey(key, options)] = entry;
-    },
-    getResolvedCache(key, options) {
-      return resolvedCache[getResolveCacheKey(key, options)];
-    }
-  };
-  return pkg;
+	const data = JSON.parse(stripBomTag(fs.readFileSync(pkgPath, "utf-8")));
+	const pkgDir = normalizePath(path.dirname(pkgPath));
+	const { sideEffects } = data;
+	let hasSideEffects;
+	if (typeof sideEffects === "boolean") hasSideEffects = () => sideEffects;
+	else if (Array.isArray(sideEffects)) if (sideEffects.length <= 0) hasSideEffects = () => false;
+	else hasSideEffects = createFilter$1(sideEffects.map((sideEffect) => {
+		if (sideEffect.includes("/")) return sideEffect;
+		return `**/${sideEffect}`;
+	}), null, { resolve: pkgDir });
+	else hasSideEffects = () => null;
+	const resolvedCache = {};
+	return {
+		dir: pkgDir,
+		data,
+		hasSideEffects,
+		setResolvedCache(key, entry, options) {
+			resolvedCache[getResolveCacheKey(key, options)] = entry;
+		},
+		getResolvedCache(key, options) {
+			return resolvedCache[getResolveCacheKey(key, options)];
+		}
+	};
 }
 function getResolveCacheKey(key, options) {
-  return [
-    key,
-    options.isRequire ? "1" : "0",
-    options.conditions.join("_"),
-    options.extensions.join("_"),
-    options.mainFields.join("_")
-  ].join("|");
+	return [
+		key,
+		options.isRequire ? "1" : "0",
+		options.conditions.join("_"),
+		options.extensions.join("_"),
+		options.mainFields.join("_")
+	].join("|");
 }
 function findNearestNodeModules(basedir) {
-  while (basedir) {
-    const pkgPath = path.join(basedir, "node_modules");
-    if (tryStatSync(pkgPath)?.isDirectory()) {
-      return pkgPath;
-    }
-    const nextBasedir = path.dirname(basedir);
-    if (nextBasedir === basedir) {
-      break;
-    }
-    basedir = nextBasedir;
-  }
-  return null;
-}
+	while (basedir) {
+		const pkgPath = path.join(basedir, "node_modules");
+		if (tryStatSync(pkgPath)?.isDirectory()) return pkgPath;
+		const nextBasedir = path.dirname(basedir);
+		if (nextBasedir === basedir) break;
+		basedir = nextBasedir;
+	}
+	return null;
+}
+/**
+* 根据 `basedir` 获取缓存的 `findNearestPackageData`。
+* 当命中缓存且已遍历 `basedir` 与 `originalBasedir` 之间的路径时，
+* 会把中间目录也写入缓存。
+*
+* 这样共享的 `basedir` 只需要读一次文件系统。
+*/
 function getFnpdCache(packageCache, basedir, originalBasedir) {
-  const cacheKey = getFnpdCacheKey(basedir);
-  const pkgData = packageCache.get(cacheKey);
-  if (pkgData) {
-    traverseBetweenDirs(originalBasedir, basedir, (dir) => {
-      packageCache.set(getFnpdCacheKey(dir), pkgData);
-    });
-    return pkgData;
-  }
+	const cacheKey = getFnpdCacheKey(basedir);
+	const pkgData = packageCache.get(cacheKey);
+	if (pkgData) {
+		traverseBetweenDirs(originalBasedir, basedir, (dir) => {
+			packageCache.set(getFnpdCacheKey(dir), pkgData);
+		});
+		return pkgData;
+	}
 }
 function setFnpdCache(packageCache, pkgData, basedir, originalBasedir) {
-  packageCache.set(getFnpdCacheKey(basedir), pkgData);
-  traverseBetweenDirs(originalBasedir, basedir, (dir) => {
-    packageCache.set(getFnpdCacheKey(dir), pkgData);
-  });
+	packageCache.set(getFnpdCacheKey(basedir), pkgData);
+	traverseBetweenDirs(originalBasedir, basedir, (dir) => {
+		packageCache.set(getFnpdCacheKey(dir), pkgData);
+	});
 }
 function getFnpdCacheKey(basedir) {
-  return `fnpd_${basedir}`;
+	return `fnpd_${basedir}`;
 }
+/**
+* 在 `longerDir`（含）与 `shorterDir`（不含）之间遍历路径并执行回调。
+* @param longerDir 较长路径，如 `/User/foo/bar/baz`
+* @param shorterDir 较短路径，如 `/User/foo`
+*/
 function traverseBetweenDirs(longerDir, shorterDir, cb) {
-  while (longerDir !== shorterDir) {
-    cb(longerDir);
-    longerDir = path.dirname(longerDir);
-  }
-}
-
-// src/sharedUtils.ts
-import process2 from "process";
-var isWindows = typeof process2 !== "undefined" && process2.platform === "win32";
-var windowsSlashRE = /\\/g;
+	while (longerDir !== shorterDir) {
+		cb(longerDir);
+		longerDir = path.dirname(longerDir);
+	}
+}
+//#endregion
+//#region src/sharedUtils.ts
+const isWindows = typeof process !== "undefined" && process.platform === "win32";
+const windowsSlashRE = /\\/g;
 function slash(p) {
-  return p.replace(windowsSlashRE, "/");
-}
-
-// src/utils.ts
-var createFilter = _createFilter;
-var NODE_BUILTIN_NAMESPACE = "node:";
-var NPM_BUILTIN_NAMESPACE = "npm:";
-var BUN_BUILTIN_NAMESPACE = "bun:";
-var nodeBuiltins = builtinModules.filter((id) => !id.includes(":"));
-var isBuiltinCache = /* @__PURE__ */ new WeakMap();
+	return p.replace(windowsSlashRE, "/");
+}
+//#endregion
+//#region src/utils.ts
+const MJS_MTS_EXT_RE = /\.m[jt]s$/;
+const CJS_CTS_EXT_RE = /\.c[jt]s$/;
+const createFilter$1 = createFilter;
+const NODE_BUILTIN_NAMESPACE = "node:";
+const NPM_BUILTIN_NAMESPACE = "npm:";
+const BUN_BUILTIN_NAMESPACE = "bun:";
+const nodeBuiltins = builtinModules.filter((id) => !id.includes(":"));
+const isBuiltinCache = /* @__PURE__ */ new WeakMap();
 function isBuiltin(builtins, id) {
-  let isBuiltin2 = isBuiltinCache.get(builtins);
-  if (!isBuiltin2) {
-    isBuiltin2 = createIsBuiltin(builtins);
-    isBuiltinCache.set(builtins, isBuiltin2);
-  }
-  return isBuiltin2(id);
+	let isBuiltin = isBuiltinCache.get(builtins);
+	if (!isBuiltin) {
+		isBuiltin = createIsBuiltin(builtins);
+		isBuiltinCache.set(builtins, isBuiltin);
+	}
+	return isBuiltin(id);
 }
 function createIsBuiltin(builtins) {
-  const plainBuiltinsSet = new Set(
-    builtins.filter((builtin) => typeof builtin === "string")
-  );
-  const regexBuiltins = builtins.filter(
-    (builtin) => typeof builtin !== "string"
-  );
-  return (id) => plainBuiltinsSet.has(id) || regexBuiltins.some((regexp) => regexp.test(id));
-}
-var nodeLikeBuiltins = [
-  ...nodeBuiltins,
-  new RegExp(`^${NODE_BUILTIN_NAMESPACE}`),
-  new RegExp(`^${NPM_BUILTIN_NAMESPACE}`),
-  new RegExp(`^${BUN_BUILTIN_NAMESPACE}`)
+	const plainBuiltinsSet = new Set(builtins.filter((builtin) => typeof builtin === "string"));
+	const regexBuiltins = builtins.filter((builtin) => typeof builtin !== "string");
+	return (id) => plainBuiltinsSet.has(id) || regexBuiltins.some((regexp) => regexp.test(id));
+}
+const nodeLikeBuiltins = [
+	...nodeBuiltins,
+	new RegExp(`^${NODE_BUILTIN_NAMESPACE}`),
+	new RegExp(`^${NPM_BUILTIN_NAMESPACE}`),
+	new RegExp(`^${BUN_BUILTIN_NAMESPACE}`)
 ];
 function isNodeLikeBuiltin(id) {
-  return isBuiltin(nodeLikeBuiltins, id);
+	return isBuiltin(nodeLikeBuiltins, id);
 }
 function isNodeBuiltin(id) {
-  if (id.startsWith(NODE_BUILTIN_NAMESPACE)) {
-    return true;
-  }
-  return nodeBuiltins.includes(id);
+	if (id.startsWith(NODE_BUILTIN_NAMESPACE)) return true;
+	return nodeBuiltins.includes(id);
 }
 function normalizePath(id) {
-  return path2.posix.normalize(isWindows ? slash(id) : id);
+	return path.posix.normalize(isWindows ? slash(id) : id);
 }
 function tryStatSync(file) {
-  try {
-    return fs2.statSync(file, { throwIfNoEntry: false });
-  } catch {
-  }
+	try {
+		return fs.statSync(file, { throwIfNoEntry: false });
+	} catch {}
 }
 function isFilePathESM(filePath, packageCache) {
-  if (/\.m[jt]s$/.test(filePath)) {
-    return true;
-  } else if (/\.c[jt]s$/.test(filePath)) {
-    return false;
-  } else {
-    try {
-      const pkg = findNearestPackageData(path2.dirname(filePath), packageCache);
-      return pkg?.data.type === "module";
-    } catch {
-      return false;
-    }
-  }
-}
-var currentSafeRealpathSync = isWindows ? windowsSafeRealPathSync : fs2.realpathSync.native;
-var windowsNetworkMap = /* @__PURE__ */ new Map();
-function windowsMappedRealpathSync(path9) {
-  const realPath = fs2.realpathSync.native(path9);
-  if (realPath.startsWith("\\\\")) {
-    for (const [network, volume] of windowsNetworkMap) {
-      if (realPath.startsWith(network)) {
-        return realPath.replace(network, volume);
-      }
-    }
-  }
-  return realPath;
-}
-var parseNetUseRE = /^\w* +(\w:) +([^ ]+)\s/;
-var firstSafeRealPathSyncRun = false;
-function windowsSafeRealPathSync(path9) {
-  if (!firstSafeRealPathSyncRun) {
-    optimizeSafeRealPathSync();
-    firstSafeRealPathSyncRun = true;
-  }
-  return fs2.realpathSync(path9);
-}
-function optimizeSafeRealPathSync() {
-  const nodeVersion = process3.versions.node.split(".").map(Number);
-  if (nodeVersion[0] < 18 || nodeVersion[0] === 18 && nodeVersion[1] < 10) {
-    currentSafeRealpathSync = fs2.realpathSync;
-    return;
-  }
-  try {
-    fs2.realpathSync.native(path2.resolve("./"));
-  } catch (error) {
-    if (error.message.includes("EISDIR: illegal operation on a directory")) {
-      currentSafeRealpathSync = fs2.realpathSync;
-      return;
-    }
-  }
-  exec("net use", (error, stdout) => {
-    if (error) {
-      return;
-    }
-    const lines = stdout.split("\n");
-    for (const line of lines) {
-      const m = parseNetUseRE.exec(line);
-      if (m) {
-        windowsNetworkMap.set(m[2], m[1]);
-      }
-    }
-    currentSafeRealpathSync = windowsNetworkMap.size === 0 ? fs2.realpathSync.native : windowsMappedRealpathSync;
-  });
-}
+	if (MJS_MTS_EXT_RE.test(filePath)) return true;
+	else if (CJS_CTS_EXT_RE.test(filePath)) return false;
+	else try {
+		return findNearestPackageData(path.dirname(filePath), packageCache)?.data.type === "module";
+	} catch {
+		return false;
+	}
+}
+isWindows || fs.realpathSync.native;
 function stripBomTag(content) {
-  if (content.charCodeAt(0) === 65279) {
-    return content.slice(1);
-  }
-  return content;
+	if (content.charCodeAt(0) === 65279) return content.slice(1);
+	return content;
 }
-var dynamicImport = async (id, { format }) => {
-  const fn = format === "esm" ? (file) => import(file) : true ? createRequire2(import.meta.url) : __require;
-  return fn(id);
+const dynamicImport = async (id, { format }) => {
+	return (format === "esm" ? (file) => import(file) : TSUP_FORMAT === "esm" ? createRequire(import.meta.url) : __require)(id);
 };
-
-// src/externalize.ts
-function createExternalizeDepsPlugin({
-  entryFile,
-  isESM
-}) {
-  const entryDir = path3.dirname(entryFile);
-  const externalizeCache = /* @__PURE__ */ new Map();
-  const entryResolveCache = /* @__PURE__ */ new Map();
-  return {
-    name: "externalize-deps",
-    resolveId: {
-      filter: { id: /^[^.#].*/ },
-      async handler(id, importer, options) {
-        const { kind } = options;
-        if (!importer || path3.isAbsolute(id) || isNodeBuiltin(id)) {
-          return;
-        }
-        if (isNodeLikeBuiltin(id)) {
-          return { id, external: true };
-        }
-        const cacheKey = `${importer}::${kind}::${id}`;
-        const cached = externalizeCache.get(cacheKey);
-        if (cached !== void 0) {
-          return cached ?? void 0;
-        }
-        const isImport = isESM || kind === "dynamic-import";
-        const resolved = await resolveWithRolldown(this, id, importer, kind);
-        if (!resolved?.id) {
-          externalizeCache.set(cacheKey, null);
-          return;
-        }
-        if (resolved.external) {
-          const external = resolved.external === "absolute" ? "absolute" : true;
-          const result2 = {
-            id: resolved.id,
-            external
-          };
-          externalizeCache.set(cacheKey, result2);
-          return result2;
-        }
-        const { cleanId, query } = splitIdAndQuery(resolved.id);
-        const resolvedPath = toFilePath(cleanId);
-        if (!resolvedPath) {
-          externalizeCache.set(cacheKey, null);
-          return;
-        }
-        if (!path3.isAbsolute(resolvedPath)) {
-          externalizeCache.set(cacheKey, null);
-          return;
-        }
-        if (resolvedPath.endsWith(".json")) {
-          const idWithQuery = resolvedPath + query;
-          externalizeCache.set(cacheKey, idWithQuery);
-          return idWithQuery;
-        }
-        const shouldExternalize = shouldExternalizeBareImport(
-          id,
-          importer,
-          entryDir,
-          resolvedPath,
-          entryResolveCache
-        );
-        let idOut = resolvedPath + query;
-        if (isImport && shouldExternalize) {
-          idOut = pathToFileURL(resolvedPath).href + query;
-        }
-        const result = { id: idOut, external: shouldExternalize };
-        externalizeCache.set(cacheKey, result);
-        return result;
-      }
-    }
-  };
+//#endregion
+//#region src/externalize.ts
+const NON_RELATIVE_NON_HASH_RE = /^[^.#].*/;
+function createExternalizeDepsPlugin({ entryFile, isESM }) {
+	const entryDir = path.dirname(entryFile);
+	const externalizeCache = /* @__PURE__ */ new Map();
+	const entryResolveCache = /* @__PURE__ */ new Map();
+	return {
+		name: "externalize-deps",
+		resolveId: {
+			filter: { id: NON_RELATIVE_NON_HASH_RE },
+			async handler(id, importer, options) {
+				const { kind } = options;
+				if (!importer || path.isAbsolute(id) || isNodeBuiltin(id)) return;
+				if (isNodeLikeBuiltin(id)) return {
+					id,
+					external: true
+				};
+				const cacheKey = `${importer}::${kind}::${id}`;
+				const cached = externalizeCache.get(cacheKey);
+				if (cached !== void 0) return cached ?? void 0;
+				const isImport = isESM || kind === "dynamic-import";
+				const resolved = await resolveWithRolldown(this, id, importer, kind);
+				if (!resolved?.id) {
+					externalizeCache.set(cacheKey, null);
+					return;
+				}
+				if (resolved.external) {
+					const external = resolved.external === "absolute" ? "absolute" : true;
+					const result = {
+						id: resolved.id,
+						external
+					};
+					externalizeCache.set(cacheKey, result);
+					return result;
+				}
+				const { cleanId, query } = splitIdAndQuery(resolved.id);
+				const resolvedPath = toFilePath(cleanId);
+				if (!resolvedPath) {
+					externalizeCache.set(cacheKey, null);
+					return;
+				}
+				if (!path.isAbsolute(resolvedPath)) {
+					externalizeCache.set(cacheKey, null);
+					return;
+				}
+				if (resolvedPath.endsWith(".json")) {
+					const idWithQuery = resolvedPath + query;
+					externalizeCache.set(cacheKey, idWithQuery);
+					return idWithQuery;
+				}
+				const shouldExternalize = shouldExternalizeBareImport(id, importer, entryDir, resolvedPath, entryResolveCache);
+				let idOut = resolvedPath + query;
+				if (isImport && shouldExternalize) idOut = pathToFileURL(resolvedPath).href + query;
+				const result = {
+					id: idOut,
+					external: shouldExternalize
+				};
+				externalizeCache.set(cacheKey, result);
+				return result;
+			}
+		}
+	};
 }
 function shouldExternalizeBareImport(specifier, importer, entryDir, resolvedPath, canResolveCache) {
-  if (!specifier || specifier.startsWith(".") || path3.isAbsolute(specifier)) {
-    return false;
-  }
-  if (isNodeLikeBuiltin(specifier)) {
-    return true;
-  }
-  const importerPath = normalizeImporterPath(importer, entryDir);
-  const resolvedFromImporter = resolvedPath ?? resolveSpecifierFromImporter(specifier, importerPath);
-  if (resolvedFromImporter) {
-    const containingNodeModules = findContainingNodeModules(resolvedFromImporter);
-    if (containingNodeModules) {
-      const ownerDir = path3.dirname(containingNodeModules);
-      const ownerInsideEntry = isPathWithinDirectory(entryDir, ownerDir);
-      const entryInsideOwner = isPathWithinDirectory(ownerDir, entryDir);
-      if (ownerInsideEntry && !entryInsideOwner) {
-        return false;
-      }
-    }
-  }
-  if (!canResolveFromEntry(specifier, entryDir, canResolveCache)) {
-    return false;
-  }
-  return true;
+	if (!specifier || specifier.startsWith(".") || path.isAbsolute(specifier)) return false;
+	if (isNodeLikeBuiltin(specifier)) return true;
+	const importerPath = normalizeImporterPath(importer, entryDir);
+	const resolvedFromImporter = resolvedPath ?? resolveSpecifierFromImporter(specifier, importerPath);
+	if (resolvedFromImporter) {
+		const containingNodeModules = findContainingNodeModules(resolvedFromImporter);
+		if (containingNodeModules) {
+			const ownerDir = path.dirname(containingNodeModules);
+			const ownerInsideEntry = isPathWithinDirectory(entryDir, ownerDir);
+			const entryInsideOwner = isPathWithinDirectory(ownerDir, entryDir);
+			if (ownerInsideEntry && !entryInsideOwner) return false;
+		}
+	}
+	if (!canResolveFromEntry(specifier, entryDir, canResolveCache)) return false;
+	return true;
 }
 function normalizeImporterPath(importer, fallback) {
-  if (!importer || importer.startsWith("\0")) {
-    return fallback;
-  }
-  const [withoutQuery] = importer.split("?");
-  return withoutQuery || fallback;
+	if (!importer || importer.startsWith("\0")) return fallback;
+	const [withoutQuery] = importer.split("?");
+	return withoutQuery || fallback;
 }
 function findContainingNodeModules(filePath) {
-  let current = path3.dirname(filePath);
-  const { root } = path3.parse(current);
-  while (true) {
-    if (path3.basename(current) === "node_modules") {
-      return current;
-    }
-    if (current === root) {
-      break;
-    }
-    current = path3.dirname(current);
-  }
+	let current = path.dirname(filePath);
+	const { root } = path.parse(current);
+	while (true) {
+		if (path.basename(current) === "node_modules") return current;
+		if (current === root) break;
+		current = path.dirname(current);
+	}
 }
 function isPathWithinDirectory(parent, child) {
-  const relative = path3.relative(parent, child);
-  return relative === "" || !relative.startsWith("..") && !path3.isAbsolute(relative);
+	const relative = path.relative(parent, child);
+	return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
 }
 function getPackageName(specifier) {
-  if (!specifier) {
-    return void 0;
-  }
-  if (specifier.startsWith("@")) {
-    const segments = specifier.split("/");
-    if (segments.length >= 2) {
-      return `${segments[0]}/${segments[1]}`;
-    }
-    return void 0;
-  }
-  const [name] = specifier.split("/");
-  return name || void 0;
+	if (!specifier) return;
+	if (specifier.startsWith("@")) {
+		const segments = specifier.split("/");
+		if (segments.length >= 2) return `${segments[0]}/${segments[1]}`;
+		return;
+	}
+	const [name] = specifier.split("/");
+	return name || void 0;
 }
 function canResolveFromEntry(specifier, entryDir, cache) {
-  const packageName = getPackageName(specifier);
-  if (!packageName) {
-    return false;
-  }
-  if (cache?.has(packageName)) {
-    return cache.get(packageName);
-  }
-  let currentDir = entryDir;
-  while (true) {
-    if (fs3.existsSync(path3.join(currentDir, "node_modules", packageName))) {
-      cache?.set(packageName, true);
-      return true;
-    }
-    const parentDir = path3.dirname(currentDir);
-    if (parentDir === currentDir) {
-      break;
-    }
-    currentDir = parentDir;
-  }
-  cache?.set(packageName, false);
-  return false;
+	const packageName = getPackageName(specifier);
+	if (!packageName) return false;
+	if (cache?.has(packageName)) return cache.get(packageName);
+	let currentDir = entryDir;
+	while (true) {
+		if (fs.existsSync(path.join(currentDir, "node_modules", packageName))) {
+			cache?.set(packageName, true);
+			return true;
+		}
+		const parentDir = path.dirname(currentDir);
+		if (parentDir === currentDir) break;
+		currentDir = parentDir;
+	}
+	cache?.set(packageName, false);
+	return false;
 }
 function resolveWithRolldown(ctx, id, importer, kind) {
-  return ctx.resolve(id, importer, { kind, skipSelf: true });
+	return ctx.resolve(id, importer, {
+		kind,
+		skipSelf: true
+	});
 }
 function splitIdAndQuery(id) {
-  const [cleanId, rawQuery] = id.split("?");
-  return { cleanId, query: rawQuery ? `?${rawQuery}` : "" };
+	const [cleanId, rawQuery] = id.split("?");
+	return {
+		cleanId,
+		query: rawQuery ? `?${rawQuery}` : ""
+	};
 }
 function toFilePath(id) {
-  if (!id) {
-    return null;
-  }
-  if (id.startsWith("file://")) {
-    return fileURLToPath(id);
-  }
-  return id;
+	if (!id) return null;
+	if (id.startsWith("file://")) return fileURLToPath(id);
+	return id;
 }
 function resolveSpecifierFromImporter(specifier, importerPath) {
-  try {
-    return createRequire3(importerPath).resolve(specifier);
-  } catch {
-    return void 0;
-  }
-}
-
-// src/module-sync.ts
-var cachedModuleSyncCondition;
-var moduleSyncConditionPromise;
+	try {
+		return createRequire(importerPath).resolve(specifier);
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/module-sync.ts
+let cachedModuleSyncCondition;
+let moduleSyncConditionPromise;
 async function getModuleSyncConditionEnabled() {
-  if (cachedModuleSyncCondition !== void 0) {
-    return cachedModuleSyncCondition;
-  }
-  if (!moduleSyncConditionPromise) {
-    moduleSyncConditionPromise = import(
-      // @ts-ignore
-      "#module-sync-enabled"
-    ).then((mod) => Boolean(mod?.default)).catch(() => false).then((result) => {
-      cachedModuleSyncCondition = result;
-      return result;
-    }).finally(() => {
-      moduleSyncConditionPromise = void 0;
-    });
-  }
-  return moduleSyncConditionPromise;
-}
-
-// src/bundler.ts
+	if (cachedModuleSyncCondition !== void 0) return cachedModuleSyncCondition;
+	if (!moduleSyncConditionPromise) moduleSyncConditionPromise = import("#module-sync-enabled").then((mod) => Boolean(mod?.default)).catch(() => false).then((result) => {
+		cachedModuleSyncCondition = result;
+		return result;
+	}).finally(() => {
+		moduleSyncConditionPromise = void 0;
+	});
+	return moduleSyncConditionPromise;
+}
+//#endregion
+//#region src/bundler.ts
+const JS_TS_EXT_RE = /\.[cm]?[jt]s$/;
 async function bundleFile(fileName, options) {
-  const { isESM } = options;
-  const dirnameVarName = "__vite_injected_original_dirname";
-  const filenameVarName = "__vite_injected_original_filename";
-  const importMetaUrlVarName = "__vite_injected_original_import_meta_url";
-  const rolldownInputOptions = options?.rolldownOptions?.input || {};
-  const {
-    transform: userTransform,
-    resolve: userResolve,
-    ...restRolldownInputOptions
-  } = rolldownInputOptions;
-  const transformDefine = {
-    ...userTransform?.define ?? {},
-    "__dirname": dirnameVarName,
-    "__filename": filenameVarName,
-    "import.meta.url": importMetaUrlVarName,
-    "import.meta.dirname": dirnameVarName,
-    "import.meta.filename": filenameVarName
-  };
-  const transformOptions = {
-    ...userTransform ?? {},
-    define: transformDefine
-  };
-  const moduleSyncEnabled = await getModuleSyncConditionEnabled();
-  const userConditionNames = userResolve?.conditionNames;
-  const conditionNames = [...userConditionNames ?? []];
-  if (moduleSyncEnabled && !conditionNames.includes("module-sync")) {
-    conditionNames.push("module-sync");
-  }
-  const resolveOptions = {
-    ...userResolve ?? {},
-    mainFields: ["main"],
-    ...typeof options.tsconfig === "string" ? { tsconfigFilename: options.tsconfig } : {},
-    ...conditionNames.length ? { conditionNames } : {}
-  };
-  const originalConsoleWarn = console.warn;
-  console.warn = (...args) => {
-    const message = typeof args[0] === "string" ? args[0] : "";
-    if (message.includes("resolve.tsconfigFilename") || message.includes("Invalid input options") || message.includes('top-level "define" option is deprecated')) {
-      return;
-    }
-    originalConsoleWarn(...args);
-  };
-  let bundle;
-  try {
-    bundle = await rolldown({
-      ...restRolldownInputOptions,
-      input: fileName,
-      platform: "node",
-      ...options.tsconfig !== void 0 ? { tsconfig: options.tsconfig } : {},
-      resolve: resolveOptions,
-      // @ts-ignore
-      define: transformDefine,
-      transform: transformOptions,
-      // disable treeshake to include files that is not sideeffectful to `moduleIds`
-      treeshake: false,
-      plugins: [
-        createExternalizeDepsPlugin({
-          entryFile: fileName,
-          isESM
-        }),
-        createFileScopeVariablesPlugin({
-          dirnameVarName,
-          filenameVarName,
-          importMetaUrlVarName
-        })
-      ],
-      external: options.external
-    });
-  } finally {
-    console.warn = originalConsoleWarn;
-  }
-  if (!bundle) {
-    throw new Error("Failed to initialize bundler");
-  }
-  const rolldownOutputOptions = options?.rolldownOptions?.output || {};
-  const { codeSplitting: _codeSplitting, ...normalizedOutputOptions } = rolldownOutputOptions;
-  const result = await bundle.generate({
-    ...normalizedOutputOptions,
-    format: options.format,
-    sourcemap: resolveSourcemapOutput(normalizedOutputOptions.sourcemap, options.sourcemap),
-    codeSplitting: false
-  });
-  await bundle.close();
-  const entryChunk = result.output.find(
-    (chunk) => chunk.type === "chunk" && chunk.isEntry
-  );
-  const bundleChunks = Object.fromEntries(
-    result.output.flatMap((c) => c.type === "chunk" ? [[c.fileName, c]] : [])
-  );
-  const allModules = /* @__PURE__ */ new Set();
-  collectReferencedModules(bundleChunks, entryChunk.fileName, allModules);
-  allModules.delete(fileName);
-  return {
-    code: entryChunk.code,
-    dependencies: [...allModules]
-  };
+	const { isESM } = options;
+	const dirnameVarName = "__vite_injected_original_dirname";
+	const filenameVarName = "__vite_injected_original_filename";
+	const importMetaUrlVarName = "__vite_injected_original_import_meta_url";
+	const { transform: userTransform, resolve: userResolve, ...restRolldownInputOptions } = options?.rolldownOptions?.input || {};
+	const transformDefine = {
+		...userTransform?.define ?? {},
+		"__dirname": dirnameVarName,
+		"__filename": filenameVarName,
+		"import.meta.url": importMetaUrlVarName,
+		"import.meta.dirname": dirnameVarName,
+		"import.meta.filename": filenameVarName
+	};
+	const transformOptions = {
+		...userTransform ?? {},
+		define: transformDefine
+	};
+	const moduleSyncEnabled = await getModuleSyncConditionEnabled();
+	const conditionNames = [...userResolve?.conditionNames ?? []];
+	if (moduleSyncEnabled && !conditionNames.includes("module-sync")) conditionNames.push("module-sync");
+	const resolveOptions = {
+		...userResolve ?? {},
+		mainFields: ["main"],
+		...typeof options.tsconfig === "string" ? { tsconfigFilename: options.tsconfig } : {},
+		...conditionNames.length ? { conditionNames } : {}
+	};
+	const originalConsoleWarn = console.warn;
+	console.warn = (...args) => {
+		const message = typeof args[0] === "string" ? args[0] : "";
+		if (message.includes("resolve.tsconfigFilename") || message.includes("Invalid input options") || message.includes("top-level \"define\" option is deprecated")) return;
+		originalConsoleWarn(...args);
+	};
+	let bundle;
+	try {
+		bundle = await rolldown({
+			...restRolldownInputOptions,
+			input: fileName,
+			platform: "node",
+			...options.tsconfig !== void 0 ? { tsconfig: options.tsconfig } : {},
+			resolve: resolveOptions,
+			define: transformDefine,
+			transform: transformOptions,
+			treeshake: false,
+			plugins: [createExternalizeDepsPlugin({
+				entryFile: fileName,
+				isESM
+			}), createFileScopeVariablesPlugin({
+				dirnameVarName,
+				filenameVarName,
+				importMetaUrlVarName
+			})],
+			external: options.external
+		});
+	} finally {
+		console.warn = originalConsoleWarn;
+	}
+	if (!bundle) throw new Error("Failed to initialize bundler");
+	const { codeSplitting: _codeSplitting, ...normalizedOutputOptions } = options?.rolldownOptions?.output || {};
+	const result = await bundle.generate({
+		...normalizedOutputOptions,
+		format: options.format,
+		sourcemap: resolveSourcemapOutput(normalizedOutputOptions.sourcemap, options.sourcemap),
+		codeSplitting: false
+	});
+	await bundle.close();
+	const entryChunk = result.output.find((chunk) => chunk.type === "chunk" && chunk.isEntry);
+	const bundleChunks = Object.fromEntries(result.output.flatMap((c) => c.type === "chunk" ? [[c.fileName, c]] : []));
+	const allModules = /* @__PURE__ */ new Set();
+	collectReferencedModules(bundleChunks, entryChunk.fileName, allModules);
+	allModules.delete(fileName);
+	return {
+		code: entryChunk.code,
+		dependencies: [...allModules]
+	};
 }
 function resolveSourcemapOutput(outputSourcemap, requested) {
-  if (outputSourcemap !== void 0) {
-    return outputSourcemap;
-  }
-  if (requested === true) {
-    return "inline";
-  }
-  return requested ?? false;
-}
-function createFileScopeVariablesPlugin({
-  dirnameVarName,
-  filenameVarName,
-  importMetaUrlVarName
-}) {
-  return {
-    name: "inject-file-scope-variables",
-    transform: {
-      filter: { id: /\.[cm]?[jt]s$/ },
-      async handler(code, id) {
-        const injectValues = `const ${dirnameVarName} = ${JSON.stringify(path4.dirname(id))};const ${filenameVarName} = ${JSON.stringify(id)};const ${importMetaUrlVarName} = ${JSON.stringify(
-          pathToFileURL2(id).href
-        )};`;
-        return { code: injectValues + code, map: null };
-      }
-    }
-  };
-}
-
-// src/cache.ts
-import crypto from "crypto";
-import fs4 from "fs";
-import fsp from "fs/promises";
-import { createRequire as createRequire4 } from "module";
-import os from "os";
-import path5 from "path";
-import process4 from "process";
-import { pathToFileURL as pathToFileURL3 } from "url";
-var _require = createRequire4(import.meta.url);
-var memoryCache = /* @__PURE__ */ new Map();
+	if (outputSourcemap !== void 0) return outputSourcemap;
+	if (requested === true) return "inline";
+	return requested ?? false;
+}
+function createFileScopeVariablesPlugin({ dirnameVarName, filenameVarName, importMetaUrlVarName }) {
+	return {
+		name: "inject-file-scope-variables",
+		transform: {
+			filter: { id: JS_TS_EXT_RE },
+			async handler(code, id) {
+				return {
+					code: `const ${dirnameVarName} = ${JSON.stringify(path.dirname(id))};const ${filenameVarName} = ${JSON.stringify(id)};const ${importMetaUrlVarName} = ${JSON.stringify(pathToFileURL(id).href)};` + code,
+					map: null
+				};
+			}
+		}
+	};
+}
+//#endregion
+//#region src/cache.ts
+const _require$1 = createRequire(import.meta.url);
+const memoryCache = /* @__PURE__ */ new Map();
 function resolveCacheOptions(fileName, options) {
-  const cacheOpt = options.cache;
-  const enabled = cacheOpt === true || typeof cacheOpt === "object" && cacheOpt.enabled !== false;
-  if (!enabled) {
-    return {
-      enabled: false,
-      key: "",
-      dir: "",
-      reset: false,
-      entryPath: fileName,
-      memory: false,
-      onEvent: void 0
-    };
-  }
-  const dir = typeof cacheOpt === "object" && cacheOpt.dir ? cacheOpt.dir : resolveDefaultCacheDir(fileName);
-  const reset = typeof cacheOpt === "object" && cacheOpt.reset === true;
-  const onEvent = typeof cacheOpt === "object" ? cacheOpt.onEvent : void 0;
-  const memory = !(typeof cacheOpt === "object" && cacheOpt.memory === false);
-  const stat = tryStatSync(fileName);
-  if (!stat) {
-    onEvent?.({ type: "skip-invalid", key: "", reason: "missing-entry" });
-    return {
-      enabled: false,
-      key: "",
-      dir,
-      reset,
-      entryPath: fileName,
-      memory,
-      onEvent
-    };
-  }
-  const hash = crypto.createHash("sha1");
-  hash.update(
-    JSON.stringify({
-      entry: path5.resolve(fileName),
-      mtimeMs: stat.mtimeMs,
-      size: stat.size,
-      format: options.format,
-      isESM: options.isESM,
-      tsconfig: options.tsconfig ?? "auto",
-      node: process4.versions.node,
-      rolldown: hashRolldownOptions(options.rolldownOptions)
-    })
-  );
-  return {
-    enabled: true,
-    key: hash.digest("hex"),
-    dir,
-    reset,
-    entryPath: path5.resolve(fileName),
-    memory,
-    onEvent
-  };
+	const cacheOpt = options.cache;
+	if (!(cacheOpt === true || typeof cacheOpt === "object" && cacheOpt.enabled !== false)) return {
+		enabled: false,
+		key: "",
+		dir: "",
+		reset: false,
+		entryPath: fileName,
+		memory: false,
+		onEvent: void 0
+	};
+	const dir = typeof cacheOpt === "object" && cacheOpt.dir ? cacheOpt.dir : resolveDefaultCacheDir(fileName);
+	const reset = typeof cacheOpt === "object" && cacheOpt.reset === true;
+	const onEvent = typeof cacheOpt === "object" ? cacheOpt.onEvent : void 0;
+	const memory = !(typeof cacheOpt === "object" && cacheOpt.memory === false);
+	const stat = tryStatSync(fileName);
+	if (!stat) {
+		onEvent?.({
+			type: "skip-invalid",
+			key: "",
+			reason: "missing-entry"
+		});
+		return {
+			enabled: false,
+			key: "",
+			dir,
+			reset,
+			entryPath: fileName,
+			memory,
+			onEvent
+		};
+	}
+	const hash = crypto.createHash("sha1");
+	hash.update(JSON.stringify({
+		entry: path.resolve(fileName),
+		mtimeMs: stat.mtimeMs,
+		size: stat.size,
+		format: options.format,
+		isESM: options.isESM,
+		tsconfig: options.tsconfig ?? "auto",
+		node: process.versions.node,
+		rolldown: hashRolldownOptions(options.rolldownOptions)
+	}));
+	return {
+		enabled: true,
+		key: hash.digest("hex"),
+		dir,
+		reset,
+		entryPath: path.resolve(fileName),
+		memory,
+		onEvent
+	};
 }
 function resolveDefaultCacheDir(fileName) {
-  if (typeof process4.versions.deno !== "string") {
-    const nearest = findNearestNodeModules(path5.dirname(fileName));
-    if (nearest) {
-      return path5.resolve(nearest, ".rolldown-require-cache");
-    }
-  }
-  return path5.join(os.tmpdir(), "rolldown-require-cache");
+	if (typeof process.versions.deno !== "string") {
+		const nearest = findNearestNodeModules(path.dirname(fileName));
+		if (nearest) return path.resolve(nearest, ".rolldown-require-cache");
+	}
+	return path.join(os.tmpdir(), "rolldown-require-cache");
 }
 async function maybeReadCache(cache, options) {
-  const metaPath = path5.join(cache.dir, `${cache.key}.meta.json`);
-  const mem = cache.memory ? memoryCache.get(cache.key) : void 0;
-  if (mem?.meta) {
-    const valid2 = validateMeta(mem.meta, options);
-    if (valid2 === true) {
-      cache.onEvent?.({ type: "hit", key: cache.key, reason: "memory" });
-      return mem;
-    }
-    memoryCache.delete(cache.key);
-    cache.onEvent?.({ type: "skip-invalid", key: cache.key, reason: valid2 });
-  }
-  const meta = await readCacheMeta(metaPath);
-  if (!meta) {
-    return;
-  }
-  const valid = validateMeta(meta, options);
-  if (valid !== true) {
-    cache.onEvent?.({ type: "skip-invalid", key: cache.key, reason: valid });
-    return;
-  }
-  if (mem?.mod !== void 0 && cache.memory) {
-    const enriched = { mod: mem.mod, codePath: meta.codePath, meta };
-    memoryCache.set(cache.key, enriched);
-    cache.onEvent?.({ type: "hit", key: cache.key, reason: "memory" });
-    return enriched;
-  }
-  return { codePath: meta.codePath, meta };
+	const metaPath = path.join(cache.dir, `${cache.key}.meta.json`);
+	const mem = cache.memory ? memoryCache.get(cache.key) : void 0;
+	if (mem?.meta) {
+		const valid = validateMeta(mem.meta, options);
+		if (valid === true) {
+			cache.onEvent?.({
+				type: "hit",
+				key: cache.key,
+				reason: "memory"
+			});
+			return mem;
+		}
+		memoryCache.delete(cache.key);
+		cache.onEvent?.({
+			type: "skip-invalid",
+			key: cache.key,
+			reason: valid
+		});
+	}
+	const meta = await readCacheMeta(metaPath);
+	if (!meta) return;
+	const valid = validateMeta(meta, options);
+	if (valid !== true) {
+		cache.onEvent?.({
+			type: "skip-invalid",
+			key: cache.key,
+			reason: valid
+		});
+		return;
+	}
+	if (mem?.mod !== void 0 && cache.memory) {
+		const enriched = {
+			mod: mem.mod,
+			codePath: meta.codePath,
+			meta
+		};
+		memoryCache.set(cache.key, enriched);
+		cache.onEvent?.({
+			type: "hit",
+			key: cache.key,
+			reason: "memory"
+		});
+		return enriched;
+	}
+	return {
+		codePath: meta.codePath,
+		meta
+	};
 }
 async function importCachedCode(cached, options) {
-  if (cached.mod !== void 0) {
-    return cached.mod;
-  }
-  const target = options.format === "esm" ? pathToFileURL3(cached.codePath).href : cached.codePath;
-  if (options.require) {
-    return options.require(target, { format: options.format });
-  }
-  if (options.format === "esm") {
-    return import(target);
-  }
-  return _require(target);
+	if (cached.mod !== void 0) return cached.mod;
+	const target = options.format === "esm" ? pathToFileURL(cached.codePath).href : cached.codePath;
+	if (options.require) return options.require(target, { format: options.format });
+	if (options.format === "esm") return import(target);
+	return _require$1(target);
 }
 async function storeCacheOutput(cache, code, options, dependencies) {
-  await fsp.mkdir(cache.dir, { recursive: true });
-  const ext = options.format === "cjs" ? "cjs" : "mjs";
-  const codePath = path5.join(cache.dir, `${cache.key}.code.${ext}`);
-  if (cache.reset) {
-    await Promise.allSettled([
-      fsp.rm(codePath, { force: true }),
-      fsp.rm(path5.join(cache.dir, `${cache.key}.meta.json`), { force: true })
-    ]);
-  }
-  await fsp.writeFile(codePath, code);
-  const trackedFiles = collectFileStats([
-    cache.entryPath,
-    ...dependencies ?? []
-  ]);
-  return {
-    outfile: options.format === "esm" ? pathToFileURL3(codePath).href : codePath,
-    cleanup: async () => {
-    },
-    cacheMeta: {
-      format: options.format,
-      codePath,
-      files: trackedFiles
-    }
-  };
+	await fsp.mkdir(cache.dir, { recursive: true });
+	const ext = options.format === "cjs" ? "cjs" : "mjs";
+	const codePath = path.join(cache.dir, `${cache.key}.code.${ext}`);
+	if (cache.reset) await Promise.allSettled([fsp.rm(codePath, { force: true }), fsp.rm(path.join(cache.dir, `${cache.key}.meta.json`), { force: true })]);
+	await fsp.writeFile(codePath, code);
+	const trackedFiles = collectFileStats([cache.entryPath, ...dependencies ?? []]);
+	return {
+		outfile: options.format === "esm" ? pathToFileURL(codePath).href : codePath,
+		cleanup: async () => {},
+		cacheMeta: {
+			format: options.format,
+			codePath,
+			files: trackedFiles
+		}
+	};
 }
 async function writeCacheMeta(cache, meta) {
-  await fsp.mkdir(cache.dir, { recursive: true });
-  await fsp.writeFile(
-    path5.join(cache.dir, `${cache.key}.meta.json`),
-    JSON.stringify(meta)
-  );
-  if (cache.memory) {
-    memoryCache.set(cache.key, { codePath: meta.codePath, meta });
-  }
+	await fsp.mkdir(cache.dir, { recursive: true });
+	await fsp.writeFile(path.join(cache.dir, `${cache.key}.meta.json`), JSON.stringify(meta));
+	if (cache.memory) memoryCache.set(cache.key, {
+		codePath: meta.codePath,
+		meta
+	});
 }
 function collectFileStats(files) {
-  const seen = /* @__PURE__ */ new Set();
-  const stats = [];
-  for (const file of files) {
-    if (!file || seen.has(file)) {
-      continue;
-    }
-    seen.add(file);
-    const stat = tryStatSync(file);
-    if (stat?.isFile()) {
-      stats.push({
-        path: path5.resolve(file),
-        mtimeMs: stat.mtimeMs,
-        size: stat.size
-      });
-    }
-  }
-  return stats;
+	const seen = /* @__PURE__ */ new Set();
+	const stats = [];
+	for (const file of files) {
+		if (!file || seen.has(file)) continue;
+		seen.add(file);
+		const stat = tryStatSync(file);
+		if (stat?.isFile()) stats.push({
+			path: path.resolve(file),
+			mtimeMs: stat.mtimeMs,
+			size: stat.size
+		});
+	}
+	return stats;
 }
 function writeMemoryCache(cache, mod, meta) {
-  if (!cache.memory) {
-    return;
-  }
-  memoryCache.set(cache.key, { mod, codePath: meta.codePath, meta });
+	if (!cache.memory) return;
+	memoryCache.set(cache.key, {
+		mod,
+		codePath: meta.codePath,
+		meta
+	});
 }
 async function readCacheMeta(metaPath) {
-  try {
-    const raw = await fsp.readFile(metaPath, "utf-8");
-    return JSON.parse(raw);
-  } catch {
-  }
-  return void 0;
+	try {
+		const raw = await fsp.readFile(metaPath, "utf-8");
+		return JSON.parse(raw);
+	} catch {}
 }
 function validateMeta(meta, options) {
-  if (meta.format !== options.format) {
-    return "format-mismatch";
-  }
-  if (!meta.codePath || !fs4.existsSync(meta.codePath)) {
-    return "missing-code";
-  }
-  for (const file of meta.files ?? []) {
-    const stat = tryStatSync(file.path);
-    if (!stat || stat.mtimeMs !== file.mtimeMs || stat.size !== file.size) {
-      return "stale-deps";
-    }
-  }
-  return true;
+	if (meta.format !== options.format) return "format-mismatch";
+	if (!meta.codePath || !fs.existsSync(meta.codePath)) return "missing-code";
+	for (const file of meta.files ?? []) {
+		const stat = tryStatSync(file.path);
+		if (!stat || stat.mtimeMs !== file.mtimeMs || stat.size !== file.size) return "stale-deps";
+	}
+	return true;
 }
 function hashRolldownOptions(options) {
-  if (!options) {
-    return "none";
-  }
-  return crypto.createHash("sha1").update(
-    JSON.stringify(options, (_key, value) => {
-      if (typeof value === "function" || typeof value === "symbol") {
-        return void 0;
-      }
-      return value;
-    })
-  ).digest("hex");
-}
-
-// src/config.ts
-var configDefaults = Object.freeze({
-  resolve: {
-    extensions: [".mjs", ".js", ".mts", ".ts", ".jsx", ".tsx", ".json"]
-  }
-});
-var defaultGetOutputFile = (filepath, _format) => {
-  return filepath;
+	if (!options) return "none";
+	return crypto.createHash("sha1").update(JSON.stringify(options, (_key, value) => {
+		if (typeof value === "function" || typeof value === "symbol") return;
+		return value;
+	})).digest("hex");
+}
+//#endregion
+//#region src/config.ts
+const configDefaults = Object.freeze({ resolve: { extensions: [
+	".mjs",
+	".js",
+	".mts",
+	".ts",
+	".jsx",
+	".tsx",
+	".json"
+] } });
+const defaultGetOutputFile = (filepath, _format) => {
+	return filepath;
 };
-
-// src/loader.ts
-import fs5 from "fs";
-import { createRequire as createRequire5 } from "module";
-import path7 from "path";
-import { promisify } from "util";
-
-// src/temp-output.ts
-import { Buffer as Buffer2 } from "buffer";
-import fsp2 from "fs/promises";
-import os2 from "os";
-import path6 from "path";
-import process5 from "process";
-import { pathToFileURL as pathToFileURL4 } from "url";
+//#endregion
+//#region src/temp-output.ts
+const NON_WORD_CHAR_RE = /[^\w.-]/g;
 function sanitizeFilename(name) {
-  return name.replace(/[^\w.-]/g, "_");
+	return name.replace(NON_WORD_CHAR_RE, "_");
 }
 async function resolveTempOutputFile(sourceFile, code, options) {
-  const getOutputFile = options.getOutputFile || defaultGetOutputFile;
-  const filenameHint = sanitizeFilename(path6.basename(sourceFile));
-  const hash = `timestamp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-  const extension = options.format === "cjs" ? "cjs" : "mjs";
-  const fileName = `${filenameHint}.${hash}.${extension}`;
-  const candidates = [];
-  if (typeof process5.versions.deno !== "string") {
-    const nearest = findNearestNodeModules(path6.dirname(sourceFile));
-    if (nearest) {
-      candidates.push(path6.resolve(nearest, ".rolldown-require"));
-    }
-  }
-  candidates.push(path6.join(os2.tmpdir(), "rolldown-require"));
-  for (const base of candidates) {
-    const target = getOutputFile(path6.join(base, fileName), options.format);
-    try {
-      await fsp2.mkdir(path6.dirname(target), { recursive: true });
-      await fsp2.writeFile(target, code);
-      const cleanup = async () => {
-        if (options.preserveTemporaryFile) {
-          return;
-        }
-        try {
-          await fsp2.unlink(target);
-        } catch {
-        }
-      };
-      return {
-        outfile: options.format === "esm" ? pathToFileURL4(target).href : target,
-        cleanup
-      };
-    } catch {
-    }
-  }
-  if (options.format === "esm") {
-    const dataUrl = `data:text/javascript;base64,${Buffer2.from(code).toString("base64")}`;
-    return {
-      outfile: dataUrl,
-      cleanup: async () => {
-      }
-    };
-  }
-  throw new Error("Failed to create temporary output file for bundled code");
-}
-
-// src/loader.ts
-var _require2 = createRequire5(import.meta.url);
-var promisifiedRealpath = promisify(fs5.realpath);
+	const getOutputFile = options.getOutputFile || defaultGetOutputFile;
+	const fileName = `${sanitizeFilename(path.basename(sourceFile))}.${`timestamp-${Date.now()}-${Math.random().toString(16).slice(2)}`}.${options.format === "cjs" ? "cjs" : "mjs"}`;
+	const candidates = [];
+	if (typeof process.versions.deno !== "string") {
+		const nearest = findNearestNodeModules(path.dirname(sourceFile));
+		if (nearest) candidates.push(path.resolve(nearest, ".rolldown-require"));
+	}
+	candidates.push(path.join(os.tmpdir(), "rolldown-require"));
+	for (const base of candidates) {
+		const target = getOutputFile(path.join(base, fileName), options.format);
+		try {
+			await fsp.mkdir(path.dirname(target), { recursive: true });
+			await fsp.writeFile(target, code);
+			const cleanup = async () => {
+				if (options.preserveTemporaryFile) return;
+				try {
+					await fsp.unlink(target);
+				} catch {}
+			};
+			return {
+				outfile: options.format === "esm" ? pathToFileURL(target).href : target,
+				cleanup
+			};
+		} catch {}
+	}
+	if (options.format === "esm") return {
+		outfile: `data:text/javascript;base64,${Buffer$1.from(code).toString("base64")}`,
+		cleanup: async () => {}
+	};
+	throw new Error("Failed to create temporary output file for bundled code");
+}
+//#endregion
+//#region src/loader.ts
+const _require = createRequire(import.meta.url);
+const promisifiedRealpath = promisify(fs.realpath);
 async function loadFromBundledFile(fileName, bundledCode, options, dependencies) {
-  const cacheConfig = resolveCacheOptions(fileName, options);
-  if (cacheConfig.enabled) {
-    const cached = await maybeReadCache(cacheConfig, options);
-    if (cached) {
-      if (!cached.mod) {
-        cacheConfig.onEvent?.({ type: "hit", key: cacheConfig.key });
-      }
-      return importCachedCode(cached, options);
-    }
-    cacheConfig.onEvent?.({ type: "miss", key: cacheConfig.key });
-  }
-  const { isESM } = options;
-  if (isESM) {
-    const tempOutput = cacheConfig.enabled ? await storeCacheOutput(cacheConfig, bundledCode, options, dependencies) : await resolveTempOutputFile(fileName, bundledCode, options);
-    const outfile = tempOutput?.outfile;
-    const cleanup = tempOutput?.cleanup;
-    let mod;
-    const req = options.require || dynamicImport;
-    try {
-      mod = await req(outfile, { format: options.format });
-      if (cacheConfig.enabled && tempOutput?.cacheMeta) {
-        await writeCacheMeta(cacheConfig, tempOutput.cacheMeta);
-        cacheConfig.onEvent?.({ type: "store", key: cacheConfig.key });
-        writeMemoryCache(cacheConfig, mod, tempOutput.cacheMeta);
-      }
-      return mod;
-    } finally {
-      if (!cacheConfig.enabled) {
-        await cleanup?.();
-      }
-    }
-  } else {
-    const extension = path7.extname(fileName);
-    const realFileName = await promisifiedRealpath(fileName);
-    const loaderExt = extension in _require2.extensions ? extension : ".js";
-    const defaultLoader = _require2.extensions[loaderExt];
-    const compileLoader = (module, filename) => {
-      if (filename === realFileName) {
-        ;
-        module._compile(bundledCode, filename);
-      } else {
-        defaultLoader(module, filename);
-      }
-    };
-    let raw;
-    try {
-      _require2.extensions[loaderExt] = compileLoader;
-      delete _require2.cache[_require2.resolve(fileName)];
-      raw = _require2(fileName);
-      return raw.__esModule ? raw.default : raw;
-    } finally {
-      _require2.extensions[loaderExt] = defaultLoader;
-      if (cacheConfig.enabled && raw !== void 0) {
-        const cachedPath = await storeCacheOutput(
-          cacheConfig,
-          bundledCode,
-          options,
-          dependencies
-        );
-        await writeCacheMeta(cacheConfig, cachedPath.cacheMeta);
-        cacheConfig.onEvent?.({ type: "store", key: cacheConfig.key });
-        writeMemoryCache(
-          cacheConfig,
-          raw.__esModule ? raw.default : raw,
-          cachedPath.cacheMeta
-        );
-      }
-    }
-  }
-}
-
-// src/options.ts
-import path8 from "path";
-import process6 from "process";
-import { getTsconfig } from "get-tsconfig";
+	const cacheConfig = resolveCacheOptions(fileName, options);
+	if (cacheConfig.enabled) {
+		const cached = await maybeReadCache(cacheConfig, options);
+		if (cached) {
+			if (!cached.mod) cacheConfig.onEvent?.({
+				type: "hit",
+				key: cacheConfig.key
+			});
+			return importCachedCode(cached, options);
+		}
+		cacheConfig.onEvent?.({
+			type: "miss",
+			key: cacheConfig.key
+		});
+	}
+	const { isESM } = options;
+	if (isESM) {
+		const tempOutput = cacheConfig.enabled ? await storeCacheOutput(cacheConfig, bundledCode, options, dependencies) : await resolveTempOutputFile(fileName, bundledCode, options);
+		const outfile = tempOutput?.outfile;
+		const cleanup = tempOutput?.cleanup;
+		let mod;
+		const req = options.require || dynamicImport;
+		try {
+			mod = await req(outfile, { format: options.format });
+			if (cacheConfig.enabled && tempOutput?.cacheMeta) {
+				await writeCacheMeta(cacheConfig, tempOutput.cacheMeta);
+				cacheConfig.onEvent?.({
+					type: "store",
+					key: cacheConfig.key
+				});
+				writeMemoryCache(cacheConfig, mod, tempOutput.cacheMeta);
+			}
+			return mod;
+		} finally {
+			if (!cacheConfig.enabled) await cleanup?.();
+		}
+	} else {
+		const extension = path.extname(fileName);
+		const realFileName = await promisifiedRealpath(fileName);
+		const loaderExt = extension in _require.extensions ? extension : ".js";
+		const defaultLoader = _require.extensions[loaderExt];
+		const compileLoader = (module, filename) => {
+			if (filename === realFileName) module._compile(bundledCode, filename);
+			else defaultLoader(module, filename);
+		};
+		let raw;
+		try {
+			_require.extensions[loaderExt] = compileLoader;
+			delete _require.cache[_require.resolve(fileName)];
+			raw = _require(fileName);
+			return raw.__esModule ? raw.default : raw;
+		} finally {
+			_require.extensions[loaderExt] = defaultLoader;
+			if (cacheConfig.enabled && raw !== void 0) {
+				const cachedPath = await storeCacheOutput(cacheConfig, bundledCode, options, dependencies);
+				await writeCacheMeta(cacheConfig, cachedPath.cacheMeta);
+				cacheConfig.onEvent?.({
+					type: "store",
+					key: cacheConfig.key
+				});
+				writeMemoryCache(cacheConfig, raw.__esModule ? raw.default : raw, cachedPath.cacheMeta);
+			}
+		}
+	}
+}
+//#endregion
+//#region src/options.ts
 function resolveEntryFilepath(options) {
-  if (path8.isAbsolute(options.filepath)) {
-    return options.filepath;
-  }
-  const cwd = options.cwd ? path8.resolve(options.cwd) : process6.cwd();
-  return path8.resolve(cwd, options.filepath);
+	if (path.isAbsolute(options.filepath)) return options.filepath;
+	const cwd = options.cwd ? path.resolve(options.cwd) : process.cwd();
+	return path.resolve(cwd, options.filepath);
 }
 function detectModuleType(resolvedPath) {
-  return typeof process6.versions.deno === "string" || isFilePathESM(resolvedPath);
+	return typeof process.versions.deno === "string" || isFilePathESM(resolvedPath);
 }
 function createInternalOptions(userOptions, isESM) {
-  const {
-    filepath: _filepath,
-    cwd: _cwd,
-    ...rest
-  } = userOptions;
-  const tsconfig = userOptions.tsconfig === false ? false : resolveTsconfigPath(userOptions);
-  const format = userOptions.format ?? (isESM ? "esm" : "cjs");
-  const sourcemap = resolveSourcemapOption(userOptions);
-  return {
-    ...rest,
-    isESM,
-    format,
-    tsconfig,
-    sourcemap
-  };
+	const { filepath: _filepath, cwd: _cwd, ...rest } = userOptions;
+	const tsconfig = userOptions.tsconfig === false ? false : resolveTsconfigPath(userOptions);
+	const format = userOptions.format ?? (isESM ? "esm" : "cjs");
+	const sourcemap = resolveSourcemapOption(userOptions);
+	return {
+		...rest,
+		isESM,
+		format,
+		tsconfig,
+		sourcemap
+	};
 }
 function resolveTsconfigPath(options) {
-  if (options.tsconfig === false) {
-    return void 0;
-  }
-  if (typeof options.tsconfig === "string") {
-    return options.tsconfig;
-  }
-  return getTsconfig(options.cwd, "tsconfig.json")?.path ?? void 0;
+	if (options.tsconfig === false) return;
+	if (typeof options.tsconfig === "string") return options.tsconfig;
+	return getTsconfig(options.cwd, "tsconfig.json")?.path ?? void 0;
 }
 function resolveSourcemapOption(options) {
-  if (options.sourcemap !== void 0) {
-    return options.sourcemap;
-  }
-  if (shouldEnableSourcemapFromEnv()) {
-    return "inline";
-  }
-  return void 0;
+	if (options.sourcemap !== void 0) return options.sourcemap;
+	if (shouldEnableSourcemapFromEnv()) return "inline";
 }
 function shouldEnableSourcemapFromEnv() {
-  const nodeOptions = process6.env.NODE_OPTIONS ?? "";
-  if (nodeOptions.includes("--inspect")) {
-    return true;
-  }
-  if (process6.env.VSCODE_INSPECTOR_OPTIONS) {
-    return true;
-  }
-  if (process6.env.DEBUG) {
-    return true;
-  }
-  return false;
+	if ((process.env.NODE_OPTIONS ?? "").includes("--inspect")) return true;
+	if (process.env.VSCODE_INSPECTOR_OPTIONS) return true;
+	if (process.env.DEBUG) return true;
+	return false;
 }
-
-// src/index.ts
+//#endregion
+//#region src/index.ts
 async function bundleRequire(options) {
-  const resolvedPath = resolveEntryFilepath(options);
-  const isESM = detectModuleType(resolvedPath);
-  const internalOptions = createInternalOptions(options, isESM);
-  const cacheConfig = resolveCacheOptions(resolvedPath, internalOptions);
-  if (cacheConfig.enabled) {
-    const cached = await maybeReadCache(cacheConfig, internalOptions);
-    if (cached) {
-      const mod2 = await importCachedCode(cached, internalOptions);
-      if (cacheConfig.memory && cached.meta) {
-        writeMemoryCache(cacheConfig, mod2, cached.meta);
-      }
-      const dependencies = cached.meta?.files?.map((file) => file.path).filter((file) => file !== cacheConfig.entryPath) ?? [];
-      return { mod: mod2, dependencies };
-    }
-  }
-  const bundled = await bundleFile(
-    resolvedPath,
-    internalOptions
-  );
-  const mod = await loadFromBundledFile(
-    resolvedPath,
-    bundled.code,
-    internalOptions,
-    bundled.dependencies
-  );
-  return {
-    mod,
-    dependencies: bundled.dependencies
-  };
-}
-export {
-  bundleFile,
-  bundleRequire,
-  configDefaults,
-  loadFromBundledFile
-};
+	const resolvedPath = resolveEntryFilepath(options);
+	const internalOptions = createInternalOptions(options, detectModuleType(resolvedPath));
+	const cacheConfig = resolveCacheOptions(resolvedPath, internalOptions);
+	if (cacheConfig.enabled) {
+		const cached = await maybeReadCache(cacheConfig, internalOptions);
+		if (cached) {
+			const mod = await importCachedCode(cached, internalOptions);
+			if (cacheConfig.memory && cached.meta) writeMemoryCache(cacheConfig, mod, cached.meta);
+			return {
+				mod,
+				dependencies: cached.meta?.files?.map((file) => file.path).filter((file) => file !== cacheConfig.entryPath) ?? []
+			};
+		}
+	}
+	const bundled = await bundleFile(resolvedPath, internalOptions);
+	return {
+		mod: await loadFromBundledFile(resolvedPath, bundled.code, internalOptions, bundled.dependencies),
+		dependencies: bundled.dependencies
+	};
+}
+//#endregion
+export { bundleFile, bundleRequire, configDefaults, loadFromBundledFile };