rolldown-require 1.0.5 → 2.0.0

package/dist/index.mjs

@@ -1,37 +1,81 @@
-// src/index.ts
+// src/bundler.ts
+import path6 from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
+import { rolldown } from "rolldown";
+
+// src/collect.ts
+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 fs4 from "fs";
-import fsp from "fs/promises";
 import { createRequire as createRequire3 } from "module";
 import path5 from "path";
-import process4 from "process";
 import { pathToFileURL } from "url";
-import { promisify } from "util";
-import { getTsconfig } from "get-tsconfig";
-import { rolldown } from "rolldown";
+
+// src/config.ts
+var configDefaults = Object.freeze({
+  resolve: {
+    extensions: [".mjs", ".js", ".mts", ".ts", ".jsx", ".tsx", ".json"]
+  }
+});
+var defaultGetOutputFile = (filepath, _format) => {
+  return filepath;
+};
+
+// src/plugins/resolve.ts
+import fs3 from "fs";
+import path4 from "path";
+import { hasESMSyntax } from "mlly";
+import { exports, imports } from "resolve.exports";
+
+// src/constants.ts
+import { readFileSync } from "fs";
+var { version } = JSON.parse(
+  readFileSync(new URL("../package.json", import.meta.url)).toString()
+);
+var DEV_PROD_CONDITION = `development|production`;
+var OPTIMIZABLE_ENTRY_RE = /\.[cm]?[jt]s$/;
+var SPECIAL_QUERY_RE = /[?&](?:worker|sharedworker|raw|url)\b/;
+
+// src/external.ts
+import path from "path";
+function canExternalizeFile(filePath) {
+  const ext = path.extname(filePath);
+  return !ext || ext === ".js" || ext === ".mjs" || ext === ".cjs";
+}
 
 // src/packages.ts
 import fs2 from "fs";
 import { createRequire as createRequire2 } from "module";
-import path2 from "path";
+import path3 from "path";
 import process3 from "process";
 
 // src/utils.ts
 import { exec } from "child_process";
 import fs from "fs";
 import { builtinModules, createRequire } from "module";
-import path from "path";
+import path2 from "path";
 import process2 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()
-);
-var DEV_PROD_CONDITION = `development|production`;
-var OPTIMIZABLE_ENTRY_RE = /\.[cm]?[jt]s$/;
-var SPECIAL_QUERY_RE = /[?&](?:worker|sharedworker|raw|url)\b/;
-
 // src/sharedUtils.ts
 import process from "process";
 var isWindows = typeof process !== "undefined" && process.platform === "win32";
