rolldown-require 1.0.4 → 1.0.6

package/dist/index.cjs

@@ -5,34 +5,57 @@
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
-// ../../node_modules/.pnpm/tsup@8.5.0_@swc+core@1.13.19_jiti@2.6.1_postcss@8.5.6_tsx@4.20.6_typescript@5.9.3_yaml@2.8.1/node_modules/tsup/assets/cjs_shims.js
-var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.src || new URL("main.js", document.baseURI).href;
+// ../../node_modules/.pnpm/tsup@8.5.1_@swc+core@1.15.3_jiti@2.6.1_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3_yaml@2.8.2/node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
 var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
 
-// src/index.ts
-var _fs = require('fs'); var _fs2 = _interopRequireDefault(_fs);
-var _promises = require('fs/promises'); var _promises2 = _interopRequireDefault(_promises);
-var _module = require('module');
+// src/bundler.ts
 var _path = require('path'); var _path2 = _interopRequireDefault(_path);
-var _process = require('process'); var _process2 = _interopRequireDefault(_process);
 var _url = require('url');
-var _util = require('util');
-var _gettsconfig = require('get-tsconfig');
 var _rolldown = require('rolldown');
 
-// src/packages.ts
-
-
+// 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
+var _fs = require('fs'); var _fs2 = _interopRequireDefault(_fs);
+var _module = require('module');
 
 
-// src/utils.ts
-var _child_process = require('child_process');
 
+// 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
 
 
-var _pluginutils = require('@rollup/pluginutils');
+var _mlly = require('mlly');
+var _resolveexports = require('resolve.exports');
 
 // src/constants.ts
 
@@ -43,6 +66,27 @@ 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
+
+function canExternalizeFile(filePath) {
+  const ext = _path2.default.extname(filePath);
+  return !ext || ext === ".js" || ext === ".mjs" || ext === ".cjs";
+}
+
+// src/packages.ts
+
+
+
+var _process = require('process'); var _process2 = _interopRequireDefault(_process);
+
+// src/utils.ts
+var _child_process = require('child_process');
+
+
+
+
+var _pluginutils = require('@rollup/pluginutils');
+
 // src/sharedUtils.ts
 
 var isWindows = typeof _process2.default !== "undefined" && _process2.default.platform === "win32";
@@ -54,9 +98,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
@@ -146,8 +190,8 @@ function safeRealpathSync(filePath) {
   return currentSafeRealpathSync(filePath);
 }
 var windowsNetworkMap = /* @__PURE__ */ new Map();