@@ -43,9 +87,9 @@ var postfixRE = /[?#].*$/;
 function cleanUrl(url) {
   return url.replace(postfixRE, "");
 }
-function splitFileAndPostfix(path6) {
-  const file = cleanUrl(path6);
-  return { file, postfix: path6.slice(file.length) };
+function splitFileAndPostfix(path11) {
+  const file = cleanUrl(path11);
+  return { file, postfix: path11.slice(file.length) };
 }
 
 // src/utils.ts
@@ -97,7 +141,7 @@ function isOptimizable(id, optimizeDeps) {
 var bareImportRE = /^(?![a-z]:)[\w@](?!.*:\/\/)/i;
 var deepImportRE = /^([^@][^/]*)\/|^(@[^/]+\/[^/]+)\//;
 function normalizePath(id) {
-  return path.posix.normalize(isWindows ? slash(id) : id);
+  return path2.posix.normalize(isWindows ? slash(id) : id);
 }
 function injectQuery(url, queryToInject) {
   const { file, postfix } = splitFileAndPostfix(url);
@@ -123,7 +167,7 @@ function isFilePathESM(filePath, packageCache) {
     return false;
   } else {
     try {
-      const pkg = findNearestPackageData(path.dirname(filePath), packageCache);
+      const pkg = findNearestPackageData(path2.dirname(filePath), packageCache);
       return pkg?.data.type === "module";
     } catch {
       return false;
@@ -135,8 +179,8 @@ function safeRealpathSync(filePath) {
   return currentSafeRealpathSync(filePath);
 }
 var windowsNetworkMap = /* @__PURE__ */ new Map();
-function windowsMappedRealpathSync(path6) {
-  const realPath = fs.realpathSync.native(path6);
+function windowsMappedRealpathSync(path11) {
+  const realPath = fs.realpathSync.native(path11);
   if (realPath.startsWith("\\\\")) {
     for (const [network, volume] of windowsNetworkMap) {
       if (realPath.startsWith(network)) {
@@ -148,12 +192,12 @@ function windowsMappedRealpathSync(path6) {
 }
 var parseNetUseRE = /^\w* +(\w:) +([^ ]+)\s/;
 var firstSafeRealPathSyncRun = false;
-function windowsSafeRealPathSync(path6) {
+function windowsSafeRealPathSync(path11) {
   if (!firstSafeRealPathSyncRun) {
     optimizeSafeRealPathSync();
     firstSafeRealPathSyncRun = true;
   }
-  return fs.realpathSync(path6);
+  return fs.realpathSync(path11);
 }
 function optimizeSafeRealPathSync() {
   const nodeVersion = process2.versions.node.split(".").map(Number);
@@ -162,7 +206,7 @@ function optimizeSafeRealPathSync() {
     return;
   }
   try {
-    fs.realpathSync.native(path.resolve("./"));
+    fs.realpathSync.native(path2.resolve("./"));
   } catch (error) {
     if (error.message.includes("EISDIR: illegal operation on a directory")) {
       currentSafeRealpathSync = fs.realpathSync;
@@ -226,7 +270,7 @@ function resolvePackageData(pkgName, basedir, preserveSymlinks = false, packageC
       if (!pkg) {
         return null;
       }
-      const pkgData = loadPackageData(path2.join(pkg, "package.json"));
+      const pkgData = loadPackageData(path3.join(pkg, "package.json"));
       packageCache?.set(cacheKey, pkgData);
       return pkgData;
     } catch {
@@ -247,7 +291,7 @@ function resolvePackageData(pkgName, basedir, preserveSymlinks = false, packageC
         return cached;
       }
     }
-    const pkg = path2.join(basedir, "node_modules", pkgName, "package.json");
+    const pkg = path3.join(basedir, "node_modules", pkgName, "package.json");
     try {
       if (fs2.existsSync(pkg)) {
         const pkgPath = preserveSymlinks ? pkg : safeRealpathSync(pkg);
@@ -266,7 +310,7 @@ function resolvePackageData(pkgName, basedir, preserveSymlinks = false, packageC
       }
     } catch {
     }
-    const nextBasedir = path2.dirname(basedir);
+    const nextBasedir = path3.dirname(basedir);
     if (nextBasedir === basedir) {
       break;
     }
@@ -283,7 +327,7 @@ function findNearestPackageData(basedir, packageCache) {
         return cached;
       }
     }
-    const pkgPath = path2.join(basedir, "package.json");
+    const pkgPath = path3.join(basedir, "package.json");
     if (tryStatSync(pkgPath)?.isFile()) {
       try {
         const pkgData = loadPackageData(pkgPath);
@@ -294,7 +338,7 @@ function findNearestPackageData(basedir, packageCache) {
       } catch {
       }
     }
-    const nextBasedir = path2.dirname(basedir);
+    const nextBasedir = path3.dirname(basedir);
     if (nextBasedir === basedir) {
       break;
     }
@@ -305,13 +349,13 @@ function findNearestPackageData(basedir, packageCache) {
 function findNearestMainPackageData(basedir, packageCache) {
   const nearestPackage = findNearestPackageData(basedir, packageCache);
   return nearestPackage && (nearestPackage.data.name ? nearestPackage : findNearestMainPackageData(
-    path2.dirname(nearestPackage.dir),
+    path3.dirname(nearestPackage.dir),
     packageCache
   ));
 }
 function loadPackageData(pkgPath) {
   const data = JSON.parse(stripBomTag(fs2.readFileSync(pkgPath, "utf-8")));
-  const pkgDir = normalizePath(path2.dirname(pkgPath));
+  const pkgDir = normalizePath(path3.dirname(pkgPath));
   const { sideEffects } = data;
   let hasSideEffects;
   if (typeof sideEffects === "boolean") {
@@ -358,11 +402,11 @@ function getResolveCacheKey(key, options) {
 }
 function findNearestNodeModules(basedir) {
   while (basedir) {
-    const pkgPath = path2.join(basedir, "node_modules");
+    const pkgPath = path3.join(basedir, "node_modules");
     if (tryStatSync(pkgPath)?.isDirectory()) {
       return pkgPath;
     }
-    const nextBasedir = path2.dirname(basedir);
+    const nextBasedir = path3.dirname(basedir);
     if (nextBasedir === basedir) {
       break;
     }
@@ -411,23 +455,10 @@ function getFnpdCacheKey(basedir) {
 function traverseBetweenDirs(longerDir, shorterDir, cb) {
   while (longerDir !== shorterDir) {
     cb(longerDir);
-    longerDir = path2.dirname(longerDir);
+    longerDir = path3.dirname(longerDir);
   }
 }
 
-// src/plugins/resolve.ts
-import fs3 from "fs";
-import path4 from "path";
-import { hasESMSyntax } from "mlly";
-import { exports, imports } from "resolve.exports";
-
-// src/external.ts
-import path3 from "path";
-function canExternalizeFile(filePath) {
-  const ext = path3.extname(filePath);
-  return !ext || ext === ".js" || ext === ".mjs" || ext === ".cjs";
-}
-
 // src/plugins/resolve.ts
 var ERR_RESOLVE_PACKAGE_ENTRY_FAIL = "ERR_RESOLVE_PACKAGE_ENTRY_FAIL";
 var browserExternalId = "__vite-browser-external";
@@ -778,8 +809,8 @@ function mapWithBrowserField(relativePathInPkgDir, map) {
     }
   }
 }
-function equalWithoutSuffix(path6, key, suffix) {
-  return key.endsWith(suffix) && key.slice(0, -suffix.length) === path6;
+function equalWithoutSuffix(path11, key, suffix) {
+  return key.endsWith(suffix) && key.slice(0, -suffix.length) === path11;
 }
 function tryResolveRealFile(file, preserveSymlinks) {
   const stat = tryStatSync(file);
@@ -810,21 +841,178 @@ function getRealPath(resolved, preserveSymlinks) {
   }
   return normalizePath(resolved);
 }
-function isDirectory(path6) {
-  const stat = tryStatSync(path6);
+function isDirectory(path11) {
+  const stat = tryStatSync(path11);
   return stat?.isDirectory() ?? false;
 }
 
-// src/index.ts
-var promisifiedRealpath = promisify(fs4.realpath);
-var configDefaults = Object.freeze({
-  resolve: {
-    extensions: [".mjs", ".js", ".mts", ".ts", ".jsx", ".tsx", ".json"]
+// src/externalize.ts
+function createExternalizeDepsPlugin({
+  entryFile,
+  isESM,
+  moduleSyncEnabled
+}) {
+  const entryDir = path5.dirname(entryFile);
+  const packageCache = /* @__PURE__ */ new Map();
+  const resolveByViteResolver = (id, importer, isRequire) => {
+    return tryNodeResolve(id, importer, {
+      root: path5.dirname(entryFile),
+      isBuild: true,
+      isProduction: true,
+      preferRelative: false,
+      tryIndex: true,
+      mainFields: [],
+      conditions: [
+        "node",
+        ...moduleSyncEnabled ? ["module-sync"] : []
+      ],
+      externalConditions: [],
+      external: [],
+      noExternal: [],
+      dedupe: [],
+      extensions: configDefaults.resolve.extensions,
+      preserveSymlinks: false,
+      packageCache,
+      isRequire,
+      builtins: nodeLikeBuiltins
+    })?.id;
+  };
+  return {
+    name: "externalize-deps",
+    resolveId: {
+      filter: { id: /^[^.#].*/ },
+      async handler(id, importer, { kind }) {
+        if (!importer || path5.isAbsolute(id) || isNodeBuiltin(id)) {
+          return;
+        }
+        if (isNodeLikeBuiltin(id)) {
+          return { id, external: true };
+        }
+        const isImport = isESM || kind === "dynamic-import";
+        let idFsPath;
+        try {
+          idFsPath = resolveByViteResolver(id, importer, !isImport);
+        } catch (e) {
+          if (!isImport) {
+            let canResolveWithImport = false;
+            try {
+              canResolveWithImport = !!resolveByViteResolver(
+                id,
+                importer,
+                false
+              );
+            } catch {
+            }
+            if (canResolveWithImport) {
+              throw new Error(
+                `Failed to resolve ${JSON.stringify(
+                  id
+                )}. This package is ESM only but it was tried to load by \`require\`. See https://vite.dev/guide/troubleshooting.html#this-package-is-esm-only for more details.`
+              );
+            }
+          }
+          throw e;
+        }
+        if (!idFsPath) {
+          return;
+        }
+        if (idFsPath.endsWith(".json")) {
+          return idFsPath;
+        }
+        const shouldExternalize = shouldExternalizeBareImport(id, importer, entryDir);
+        if (idFsPath && isImport && shouldExternalize) {
+          idFsPath = pathToFileURL(idFsPath).href;
+        }
+        return { id: idFsPath, external: shouldExternalize };
+      }
+    }
+  };
+}
+function shouldExternalizeBareImport(specifier, importer, entryDir) {
+  if (!specifier || specifier.startsWith(".") || path5.isAbsolute(specifier)) {
+    return false;
   }
-});
-var defaultGetOutputFile = (filepath, _format) => {
-  return filepath;
-};
+  if (isNodeLikeBuiltin(specifier)) {
+    return true;
+  }
+  const importerPath = normalizeImporterPath(importer, entryDir);
+  try {
+    const containingNodeModules = findContainingNodeModules(
+      createRequire3(importerPath).resolve(specifier)
+    );
+    if (containingNodeModules) {
+      const ownerDir = path5.dirname(containingNodeModules);
+      const ownerInsideEntry = isPathWithinDirectory(entryDir, ownerDir);
+      const entryInsideOwner = isPathWithinDirectory(ownerDir, entryDir);
+      if (ownerInsideEntry && !entryInsideOwner) {
+        return false;
+      }
+    }
+  } catch {
+  }
+  if (!canResolveFromEntry(specifier, entryDir)) {
+    return false;
+  }
+  return true;
+}
+function normalizeImporterPath(importer, fallback) {
+  if (!importer || importer.startsWith("\0")) {
+    return fallback;
+  }
+  const [withoutQuery] = importer.split("?");
+  return withoutQuery || fallback;
+}
+function findContainingNodeModules(filePath) {
+  let current = path5.dirname(filePath);
+  const { root } = path5.parse(current);
+  while (true) {
+    if (path5.basename(current) === "node_modules") {
+      return current;
+    }
+    if (current === root) {
+      break;
+    }
+    current = path5.dirname(current);
+  }
+}
+function isPathWithinDirectory(parent, child) {
+  const relative = path5.relative(parent, child);
+  return relative === "" || !relative.startsWith("..") && !path5.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;
+}
+function canResolveFromEntry(specifier, entryDir) {
+  const packageName = getPackageName(specifier);
+  if (!packageName) {
+    return false;
+  }
+  let currentDir = entryDir;
+  while (true) {
+    if (fs4.existsSync(path5.join(currentDir, "node_modules", packageName))) {
+      return true;
+    }
+    const parentDir = path5.dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  return false;
+}
+
+// src/module-sync.ts
 var cachedModuleSyncCondition;
 var moduleSyncConditionPromise;
 async function getModuleSyncConditionEnabled() {
@@ -844,25 +1032,8 @@ async function getModuleSyncConditionEnabled() {
   }
   return moduleSyncConditionPromise;
 }
-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/bundler.ts
 async function bundleFile(fileName, options) {
   const { isESM } = options;
   const moduleSyncEnabled = await getModuleSyncConditionEnabled();
@@ -905,9 +1076,9 @@ async function bundleFile(fileName, options) {
     bundle = await rolldown({
       ...restRolldownInputOptions,
       input: fileName,
-      // target: [`node${process.versions.node}`],
       platform: "node",
       resolve: resolveOptions,
+      // @ts-ignore
       define: transformDefine,
       transform: transformOptions,
       // disable treeshake to include files that is not sideeffectful to `moduleIds`
@@ -925,7 +1096,6 @@ async function bundleFile(fileName, options) {
         })
       ],
       external: options.external
-      // preserveEntrySignatures: 'exports-only'
     });
   } finally {
     console.warn = originalConsoleWarn;
@@ -938,10 +1108,6 @@ async function bundleFile(fileName, options) {
     ...rolldownOutputOptions,
     format: options.format,
     sourcemap: false,
-    // sourcemapPathTransform(relative) {
-    //   return path.resolve(fileName, relative)
-    // },
-    // we want to generate a single chunk like esbuild does with `splitting: false`
     inlineDynamicImports: true
   });
   await bundle.close();
@@ -959,51 +1125,341 @@ async function bundleFile(fileName, options) {
     dependencies: [...allModules]
   };
 }
-var _require = createRequire3(import.meta.url);
-async function loadFromBundledFile(fileName, bundledCode, options) {
-  const { isESM } = options;
-  if (isESM) {
-    let nodeModulesDir = typeof process4.versions.deno === "string" ? void 0 : findNearestNodeModules(path5.dirname(fileName));
-    if (nodeModulesDir) {
-      try {
-        await fsp.mkdir(path5.resolve(nodeModulesDir, ".vite-temp/"), {
-          recursive: true
-        });
-      } catch (e) {
-        if (e.code === "EACCES") {
-          nodeModulesDir = void 0;
-        } else {
-          throw e;
+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(path6.dirname(id))};const ${filenameVarName} = ${JSON.stringify(id)};const ${importMetaUrlVarName} = ${JSON.stringify(
+          pathToFileURL2(id).href
+        )};`;
+        return { code: injectValues + code, map: null };
+      }
+    }
+  };
+}
+
+// src/loader.ts
+import fs6 from "fs";
+import { createRequire as createRequire5 } from "module";
+import path9 from "path";
+import { promisify } from "util";
+
+// src/cache.ts
+import crypto from "crypto";
+import fs5 from "fs";
+import fsp from "fs/promises";
+import { createRequire as createRequire4 } from "module";
+import os from "os";
+import path7 from "path";
+import process4 from "process";
+import { pathToFileURL as pathToFileURL3 } from "url";
+var _require = createRequire4(import.meta.url);
+var 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: path7.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: path7.resolve(fileName),
+    memory,
+    onEvent
+  };
+}
+function resolveDefaultCacheDir(fileName) {
+  if (typeof process4.versions.deno !== "string") {
+    const nearest = findNearestNodeModules(path7.dirname(fileName));
+    if (nearest) {
+      return path7.resolve(nearest, ".rolldown-require-cache");
+    }
+  }
+  return path7.join(os.tmpdir(), "rolldown-require-cache");
+}
+async function maybeReadCache(cache, options) {
+  const metaPath = path7.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 };
+}
+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);
+}
+async function storeCacheOutput(cache, code, options, dependencies) {
+  await fsp.mkdir(cache.dir, { recursive: true });
+  const ext = options.format === "cjs" ? "cjs" : "mjs";
+  const codePath = path7.join(cache.dir, `${cache.key}.code.${ext}`);
+  if (cache.reset) {
+    await Promise.allSettled([
+      fsp.rm(codePath, { force: true }),
+      fsp.rm(path7.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
+    }
+  };
+}
+async function writeCacheMeta(cache, meta) {
+  await fsp.mkdir(cache.dir, { recursive: true });
+  await fsp.writeFile(
+    path7.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: path7.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 });
+}
+async function readCacheMeta(metaPath) {
+  try {
+    const raw = await fsp.readFile(metaPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+  }
+  return void 0;
+}
+function validateMeta(meta, options) {
+  if (meta.format !== options.format) {
+    return "format-mismatch";
+  }
+  if (!meta.codePath || !fs5.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/temp-output.ts
+import { Buffer as Buffer2 } from "buffer";
+import fsp2 from "fs/promises";
+import os2 from "os";
+import path8 from "path";
+import process5 from "process";
+import { pathToFileURL as pathToFileURL4 } from "url";
+function sanitizeFilename(name) {
+  return name.replace(/[^\w.-]/g, "_");
+}
+async function resolveTempOutputFile(sourceFile, code, options) {
+  const getOutputFile = options.getOutputFile || defaultGetOutputFile;
+  const filenameHint = sanitizeFilename(path8.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(path8.dirname(sourceFile));
+    if (nearest) {
+      candidates.push(path8.resolve(nearest, ".rolldown-require"));
+    }
+  }
+  candidates.push(path8.join(os2.tmpdir(), "rolldown-require"));
+  for (const base of candidates) {
+    const target = getOutputFile(path8.join(base, fileName), options.format);
+    try {
+      await fsp2.mkdir(path8.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(fs6.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);
     }
-    const hash = `timestamp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-    const tempFileName = nodeModulesDir ? path5.resolve(
-      nodeModulesDir,
-      `.vite-temp/${path5.basename(fileName)}.${hash}.${isESM ? "mjs" : "cjs"}`
-    ) : `${fileName}.${hash}.mjs`;
-    const getOutputFile = options.getOutputFile || defaultGetOutputFile;
-    const outfile = getOutputFile(tempFileName, options.format);
-    await fsp.writeFile(outfile, bundledCode);
+    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(
-        options.format === "esm" ? pathToFileURL(outfile).href : outfile,
-        { format: options.format }
-      );
+      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 (!options?.preserveTemporaryFile) {
-        fs4.unlink(outfile, () => {
-        });
+      if (!cacheConfig.enabled) {
+        await cleanup?.();
       }
     }
   } else {
-    const extension = path5.extname(fileName);
+    const extension = path9.extname(fileName);
     const realFileName = await promisifiedRealpath(fileName);
-    const loaderExt = extension in _require.extensions ? extension : ".js";
-    const defaultLoader = _require.extensions[loaderExt];
+    const loaderExt = extension in _require2.extensions ? extension : ".js";
+    const defaultLoader = _require2.extensions[loaderExt];
     const compileLoader = (module, filename) => {
       if (filename === realFileName) {
         ;
@@ -1012,140 +1468,46 @@ async function loadFromBundledFile(fileName, bundledCode, options) {
         defaultLoader(module, filename);
       }
     };
+    let raw;
     try {
-      _require.extensions[loaderExt] = compileLoader;
-      delete _require.cache[_require.resolve(fileName)];
-      const raw = _require(fileName);
+      _require2.extensions[loaderExt] = compileLoader;
+      delete _require2.cache[_require2.resolve(fileName)];
+      raw = _require2(fileName);
       return raw.__esModule ? raw.default : raw;
     } finally {
-      _require.extensions[loaderExt] = defaultLoader;
-    }
-  }
-}
-async function bundleRequire(options) {
-  const resolvedPath = resolveEntryFilepath(options);
-  const isESM = detectModuleType(resolvedPath);
-  const internalOptions = createInternalOptions(options, isESM);
-  const bundled = await bundleFile(
-    resolvedPath,
-    internalOptions
-  );
-  const mod = await loadFromBundledFile(
-    resolvedPath,
-    bundled.code,
-    internalOptions
-  );
-  return {
-    mod,
-    dependencies: bundled.dependencies
-  };
-}
-function createExternalizeDepsPlugin({
-  entryFile,
-  isESM,
-  moduleSyncEnabled
-}) {
-  const packageCache = /* @__PURE__ */ new Map();
-  const resolveByViteResolver = (id, importer, isRequire) => {
-    return tryNodeResolve(id, importer, {
-      root: path5.dirname(entryFile),
-      isBuild: true,
-      isProduction: true,
-      preferRelative: false,
-      tryIndex: true,
-      mainFields: [],
-      conditions: [
-        "node",
-        ...moduleSyncEnabled ? ["module-sync"] : []
-      ],
-      externalConditions: [],
-      external: [],
-      noExternal: [],
-      dedupe: [],
-      extensions: configDefaults.resolve.extensions,
-      preserveSymlinks: false,
-      packageCache,
-      isRequire,
-      builtins: nodeLikeBuiltins
-    })?.id;
-  };
-  return {
-    name: "externalize-deps",
-    resolveId: {
-      filter: { id: /^[^.#].*/ },
-      async handler(id, importer, { kind }) {
-        if (!importer || path5.isAbsolute(id) || isNodeBuiltin(id)) {
-          return;
-        }
-        if (isNodeLikeBuiltin(id)) {
-          return { id, external: true };
-        }
-        const isImport = isESM || kind === "dynamic-import";
-        let idFsPath;
-        try {
-          idFsPath = resolveByViteResolver(id, importer, !isImport);
-        } catch (e) {
-          if (!isImport) {
-            let canResolveWithImport = false;
-            try {
-              canResolveWithImport = !!resolveByViteResolver(
-                id,
-                importer,
-                false
-              );
-            } catch {
-            }
-            if (canResolveWithImport) {
-              throw new Error(
-                `Failed to resolve ${JSON.stringify(
-                  id
-                )}. This package is ESM only but it was tried to load by \`require\`. See https://vite.dev/guide/troubleshooting.html#this-package-is-esm-only for more details.`
-              );
-            }
-          }
-          throw e;
-        }
-        if (!idFsPath) {
-          return;
-        }
-        if (idFsPath.endsWith(".json")) {
-          return idFsPath;
-        }
-        if (idFsPath && isImport) {
-          idFsPath = pathToFileURL(idFsPath).href;
-        }
-        return { id: idFsPath, external: true };
+      _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
+        );
       }
     }
-  };
-}
-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(path5.dirname(id))};const ${filenameVarName} = ${JSON.stringify(id)};const ${importMetaUrlVarName} = ${JSON.stringify(
-          pathToFileURL(id).href
-        )};`;
-        return { code: injectValues + code, map: null };
-      }
-    }
-  };
+  }
 }
+
+// src/options.ts
+import path10 from "path";
+import process6 from "process";
+import { getTsconfig } from "get-tsconfig";
 function resolveEntryFilepath(options) {
-  if (path5.isAbsolute(options.filepath)) {
+  if (path10.isAbsolute(options.filepath)) {
     return options.filepath;
   }
-  const cwd = options.cwd ? path5.resolve(options.cwd) : process4.cwd();
-  return path5.resolve(cwd, options.filepath);
+  const cwd = options.cwd ? path10.resolve(options.cwd) : process6.cwd();
+  return path10.resolve(cwd, options.filepath);
 }
 function detectModuleType(resolvedPath) {
-  return typeof process4.versions.deno === "string" || isFilePathESM(resolvedPath);
+  return typeof process6.versions.deno === "string" || isFilePathESM(resolvedPath);
 }
 function createInternalOptions(userOptions, isESM) {
   const {
@@ -1171,6 +1533,27 @@ function resolveTsconfigPath(options) {
   }
   return getTsconfig(options.cwd, "tsconfig.json")?.path ?? void 0;
 }
+
+// src/index.ts
+async function bundleRequire(options) {
+  const resolvedPath = resolveEntryFilepath(options);
+  const isESM = detectModuleType(resolvedPath);
+  const internalOptions = createInternalOptions(options, isESM);
+  const bundled = await bundleFile(
+    resolvedPath,
+    internalOptions
+  );
+  const mod = await loadFromBundledFile(
+    resolvedPath,
+    bundled.code,
+    internalOptions,
+    bundled.dependencies
+  );
+  return {
+    mod,
+    dependencies: bundled.dependencies
+  };
+}
 export {
   bundleFile,
   bundleRequire,