-function windowsMappedRealpathSync(path6) {
-  const realPath = _fs2.default.realpathSync.native(path6);
+function windowsMappedRealpathSync(path11) {
+  const realPath = _fs2.default.realpathSync.native(path11);
   if (realPath.startsWith("\\\\")) {
     for (const [network, volume] of windowsNetworkMap) {
       if (realPath.startsWith(network)) {
@@ -159,12 +203,12 @@ function windowsMappedRealpathSync(path6) {
 }
 var parseNetUseRE = /^\w* +(\w:) +([^ ]+)\s/;
 var firstSafeRealPathSyncRun = false;
-function windowsSafeRealPathSync(path6) {
+function windowsSafeRealPathSync(path11) {
   if (!firstSafeRealPathSyncRun) {
     optimizeSafeRealPathSync();
     firstSafeRealPathSyncRun = true;
   }
-  return _fs2.default.realpathSync(path6);
+  return _fs2.default.realpathSync(path11);
 }
 function optimizeSafeRealPathSync() {
   const nodeVersion = _process2.default.versions.node.split(".").map(Number);
@@ -426,19 +470,6 @@ function traverseBetweenDirs(longerDir, shorterDir, cb) {
   }
 }
 
-// src/plugins/resolve.ts
-
-
-var _mlly = require('mlly');
-var _resolveexports = require('resolve.exports');
-
-// src/external.ts
-
-function canExternalizeFile(filePath) {
-  const ext = _path2.default.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";
@@ -789,8 +820,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);
@@ -821,214 +852,21 @@ function getRealPath(resolved, preserveSymlinks) {
   }
   return normalizePath(resolved);
 }
-function isDirectory(path6) {
-  const stat = tryStatSync(path6);
+function isDirectory(path11) {
+  const stat = tryStatSync(path11);
   return _nullishCoalesce(_optionalChain([stat, 'optionalAccess', _36 => _36.isDirectory, 'call', _37 => _37()]), () => ( false));
 }
 
-// src/index.ts
-var promisifiedRealpath = _util.promisify.call(void 0, _fs2.default.realpath);
-var configDefaults = Object.freeze({
-  resolve: {
-    extensions: [".mjs", ".js", ".mts", ".ts", ".jsx", ".tsx", ".json"]
-  }
-});
-var defaultGetOutputFile = (filepath, _format) => {
-  return filepath;
-};
-var cachedModuleSyncCondition;
-var moduleSyncConditionPromise;
-async function getModuleSyncConditionEnabled() {
-  if (cachedModuleSyncCondition !== void 0) {
-    return cachedModuleSyncCondition;
-  }
-  if (!moduleSyncConditionPromise) {
-    moduleSyncConditionPromise = Promise.resolve().then(() => _interopRequireWildcard(require(
-      // @ts-ignore
-      "#module-sync-enabled"
-    ))).then((mod) => Boolean(_optionalChain([mod, 'optionalAccess', _38 => _38.default]))).catch(() => false).then((result) => {
-      cachedModuleSyncCondition = result;
-      return result;
-    }).finally(() => {
-      moduleSyncConditionPromise = void 0;
-    });
-  }
-  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);
-  }
-}
-async function bundleFile(fileName, options) {
-  const { isESM } = options;
-  const moduleSyncEnabled = await getModuleSyncConditionEnabled();
-  const dirnameVarName = "__vite_injected_original_dirname";
-  const filenameVarName = "__vite_injected_original_filename";
-  const importMetaUrlVarName = "__vite_injected_original_import_meta_url";
-  const rolldownInputOptions = _optionalChain([options, 'optionalAccess', _39 => _39.rolldownOptions, 'optionalAccess', _40 => _40.input]) || {};
-  const bundle = await _rolldown.rolldown.call(void 0, {
-    ...rolldownInputOptions,
-    input: fileName,
-    // target: [`node${process.versions.node}`],
-    platform: "node",
-    resolve: {
-      mainFields: ["main"],
-      tsconfigFilename: options.tsconfig
-    },
-    define: {
-      "__dirname": dirnameVarName,
-      "__filename": filenameVarName,
-      "import.meta.url": importMetaUrlVarName,
-      "import.meta.dirname": dirnameVarName,
-      "import.meta.filename": filenameVarName
-    },
-    // disable treeshake to include files that is not sideeffectful to `moduleIds`
-    treeshake: false,
-    plugins: [
-      createExternalizeDepsPlugin({
-        entryFile: fileName,
-        isESM,
-        moduleSyncEnabled
-      }),
-      createFileScopeVariablesPlugin({
-        dirnameVarName,
-        filenameVarName,
-        importMetaUrlVarName
-      })
-    ],
-    external: options.external
-    // preserveEntrySignatures: 'exports-only'
-  });
-  const rolldownOutputOptions = _optionalChain([options, 'optionalAccess', _41 => _41.rolldownOptions, 'optionalAccess', _42 => _42.output]) || {};
-  const result = await bundle.generate({
-    ...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();
-  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]
-  };
-}
-var _require = _module.createRequire.call(void 0, importMetaUrl);
-async function loadFromBundledFile(fileName, bundledCode, options) {
-  const { isESM } = options;
-  if (isESM) {
-    let nodeModulesDir = typeof _process2.default.versions.deno === "string" ? void 0 : findNearestNodeModules(_path2.default.dirname(fileName));
-    if (nodeModulesDir) {
-      try {
-        await _promises2.default.mkdir(_path2.default.resolve(nodeModulesDir, ".vite-temp/"), {
-          recursive: true
-        });
-      } catch (e) {
-        if (e.code === "EACCES") {
-          nodeModulesDir = void 0;
-        } else {
-          throw e;
-        }
-      }
-    }
-    const hash = `timestamp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-    const tempFileName = nodeModulesDir ? _path2.default.resolve(
-      nodeModulesDir,
-      `.vite-temp/${_path2.default.basename(fileName)}.${hash}.${isESM ? "mjs" : "cjs"}`
-    ) : `${fileName}.${hash}.mjs`;
-    const getOutputFile = options.getOutputFile || defaultGetOutputFile;
-    const outfile = getOutputFile(tempFileName, options.format);
-    await _promises2.default.writeFile(outfile, bundledCode);
-    let mod;
-    const req = options.require || dynamicImport;
-    try {
-      mod = await req(
-        options.format === "esm" ? _url.pathToFileURL.call(void 0, outfile).href : outfile,
-        { format: options.format }
-      );
-      return mod;
-    } finally {
-      if (!_optionalChain([options, 'optionalAccess', _43 => _43.preserveTemporaryFile])) {
-        _fs2.default.unlink(outfile, () => {
-        });
-      }
-    }
-  } else {
-    const extension = _path2.default.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);
-      }
-    };
-    try {
-      _require.extensions[loaderExt] = compileLoader;
-      delete _require.cache[_require.resolve(fileName)];
-      const raw = _require(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
-  };
-}
+// src/externalize.ts
 function createExternalizeDepsPlugin({
   entryFile,
   isESM,
   moduleSyncEnabled
 }) {
+  const entryDir = _path2.default.dirname(entryFile);
   const packageCache = /* @__PURE__ */ new Map();
   const resolveByViteResolver = (id, importer, isRequire) => {
-    return _optionalChain([tryNodeResolve, 'call', _44 => _44(id, importer, {
+    return _optionalChain([tryNodeResolve, 'call', _38 => _38(id, importer, {
       root: _path2.default.dirname(entryFile),
       isBuild: true,
       isProduction: true,
@@ -1048,7 +886,7 @@ function createExternalizeDepsPlugin({
       packageCache,
       isRequire,
       builtins: nodeLikeBuiltins
-    }), 'optionalAccess', _45 => _45.id]);
+    }), 'optionalAccess', _39 => _39.id]);
   };
   return {
     name: "externalize-deps",
@@ -1092,14 +930,212 @@ function createExternalizeDepsPlugin({
         if (idFsPath.endsWith(".json")) {
           return idFsPath;
         }
-        if (idFsPath && isImport) {
+        const shouldExternalize = shouldExternalizeBareImport(id, importer, entryDir);
+        if (idFsPath && isImport && shouldExternalize) {
           idFsPath = _url.pathToFileURL.call(void 0, idFsPath).href;
         }
-        return { id: idFsPath, external: true };
+        return { id: idFsPath, external: shouldExternalize };
       }
     }
   };
 }
+function shouldExternalizeBareImport(specifier, importer, entryDir) {
+  if (!specifier || specifier.startsWith(".") || _path2.default.isAbsolute(specifier)) {
+    return false;
+  }
+  if (isNodeLikeBuiltin(specifier)) {
+    return true;
+  }
+  const importerPath = normalizeImporterPath(importer, entryDir);
+  try {
+    const containingNodeModules = findContainingNodeModules(
+      _module.createRequire.call(void 0, importerPath).resolve(specifier)
+    );
+    if (containingNodeModules) {
+      const ownerDir = _path2.default.dirname(containingNodeModules);
+      const ownerInsideEntry = isPathWithinDirectory(entryDir, ownerDir);
+      const entryInsideOwner = isPathWithinDirectory(ownerDir, entryDir);
+      if (ownerInsideEntry && !entryInsideOwner) {
+        return false;
+      }
+    }
+  } catch (e9) {
+  }
+  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 = _path2.default.dirname(filePath);
+  const { root } = _path2.default.parse(current);
+  while (true) {
+    if (_path2.default.basename(current) === "node_modules") {
+      return current;
+    }
+    if (current === root) {
+      break;
+    }
+    current = _path2.default.dirname(current);
+  }
+}
+function isPathWithinDirectory(parent, child) {
+  const relative = _path2.default.relative(parent, child);
+  return relative === "" || !relative.startsWith("..") && !_path2.default.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 (_fs2.default.existsSync(_path2.default.join(currentDir, "node_modules", packageName))) {
+      return true;
+    }
+    const parentDir = _path2.default.dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  return false;
+}
+
+// src/module-sync.ts
+var cachedModuleSyncCondition;
+var moduleSyncConditionPromise;
+async function getModuleSyncConditionEnabled() {
+  if (cachedModuleSyncCondition !== void 0) {
+    return cachedModuleSyncCondition;
+  }
+  if (!moduleSyncConditionPromise) {
+    moduleSyncConditionPromise = Promise.resolve().then(() => _interopRequireWildcard(require(
+      // @ts-ignore
+      "#module-sync-enabled"
+    ))).then((mod) => Boolean(_optionalChain([mod, 'optionalAccess', _40 => _40.default]))).catch(() => false).then((result) => {
+      cachedModuleSyncCondition = result;
+      return result;
+    }).finally(() => {
+      moduleSyncConditionPromise = void 0;
+    });
+  }
+  return moduleSyncConditionPromise;
+}
+
+// src/bundler.ts
+async function bundleFile(fileName, options) {
+  const { isESM } = options;
+  const moduleSyncEnabled = await getModuleSyncConditionEnabled();
+  const dirnameVarName = "__vite_injected_original_dirname";
+  const filenameVarName = "__vite_injected_original_filename";
+  const importMetaUrlVarName = "__vite_injected_original_import_meta_url";
+  const rolldownInputOptions = _optionalChain([options, 'optionalAccess', _41 => _41.rolldownOptions, 'optionalAccess', _42 => _42.input]) || {};
+  const {
+    transform: userTransform,
+    resolve: userResolve,
+    ...restRolldownInputOptions
+  } = rolldownInputOptions;
+  const transformDefine = {
+    ..._nullishCoalesce(_optionalChain([userTransform, 'optionalAccess', _43 => _43.define]), () => ( {})),
+    "__dirname": dirnameVarName,
+    "__filename": filenameVarName,
+    "import.meta.url": importMetaUrlVarName,
+    "import.meta.dirname": dirnameVarName,
+    "import.meta.filename": filenameVarName
+  };
+  const transformOptions = {
+    ..._nullishCoalesce(userTransform, () => ( {})),
+    define: transformDefine
+  };
+  const resolveOptions = {
+    ..._nullishCoalesce(userResolve, () => ( {})),
+    mainFields: ["main"],
+    tsconfigFilename: options.tsconfig
+  };
+  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.rolldown.call(void 0, {
+      ...restRolldownInputOptions,
+      input: fileName,
+      platform: "node",
+      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,
+          moduleSyncEnabled
+        }),
+        createFileScopeVariablesPlugin({
+          dirnameVarName,
+          filenameVarName,
+          importMetaUrlVarName
+        })
+      ],
+      external: options.external
+    });
+  } finally {
+    console.warn = originalConsoleWarn;
+  }
+  if (!bundle) {
+    throw new Error("Failed to initialize bundler");
+  }
+  const rolldownOutputOptions = _optionalChain([options, 'optionalAccess', _44 => _44.rolldownOptions, 'optionalAccess', _45 => _45.output]) || {};
+  const result = await bundle.generate({
+    ...rolldownOutputOptions,
+    format: options.format,
+    sourcemap: false,
+    inlineDynamicImports: true
+  });
+  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 createFileScopeVariablesPlugin({
   dirnameVarName,
   filenameVarName,
@@ -1118,6 +1154,362 @@ function createFileScopeVariablesPlugin({
     }
   };
 }
+
+// src/loader.ts
+
+
+
+var _util = require('util');
+
+// src/cache.ts
+var _crypto = require('crypto'); var _crypto2 = _interopRequireDefault(_crypto);
+
+var _promises = require('fs/promises'); var _promises2 = _interopRequireDefault(_promises);
+
+var _os = require('os'); var _os2 = _interopRequireDefault(_os);
+
+
+
+var _require = _module.createRequire.call(void 0, importMetaUrl);
+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) {
+    _optionalChain([onEvent, 'optionalCall', _46 => _46({ type: "skip-invalid", key: "", reason: "missing-entry" })]);
+    return {
+      enabled: false,
+      key: "",
+      dir,
+      reset,
+      entryPath: fileName,
+      memory,
+      onEvent
+    };
+  }
+  const hash = _crypto2.default.createHash("sha1");
+  hash.update(
+    JSON.stringify({
+      entry: _path2.default.resolve(fileName),
+      mtimeMs: stat.mtimeMs,
+      size: stat.size,
+      format: options.format,
+      isESM: options.isESM,
+      tsconfig: _nullishCoalesce(options.tsconfig, () => ( "auto")),
+      node: _process2.default.versions.node,
+      rolldown: hashRolldownOptions(options.rolldownOptions)
+    })
+  );
+  return {
+    enabled: true,
+    key: hash.digest("hex"),
+    dir,
+    reset,
+    entryPath: _path2.default.resolve(fileName),
+    memory,
+    onEvent
+  };
+}
+function resolveDefaultCacheDir(fileName) {
+  if (typeof _process2.default.versions.deno !== "string") {
+    const nearest = findNearestNodeModules(_path2.default.dirname(fileName));
+    if (nearest) {
+      return _path2.default.resolve(nearest, ".rolldown-require-cache");
+    }
+  }
+  return _path2.default.join(_os2.default.tmpdir(), "rolldown-require-cache");
+}
+async function maybeReadCache(cache, options) {
+  const metaPath = _path2.default.join(cache.dir, `${cache.key}.meta.json`);
+  const mem = cache.memory ? memoryCache.get(cache.key) : void 0;
+  if (_optionalChain([mem, 'optionalAccess', _47 => _47.meta])) {
+    const valid2 = validateMeta(mem.meta, options);
+    if (valid2 === true) {
+      _optionalChain([cache, 'access', _48 => _48.onEvent, 'optionalCall', _49 => _49({ type: "hit", key: cache.key, reason: "memory" })]);
+      return mem;
+    }
+    memoryCache.delete(cache.key);
+    _optionalChain([cache, 'access', _50 => _50.onEvent, 'optionalCall', _51 => _51({ type: "skip-invalid", key: cache.key, reason: valid2 })]);
+  }
+  const meta = await readCacheMeta(metaPath);
+  if (!meta) {
+    return;
+  }
+  const valid = validateMeta(meta, options);
+  if (valid !== true) {
+    _optionalChain([cache, 'access', _52 => _52.onEvent, 'optionalCall', _53 => _53({ type: "skip-invalid", key: cache.key, reason: valid })]);
+    return;
+  }
+  if (_optionalChain([mem, 'optionalAccess', _54 => _54.mod]) !== void 0 && cache.memory) {
+    const enriched = { mod: mem.mod, codePath: meta.codePath, meta };
+    memoryCache.set(cache.key, enriched);
+    _optionalChain([cache, 'access', _55 => _55.onEvent, 'optionalCall', _56 => _56({ 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" ? _url.pathToFileURL.call(void 0, cached.codePath).href : cached.codePath;
+  if (options.require) {
+    return options.require(target, { format: options.format });
+  }
+  if (options.format === "esm") {
+    return Promise.resolve().then(() => _interopRequireWildcard(require(target)));
+  }
+  return _require(target);
+}
+async function storeCacheOutput(cache, code, options, dependencies) {
+  await _promises2.default.mkdir(cache.dir, { recursive: true });
+  const ext = options.format === "cjs" ? "cjs" : "mjs";
+  const codePath = _path2.default.join(cache.dir, `${cache.key}.code.${ext}`);
+  if (cache.reset) {
+    await Promise.allSettled([
+      _promises2.default.rm(codePath, { force: true }),
+      _promises2.default.rm(_path2.default.join(cache.dir, `${cache.key}.meta.json`), { force: true })
+    ]);
+  }
+  await _promises2.default.writeFile(codePath, code);
+  const trackedFiles = collectFileStats([
+    cache.entryPath,
+    ..._nullishCoalesce(dependencies, () => ( []))
+  ]);
+  return {
+    outfile: options.format === "esm" ? _url.pathToFileURL.call(void 0, codePath).href : codePath,
+    cleanup: async () => {
+    },
+    cacheMeta: {
+      format: options.format,
+      codePath,
+      files: trackedFiles
+    }
+  };
+}
+async function writeCacheMeta(cache, meta) {
+  await _promises2.default.mkdir(cache.dir, { recursive: true });
+  await _promises2.default.writeFile(
+    _path2.default.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 (_optionalChain([stat, 'optionalAccess', _57 => _57.isFile, 'call', _58 => _58()])) {
+      stats.push({
+        path: _path2.default.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 _promises2.default.readFile(metaPath, "utf-8");
+    return JSON.parse(raw);
+  } catch (e10) {
+  }
+  return void 0;
+}
+function validateMeta(meta, options) {
+  if (meta.format !== options.format) {
+    return "format-mismatch";
+  }
+  if (!meta.codePath || !_fs2.default.existsSync(meta.codePath)) {
+    return "missing-code";
+  }
+  for (const file of _nullishCoalesce(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 _crypto2.default.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
+var _buffer = require('buffer');
+
+
+
+
+
+function sanitizeFilename(name) {
+  return name.replace(/[^\w.-]/g, "_");
+}
+async function resolveTempOutputFile(sourceFile, code, options) {
+  const getOutputFile = options.getOutputFile || defaultGetOutputFile;
+  const filenameHint = sanitizeFilename(_path2.default.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 _process2.default.versions.deno !== "string") {
+    const nearest = findNearestNodeModules(_path2.default.dirname(sourceFile));
+    if (nearest) {
+      candidates.push(_path2.default.resolve(nearest, ".rolldown-require"));
+    }
+  }
+  candidates.push(_path2.default.join(_os2.default.tmpdir(), "rolldown-require"));
+  for (const base of candidates) {
+    const target = getOutputFile(_path2.default.join(base, fileName), options.format);
+    try {
+      await _promises2.default.mkdir(_path2.default.dirname(target), { recursive: true });
+      await _promises2.default.writeFile(target, code);
+      const cleanup = async () => {
+        if (options.preserveTemporaryFile) {
+          return;
+        }
+        try {
+          await _promises2.default.unlink(target);
+        } catch (e11) {
+        }
+      };
+      return {
+        outfile: options.format === "esm" ? _url.pathToFileURL.call(void 0, target).href : target,
+        cleanup
+      };
+    } catch (e12) {
+    }
+  }
+  if (options.format === "esm") {
+    const dataUrl = `data:text/javascript;base64,${_buffer.Buffer.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 = _module.createRequire.call(void 0, importMetaUrl);
+var promisifiedRealpath = _util.promisify.call(void 0, _fs2.default.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) {
+        _optionalChain([cacheConfig, 'access', _59 => _59.onEvent, 'optionalCall', _60 => _60({ type: "hit", key: cacheConfig.key })]);
+      }
+      return importCachedCode(cached, options);
+    }
+    _optionalChain([cacheConfig, 'access', _61 => _61.onEvent, 'optionalCall', _62 => _62({ 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 = _optionalChain([tempOutput, 'optionalAccess', _63 => _63.outfile]);
+    const cleanup = _optionalChain([tempOutput, 'optionalAccess', _64 => _64.cleanup]);
+    let mod;
+    const req = options.require || dynamicImport;
+    try {
+      mod = await req(outfile, { format: options.format });
+      if (cacheConfig.enabled && _optionalChain([tempOutput, 'optionalAccess', _65 => _65.cacheMeta])) {
+        await writeCacheMeta(cacheConfig, tempOutput.cacheMeta);
+        _optionalChain([cacheConfig, 'access', _66 => _66.onEvent, 'optionalCall', _67 => _67({ type: "store", key: cacheConfig.key })]);
+        writeMemoryCache(cacheConfig, mod, tempOutput.cacheMeta);
+      }
+      return mod;
+    } finally {
+      if (!cacheConfig.enabled) {
+        await _optionalChain([cleanup, 'optionalCall', _68 => _68()]);
+      }
+    }
+  } else {
+    const extension = _path2.default.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);
+        _optionalChain([cacheConfig, 'access', _69 => _69.onEvent, 'optionalCall', _70 => _70({ type: "store", key: cacheConfig.key })]);
+        writeMemoryCache(
+          cacheConfig,
+          raw.__esModule ? raw.default : raw,
+          cachedPath.cacheMeta
+        );
+      }
+    }
+  }
+}
+
+// src/options.ts
+
+
+var _gettsconfig = require('get-tsconfig');
 function resolveEntryFilepath(options) {
   if (_path2.default.isAbsolute(options.filepath)) {
     return options.filepath;
@@ -1150,7 +1542,28 @@ function resolveTsconfigPath(options) {
   if (typeof options.tsconfig === "string") {
     return options.tsconfig;
   }
-  return _nullishCoalesce(_optionalChain([_gettsconfig.getTsconfig.call(void 0, options.cwd, "tsconfig.json"), 'optionalAccess', _46 => _46.path]), () => ( void 0));
+  return _nullishCoalesce(_optionalChain([_gettsconfig.getTsconfig.call(void 0, options.cwd, "tsconfig.json"), 'optionalAccess', _71 => _71.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
+  };
 }