rolldown-require 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1151 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+var _chunkQ6XJHTDBcjs = require('./chunk-Q6XJHTDB.cjs');
+
+// src/index.ts
+var _fs = require('fs'); var _fs2 = _interopRequireDefault(_fs);
+var _promises = require('fs/promises'); var _promises2 = _interopRequireDefault(_promises);
+var _module = require('module');
+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/utils.ts
+var _child_process = require('child_process');
+var _crypto = require('crypto'); var _crypto2 = _interopRequireDefault(_crypto);
+var _dns = require('dns');
+
+
+
+
+
+
+var _pluginutils = require('@rollup/pluginutils');
+
+// src/constants.ts
+
+
+
+var { version } = JSON.parse(
+  _fs.readFileSync.call(void 0, new URL("../package.json", _chunkQ6XJHTDBcjs.importMetaUrl)).toString()
+);
+var DEFAULT_MAIN_FIELDS = [
+  "browser",
+  "module",
+  "jsnext:main",
+  // moment still uses this...
+  "jsnext"
+];
+var DEFAULT_CLIENT_MAIN_FIELDS = Object.freeze(DEFAULT_MAIN_FIELDS);
+var DEFAULT_SERVER_MAIN_FIELDS = Object.freeze(
+  DEFAULT_MAIN_FIELDS.filter((f) => f !== "browser")
+);
+var DEV_PROD_CONDITION = `development|production`;
+var DEFAULT_CONDITIONS = ["module", "browser", "node", DEV_PROD_CONDITION];
+var DEFAULT_CLIENT_CONDITIONS = Object.freeze(
+  DEFAULT_CONDITIONS.filter((c) => c !== "node")
+);
+var DEFAULT_SERVER_CONDITIONS = Object.freeze(
+  DEFAULT_CONDITIONS.filter((c) => c !== "browser")
+);
+var OPTIMIZABLE_ENTRY_RE = /\.[cm]?[jt]s$/;
+var SPECIAL_QUERY_RE = /[?&](?:worker|sharedworker|raw|url)\b/;
+var FS_PREFIX = `/@fs/`;
+var CLIENT_PUBLIC_PATH = `/@vite/client`;
+var ENV_PUBLIC_PATH = `/@vite/env`;
+var VITE_PACKAGE_DIR = _path.resolve.call(void 0, 
+  // import.meta.url is `dist/node/constants.js` after bundle
+  _url.fileURLToPath.call(void 0, _chunkQ6XJHTDBcjs.importMetaUrl),
+  "../../.."
+);
+var CLIENT_ENTRY = _path.resolve.call(void 0, VITE_PACKAGE_DIR, "dist/client/client.mjs");
+var ENV_ENTRY = _path.resolve.call(void 0, VITE_PACKAGE_DIR, "dist/client/env.mjs");
+var CLIENT_DIR = _path2.default.dirname(CLIENT_ENTRY);
+var VALID_ID_PREFIX = `/@id/`;
+var SOURCEMAPPING_URL = "sourceMa";
+SOURCEMAPPING_URL += "ppingURL";
+
+// src/sharedUtils.ts
+
+var isWindows = typeof _process2.default !== "undefined" && _process2.default.platform === "win32";
+var windowsSlashRE = /\\/g;
+function slash(p) {
+  return p.replace(windowsSlashRE, "/");
+}
+var postfixRE = /[?#].*$/;
+function cleanUrl(url) {
+  return url.replace(postfixRE, "");
+}
+function splitFileAndPostfix(path7) {
+  const file = cleanUrl(path7);
+  return { file, postfix: path7.slice(file.length) };
+}
+var AsyncFunction = async function() {
+}.constructor;
+
+// src/utils.ts
+
+var _filter = require('rolldown/filter');
+var createFilter = _pluginutils.createFilter;
+var NODE_BUILTIN_NAMESPACE = "node:";
+var NPM_BUILTIN_NAMESPACE = "npm:";
+var BUN_BUILTIN_NAMESPACE = "bun:";
+var nodeBuiltins = _module.builtinModules.filter((id) => !id.includes(":"));
+var 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);
+}
+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}`)
+];
+function isNodeLikeBuiltin(id) {
+  return isBuiltin(nodeLikeBuiltins, id);
+}
+function isNodeBuiltin(id) {
+  if (id.startsWith(NODE_BUILTIN_NAMESPACE)) {
+    return true;
+  }
+  return nodeBuiltins.includes(id);
+}
+function isInNodeModules(id) {
+  return id.includes("node_modules");
+}
+function isOptimizable(id, optimizeDeps) {
+  const { extensions } = optimizeDeps;
+  return OPTIMIZABLE_ENTRY_RE.test(id) || (_nullishCoalesce(_optionalChain([extensions, 'optionalAccess', _ => _.some, 'call', _2 => _2((ext) => id.endsWith(ext))]), () => ( false)));
+}
+var bareImportRE = /^(?![a-z]:)[\w@](?!.*:\/\/)/i;
+var deepImportRE = /^([^@][^/]*)\/|^(@[^/]+\/[^/]+)\//;
+var _require = _module.createRequire.call(void 0, _chunkQ6XJHTDBcjs.importMetaUrl);
+var _dirname = _path2.default.dirname(_url.fileURLToPath.call(void 0, _chunkQ6XJHTDBcjs.importMetaUrl));
+var urlCanParse = _nullishCoalesce(_url.URL.canParse, () => ( ((path7, base) => {
+  try {
+    new (0, _url.URL)(path7, base);
+    return true;
+  } catch (e2) {
+    return false;
+  }
+})));
+function normalizePath(id) {
+  return _path2.default.posix.normalize(isWindows ? slash(id) : id);
+}
+var internalPrefixes = [
+  FS_PREFIX,
+  VALID_ID_PREFIX,
+  CLIENT_PUBLIC_PATH,
+  ENV_PUBLIC_PATH
+];
+var InternalPrefixRE = new RegExp(`^(?:${internalPrefixes.join("|")})`);
+function injectQuery(url, queryToInject) {
+  const { file, postfix } = splitFileAndPostfix(url);
+  const normalizedFile = isWindows ? slash(file) : file;
+  return `${normalizedFile}?${queryToInject}${postfix[0] === "?" ? `&${postfix.slice(1)}` : (
+    /* hash only */
+    postfix
+  )}`;
+}
+function isObject(value) {
+  return Object.prototype.toString.call(value) === "[object Object]";
+}
+function tryStatSync(file) {
+  try {
+    return _fs2.default.statSync(file, { throwIfNoEntry: false });
+  } catch (e3) {
+  }
+}
+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.default.dirname(filePath), packageCache);
+      return _optionalChain([pkg, 'optionalAccess', _3 => _3.data, 'access', _4 => _4.type]) === "module";
+    } catch (e4) {
+      return false;
+    }
+  }
+}
+var safeRealpathSync = isWindows ? windowsSafeRealPathSync : _fs2.default.realpathSync.native;
+var windowsNetworkMap = /* @__PURE__ */ new Map();
+function windowsMappedRealpathSync(path7) {
+  const realPath = _fs2.default.realpathSync.native(path7);
+  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(path7) {
+  if (!firstSafeRealPathSyncRun) {
+    optimizeSafeRealPathSync();
+    firstSafeRealPathSyncRun = true;
+  }
+  return _fs2.default.realpathSync(path7);
+}
+function optimizeSafeRealPathSync() {
+  const nodeVersion = _process2.default.versions.node.split(".").map(Number);
+  if (nodeVersion[0] < 18 || nodeVersion[0] === 18 && nodeVersion[1] < 10) {
+    safeRealpathSync = _fs2.default.realpathSync;
+    return;
+  }
+  try {
+    _fs2.default.realpathSync.native(_path2.default.resolve("./"));
+  } catch (error) {
+    if (error.message.includes("EISDIR: illegal operation on a directory")) {
+      safeRealpathSync = _fs2.default.realpathSync;
+      return;
+    }
+  }
+  _child_process.exec.call(void 0, "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]);
+      }
+    }
+    if (windowsNetworkMap.size === 0) {
+      safeRealpathSync = _fs2.default.realpathSync.native;
+    } else {
+      safeRealpathSync = windowsMappedRealpathSync;
+    }
+  });
+}
+var hash = _nullishCoalesce(_crypto2.default.hash, () => ( ((algorithm, data, outputEncoding) => _crypto2.default.createHash(algorithm).update(data).digest(outputEncoding))));
+function stripBomTag(content) {
+  if (content.charCodeAt(0) === 65279) {
+    return content.slice(1);
+  }
+  return content;
+}
+function getNpmPackageName(importPath) {
+  const parts = importPath.split("/");
+  if (parts[0][0] === "@") {
+    if (!parts[1]) {
+      return null;
+    }
+    return `${parts[0]}/${parts[1]}`;
+  } else {
+    return parts[0];
+  }
+}
+var dynamicImport = async (id, { format }) => {
+  const fn = format === "esm" ? (file) => Promise.resolve().then(() => _interopRequireWildcard(require(file))) : false ? _module.createRequire.call(void 0, _chunkQ6XJHTDBcjs.importMetaUrl) : _chunkQ6XJHTDBcjs.__require;
+  return fn(id);
+};
+
+// src/packages.ts
+var pnp;
+if (_process2.default.versions.pnp) {
+  try {
+    pnp = _module.createRequire.call(void 0, (0, _chunkQ6XJHTDBcjs.importMetaUrl))("pnpapi");
+  } catch (e5) {
+  }
+}
+function resolvePackageData(pkgName, basedir, preserveSymlinks = false, packageCache) {
+  if (pnp) {
+    const cacheKey = getRpdCacheKey(pkgName, basedir, preserveSymlinks);
+    if (_optionalChain([packageCache, 'optionalAccess', _5 => _5.has, 'call', _6 => _6(cacheKey)])) {
+      return packageCache.get(cacheKey);
+    }
+    try {
+      const pkg = pnp.resolveToUnqualified(pkgName, basedir, {
+        considerBuiltins: false
+      });
+      if (!pkg) {
+        return null;
+      }
+      const pkgData = loadPackageData(_path2.default.join(pkg, "package.json"));
+      _optionalChain([packageCache, 'optionalAccess', _7 => _7.set, 'call', _8 => _8(cacheKey, pkgData)]);
+      return pkgData;
+    } catch (e6) {
+      return null;
+    }
+  }
+  const originalBasedir = basedir;
+  while (basedir) {
+    if (packageCache) {
+      const cached = getRpdCache(
+        packageCache,
+        pkgName,
+        basedir,
+        originalBasedir,
+        preserveSymlinks
+      );
+      if (cached) {
+        return cached;
+      }
+    }
+    const pkg = _path2.default.join(basedir, "node_modules", pkgName, "package.json");
+    try {
+      if (_fs2.default.existsSync(pkg)) {
+        const pkgPath = preserveSymlinks ? pkg : safeRealpathSync(pkg);
+        const pkgData = loadPackageData(pkgPath);
+        if (packageCache) {
+          setRpdCache(
+            packageCache,
+            pkgData,
+            pkgName,
+            basedir,
+            originalBasedir,
+            preserveSymlinks
+          );
+        }
+        return pkgData;
+      }
+    } catch (e7) {
+    }
+    const nextBasedir = _path2.default.dirname(basedir);
+    if (nextBasedir === basedir) {
+      break;
+    }
+    basedir = nextBasedir;
+  }
+  return null;
+}
+function findNearestPackageData(basedir, packageCache) {
+  const originalBasedir = basedir;
+  while (basedir) {
+    if (packageCache) {
+      const cached = getFnpdCache(packageCache, basedir, originalBasedir);
+      if (cached) {
+        return cached;
+      }
+    }
+    const pkgPath = _path2.default.join(basedir, "package.json");
+    if (_optionalChain([tryStatSync, 'call', _9 => _9(pkgPath), 'optionalAccess', _10 => _10.isFile, 'call', _11 => _11()])) {
+      try {
+        const pkgData = loadPackageData(pkgPath);
+        if (packageCache) {
+          setFnpdCache(packageCache, pkgData, basedir, originalBasedir);
+        }
+        return pkgData;
+      } catch (e8) {
+      }
+    }
+    const nextBasedir = _path2.default.dirname(basedir);
+    if (nextBasedir === basedir) {
+      break;
+    }
+    basedir = nextBasedir;
+  }
+  return null;
+}
+function findNearestMainPackageData(basedir, packageCache) {
+  const nearestPackage = findNearestPackageData(basedir, packageCache);
+  return nearestPackage && (nearestPackage.data.name ? nearestPackage : findNearestMainPackageData(
+    _path2.default.dirname(nearestPackage.dir),
+    packageCache
+  ));
+}
+function loadPackageData(pkgPath) {
+  const data = JSON.parse(stripBomTag(_fs2.default.readFileSync(pkgPath, "utf-8")));
+  const pkgDir = normalizePath(_path2.default.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;
+}
+function getResolveCacheKey(key, options) {
+  return [
+    key,
+    options.isRequire ? "1" : "0",
+    options.conditions.join("_"),
+    options.extensions.join("_"),
+    options.mainFields.join("_")
+  ].join("|");
+}
+function findNearestNodeModules(basedir) {
+  while (basedir) {
+    const pkgPath = _path2.default.join(basedir, "node_modules");
+    if (_optionalChain([tryStatSync, 'call', _12 => _12(pkgPath), 'optionalAccess', _13 => _13.isDirectory, 'call', _14 => _14()])) {
+      return pkgPath;
+    }
+    const nextBasedir = _path2.default.dirname(basedir);
+    if (nextBasedir === basedir) {
+      break;
+    }
+    basedir = nextBasedir;
+  }
+  return null;
+}
+function getRpdCache(packageCache, pkgName, basedir, originalBasedir, preserveSymlinks) {
+  const cacheKey = getRpdCacheKey(pkgName, basedir, preserveSymlinks);
+  const pkgData = packageCache.get(cacheKey);
+  if (pkgData) {
+    traverseBetweenDirs(originalBasedir, basedir, (dir) => {
+      packageCache.set(getRpdCacheKey(pkgName, dir, preserveSymlinks), pkgData);
+    });
+    return pkgData;
+  }
+}
+function setRpdCache(packageCache, pkgData, pkgName, basedir, originalBasedir, preserveSymlinks) {
+  packageCache.set(getRpdCacheKey(pkgName, basedir, preserveSymlinks), pkgData);
+  traverseBetweenDirs(originalBasedir, basedir, (dir) => {
+    packageCache.set(getRpdCacheKey(pkgName, dir, preserveSymlinks), pkgData);
+  });
+}
+function getRpdCacheKey(pkgName, basedir, preserveSymlinks) {
+  return `rpd_${pkgName}_${basedir}_${preserveSymlinks}`;
+}
+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;
+  }
+}
+function setFnpdCache(packageCache, pkgData, basedir, originalBasedir) {
+  packageCache.set(getFnpdCacheKey(basedir), pkgData);
+  traverseBetweenDirs(originalBasedir, basedir, (dir) => {
+    packageCache.set(getFnpdCacheKey(dir), pkgData);
+  });
+}
+function getFnpdCacheKey(basedir) {
+  return `fnpd_${basedir}`;
+}
+function traverseBetweenDirs(longerDir, shorterDir, cb) {
+  while (longerDir !== shorterDir) {
+    cb(longerDir);
+    longerDir = _path2.default.dirname(longerDir);
+  }
+}
+
+// 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";
+var optionalPeerDepId = "__vite-optional-peer-dep";
+function tryFsResolve(fsPath, options, tryIndex = true, skipPackageJson = false) {
+  const hashIndex = fsPath.indexOf("#");
+  if (hashIndex >= 0 && isInNodeModules(fsPath)) {
+    const queryIndex = fsPath.indexOf("?");
+    if (queryIndex < 0 || queryIndex > hashIndex) {
+      const file2 = queryIndex > hashIndex ? fsPath.slice(0, queryIndex) : fsPath;
+      const res2 = tryCleanFsResolve(file2, options, tryIndex, skipPackageJson);
+      if (res2) {
+        return res2 + fsPath.slice(file2.length);
+      }
+    }
+  }
+  const { file, postfix } = splitFileAndPostfix(fsPath);
+  const res = tryCleanFsResolve(file, options, tryIndex, skipPackageJson);
+  if (res) {
+    return res + postfix;
+  }
+}
+var knownTsOutputRE = /\.(?:js|mjs|cjs|jsx)$/;
+var isPossibleTsOutput = (url) => knownTsOutputRE.test(url);
+function tryCleanFsResolve(file, options, tryIndex = true, skipPackageJson = false) {
+  const { tryPrefix, extensions, preserveSymlinks } = options;
+  const fileResult = tryResolveRealFileOrType(file, options.preserveSymlinks);
+  if (_optionalChain([fileResult, 'optionalAccess', _15 => _15.path])) {
+    return fileResult.path;
+  }
+  let res;
+  const possibleJsToTs = isPossibleTsOutput(file);
+  if (possibleJsToTs || options.extensions.length || tryPrefix) {
+    const dirPath = _path2.default.dirname(file);
+    if (isDirectory(dirPath)) {
+      if (possibleJsToTs) {
+        const fileExt = _path2.default.extname(file);
+        const fileName = file.slice(0, -fileExt.length);
+        if (res = tryResolveRealFile(
+          fileName + fileExt.replace("js", "ts"),
+          preserveSymlinks
+        )) {
+          return res;
+        }
+        if (fileExt === ".js" && (res = tryResolveRealFile(`${fileName}.tsx`, preserveSymlinks))) {
+          return res;
+        }
+      }
+      if (res = tryResolveRealFileWithExtensions(
+        file,
+        extensions,
+        preserveSymlinks
+      )) {
+        return res;
+      }
+      if (tryPrefix) {
+        const prefixed = `${dirPath}/${options.tryPrefix}${_path2.default.basename(file)}`;
+        if (res = tryResolveRealFile(prefixed, preserveSymlinks)) {
+          return res;
+        }
+        if (res = tryResolveRealFileWithExtensions(
+          prefixed,
+          extensions,
+          preserveSymlinks
+        )) {
+          return res;
+        }
+      }
+    }
+  }
+  if (tryIndex && _optionalChain([fileResult, 'optionalAccess', _16 => _16.type]) === "directory") {
+    const dirPath = file;
+    if (!skipPackageJson) {
+      let pkgPath = `${dirPath}/package.json`;
+      try {
+        if (_fs2.default.existsSync(pkgPath)) {
+          if (!options.preserveSymlinks) {
+            pkgPath = safeRealpathSync(pkgPath);
+          }
+          const pkg = loadPackageData(pkgPath);
+          return resolvePackageEntry(dirPath, pkg, options);
+        }
+      } catch (e) {
+        if (e.code !== ERR_RESOLVE_PACKAGE_ENTRY_FAIL && e.code !== "ENOENT") {
+          throw e;
+        }
+      }
+    }
+    if (res = tryResolveRealFileWithExtensions(
+      `${dirPath}/index`,
+      extensions,
+      preserveSymlinks
+    )) {
+      return res;
+    }
+    if (tryPrefix) {
+      if (res = tryResolveRealFileWithExtensions(
+        `${dirPath}/${options.tryPrefix}index`,
+        extensions,
+        preserveSymlinks
+      )) {
+        return res;
+      }
+    }
+  }
+}
+function tryNodeResolve(id, importer, options, depsOptimizer, externalize) {
+  const { root, dedupe, isBuild, preserveSymlinks, packageCache } = options;
+  const deepMatch = deepImportRE.exec(id);
+  const pkgId = deepMatch ? deepMatch[1] || deepMatch[2] : cleanUrl(id);
+  let basedir;
+  if (dedupe.includes(pkgId)) {
+    basedir = root;
+  } else if (importer && _path2.default.isAbsolute(importer) && (importer.endsWith("*") || _fs2.default.existsSync(cleanUrl(importer)))) {
+    basedir = _path2.default.dirname(importer);
+  } else {
+    basedir = root;
+  }
+  const isModuleBuiltin = (id2) => isBuiltin(options.builtins, id2);
+  let selfPkg = null;
+  if (!isModuleBuiltin(id) && !id.includes("\0") && bareImportRE.test(id)) {
+    const selfPackageData = findNearestPackageData(basedir, packageCache);
+    selfPkg = _optionalChain([selfPackageData, 'optionalAccess', _17 => _17.data, 'access', _18 => _18.exports]) && selfPackageData.data.name === pkgId ? selfPackageData : null;
+  }
+  const pkg = selfPkg || resolvePackageData(pkgId, basedir, preserveSymlinks, packageCache);
+  if (!pkg) {
+    if (basedir !== root && !isModuleBuiltin(id) && !id.includes("\0") && bareImportRE.test(id)) {
+      const mainPkg = _optionalChain([findNearestMainPackageData, 'call', _19 => _19(basedir, packageCache), 'optionalAccess', _20 => _20.data]);
+      if (mainPkg) {
+        const pkgName = getNpmPackageName(id);
+        if (pkgName != null && _optionalChain([mainPkg, 'access', _21 => _21.peerDependencies, 'optionalAccess', _22 => _22[pkgName]]) && _optionalChain([mainPkg, 'access', _23 => _23.peerDependenciesMeta, 'optionalAccess', _24 => _24[pkgName], 'optionalAccess', _25 => _25.optional])) {
+          return {
+            id: `${optionalPeerDepId}:${id}:${mainPkg.name}`
+          };
+        }
+      }
+    }
+    return;
+  }
+  const resolveId = deepMatch ? resolveDeepImport : resolvePackageEntry;
+  const unresolvedId = deepMatch ? `.${id.slice(pkgId.length)}` : id;
+  let resolved = resolveId(unresolvedId, pkg, options);
+  if (!resolved) {
+    return;
+  }
+  const processResult = (resolved2) => {
+    if (!externalize) {
+      return resolved2;
+    }
+    if (!canExternalizeFile(resolved2.id)) {
+      return resolved2;
+    }
+    let resolvedId = id;
+    if (deepMatch && !pkg.data.exports && _path2.default.extname(id) !== _path2.default.extname(resolved2.id)) {
+      const index = resolved2.id.indexOf(id);
+      if (index > -1) {
+        resolvedId = resolved2.id.slice(index);
+      }
+    }
+    return { ...resolved2, id: resolvedId, external: true };
+  };
+  if (!options.idOnly && (!options.scan && isBuild || externalize)) {
+    return processResult({
+      id: resolved,
+      moduleSideEffects: pkg.hasSideEffects(resolved)
+    });
+  }
+  if (!isInNodeModules(resolved) || !depsOptimizer || options.scan) {
+    return { id: resolved };
+  }
+  const isJsType = isOptimizable(resolved, depsOptimizer.options);
+  const exclude = depsOptimizer.options.exclude;
+  const skipOptimization = depsOptimizer.options.noDiscovery || !isJsType || importer && isInNodeModules(importer) || _optionalChain([exclude, 'optionalAccess', _26 => _26.includes, 'call', _27 => _27(pkgId)]) || _optionalChain([exclude, 'optionalAccess', _28 => _28.includes, 'call', _29 => _29(id)]) || SPECIAL_QUERY_RE.test(resolved);
+  if (skipOptimization) {
+    const versionHash = depsOptimizer.metadata.browserHash;
+    if (versionHash && isJsType) {
+      resolved = injectQuery(resolved, `v=${versionHash}`);
+    }
+  } else {
+    const optimizedInfo = depsOptimizer.registerMissingImport(id, resolved);
+    resolved = depsOptimizer.getOptimizedDepId(optimizedInfo);
+  }
+  return { id: resolved };
+}
+function resolvePackageEntry(id, { dir, data, setResolvedCache, getResolvedCache }, options) {
+  const { postfix } = splitFileAndPostfix(id);
+  const cached = getResolvedCache(".", options);
+  if (cached) {
+    return cached + postfix;
+  }
+  try {
+    let entryPoint;
+    if (data.exports) {
+      entryPoint = resolveExportsOrImports(data, ".", options, "exports");
+    }
+    if (!entryPoint) {
+      for (const field of options.mainFields) {
+        if (field === "browser") {
+          entryPoint = tryResolveBrowserEntry(dir, data, options);
+          if (entryPoint) {
+            break;
+          }
+        } else if (typeof data[field] === "string") {
+          entryPoint = data[field];
+          break;
+        }
+      }
+    }
+    entryPoint ||= data.main;
+    const entryPoints = entryPoint ? [entryPoint] : ["index.js", "index.json", "index.node"];
+    for (let entry of entryPoints) {
+      let skipPackageJson = false;
+      if (options.mainFields[0] === "sass" && !options.extensions.includes(_path2.default.extname(entry))) {
+        entry = "";
+        skipPackageJson = true;
+      } else {
+        const { browser: browserField } = data;
+        if (options.mainFields.includes("browser") && isObject(browserField)) {
+          entry = mapWithBrowserField(entry, browserField) || entry;
+        }
+      }
+      const entryPointPath = _path2.default.join(dir, entry);
+      const resolvedEntryPoint = tryFsResolve(
+        entryPointPath,
+        options,
+        true,
+        skipPackageJson
+      );
+      if (resolvedEntryPoint) {
+        setResolvedCache(".", resolvedEntryPoint, options);
+        return resolvedEntryPoint + postfix;
+      }
+    }
+  } catch (e) {
+    packageEntryFailure(
+      id,
+      // @ts-ignore
+      e.message
+    );
+  }
+  packageEntryFailure(id);
+}
+function packageEntryFailure(id, details) {
+  const err = new Error(
+    `Failed to resolve entry for package "${id}". The package may have incorrect main/module/exports specified in its package.json${details ? `: ${details}` : "."}`
+  );
+  err.code = ERR_RESOLVE_PACKAGE_ENTRY_FAIL;
+  throw err;
+}
+function getConditions(conditions, isProduction, isRequire) {
+  const resolvedConditions = conditions.map((condition) => {
+    if (condition === DEV_PROD_CONDITION) {
+      return isProduction ? "production" : "development";
+    }
+    return condition;
+  });
+  if (isRequire) {
+    resolvedConditions.push("require");
+  } else {
+    resolvedConditions.push("import");
+  }
+  return resolvedConditions;
+}
+function resolveExportsOrImports(pkg, key, options, type) {
+  const conditions = getConditions(
+    options.conditions,
+    options.isProduction,
+    options.isRequire
+  );
+  const fn = type === "imports" ? _resolveexports.imports : _resolveexports.exports;
+  const result = fn(pkg, key, { conditions, unsafe: true });
+  return result ? result[0] : void 0;
+}
+function resolveDeepImport(id, { setResolvedCache, getResolvedCache, dir, data }, options) {
+  const cache = getResolvedCache(id, options);
+  if (cache) {
+    return cache;
+  }
+  let relativeId = id;
+  const { exports: exportsField, browser: browserField } = data;
+  if (exportsField) {
+    if (isObject(exportsField) && !Array.isArray(exportsField)) {
+      const { file, postfix } = splitFileAndPostfix(relativeId);
+      const exportsId = resolveExportsOrImports(data, file, options, "exports");
+      if (exportsId !== void 0) {
+        relativeId = exportsId + postfix;
+      } else {
+        relativeId = void 0;
+      }
+    } else {
+      relativeId = void 0;
+    }
+    if (!relativeId) {
+      throw new Error(
+        `Package subpath '${relativeId}' is not defined by "exports" in ${_path2.default.join(dir, "package.json")}.`
+      );
+    }
+  } else if (options.mainFields.includes("browser") && isObject(browserField)) {
+    const { file, postfix } = splitFileAndPostfix(relativeId);
+    const mapped = mapWithBrowserField(file, browserField);
+    if (mapped) {
+      relativeId = mapped + postfix;
+    } else if (mapped === false) {
+      setResolvedCache(id, browserExternalId, options);
+      return browserExternalId;
+    }
+  }
+  if (relativeId) {
+    const resolved = tryFsResolve(
+      _path2.default.join(dir, relativeId),
+      options,
+      !exportsField
+      // try index only if no exports field
+    );
+    if (resolved) {
+      setResolvedCache(id, resolved, options);
+      return resolved;
+    }
+  }
+}
+function tryResolveBrowserEntry(dir, data, options) {
+  const browserEntry = typeof data.browser === "string" ? data.browser : isObject(data.browser) && data.browser["."];
+  if (browserEntry) {
+    if (!options.isRequire && options.mainFields.includes("module") && typeof data.module === "string" && data.module !== browserEntry) {
+      const resolvedBrowserEntry = tryFsResolve(
+        _path2.default.join(dir, browserEntry),
+        options
+      );
+      if (resolvedBrowserEntry) {
+        const content = _fs2.default.readFileSync(resolvedBrowserEntry, "utf-8");
+        if (_mlly.hasESMSyntax.call(void 0, content)) {
+          return browserEntry;
+        } else {
+          return data.module;
+        }
+      }
+    } else {
+      return browserEntry;
+    }
+  }
+}
+function mapWithBrowserField(relativePathInPkgDir, map) {
+  const normalizedPath = _path2.default.posix.normalize(relativePathInPkgDir);
+  for (const key in map) {
+    const normalizedKey = _path2.default.posix.normalize(key);
+    if (normalizedPath === normalizedKey || equalWithoutSuffix(normalizedPath, normalizedKey, ".js") || equalWithoutSuffix(normalizedPath, normalizedKey, "/index.js")) {
+      return map[key];
+    }
+  }
+}
+function equalWithoutSuffix(path7, key, suffix) {
+  return key.endsWith(suffix) && key.slice(0, -suffix.length) === path7;
+}
+function tryResolveRealFile(file, preserveSymlinks) {
+  const stat = tryStatSync(file);
+  if (_optionalChain([stat, 'optionalAccess', _30 => _30.isFile, 'call', _31 => _31()])) {
+    return getRealPath(file, preserveSymlinks);
+  }
+}
+function tryResolveRealFileWithExtensions(filePath, extensions, preserveSymlinks) {
+  for (const ext of extensions) {
+    const res = tryResolveRealFile(filePath + ext, preserveSymlinks);
+    if (res) {
+      return res;
+    }
+  }
+}
+function tryResolveRealFileOrType(file, preserveSymlinks) {
+  const fileStat = tryStatSync(file);
+  if (_optionalChain([fileStat, 'optionalAccess', _32 => _32.isFile, 'call', _33 => _33()])) {
+    return { path: getRealPath(file, preserveSymlinks), type: "file" };
+  }
+  if (_optionalChain([fileStat, 'optionalAccess', _34 => _34.isDirectory, 'call', _35 => _35()])) {
+    return { type: "directory" };
+  }
+}
+function getRealPath(resolved, preserveSymlinks) {
+  if (!preserveSymlinks) {
+    resolved = safeRealpathSync(resolved);
+  }
+  return normalizePath(resolved);
+}
+function isDirectory(path7) {
+  const stat = tryStatSync(path7);
+  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;
+};
+function collectAllModules(bundle, fileName, allModules, analyzedModules = /* @__PURE__ */ new Set()) {
+  if (analyzedModules.has(fileName)) {
+    return;
+  }
+  analyzedModules.add(fileName);
+  const chunk = bundle[fileName];
+  for (const mod of chunk.moduleIds) {
+    allModules.add(mod);
+  }
+  for (const i of chunk.imports) {
+    analyzedModules.add(i);
+    collectAllModules(bundle, i, allModules, analyzedModules);
+  }
+  for (const i of chunk.dynamicImports) {
+    analyzedModules.add(i);
+    collectAllModules(bundle, i, allModules, analyzedModules);
+  }
+}
+async function bundleFile(fileName, options) {
+  const { isESM } = options;
+  const isModuleSyncConditionEnabled = (await Promise.resolve().then(() => _interopRequireWildcard(require(
+    // @ts-ignore
+    "./false-SI6OY5LO.cjs"
+  )))).default;
+  const dirnameVarName = "__vite_injected_original_dirname";
+  const filenameVarName = "__vite_injected_original_filename";
+  const importMetaUrlVarName = "__vite_injected_original_import_meta_url";
+  const rolldownOptions = _optionalChain([options, 'optionalAccess', _38 => _38.rolldownOptions]) || {};
+  const bundle = await _rolldown.rolldown.call(void 0, {
+    ...rolldownOptions,
+    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: [
+      /* @__PURE__ */ (() => {
+        const packageCache = /* @__PURE__ */ new Map();
+        const resolveByViteResolver = (id, importer, isRequire) => {
+          return _optionalChain([tryNodeResolve, 'call', _39 => _39(id, importer, {
+            root: _path2.default.dirname(fileName),
+            isBuild: true,
+            isProduction: true,
+            preferRelative: false,
+            tryIndex: true,
+            mainFields: [],
+            conditions: [
+              "node",
+              ...isModuleSyncConditionEnabled ? ["module-sync"] : []
+            ],
+            externalConditions: [],
+            external: [],
+            noExternal: [],
+            dedupe: [],
+            extensions: configDefaults.resolve.extensions,
+            preserveSymlinks: false,
+            packageCache,
+            isRequire,
+            builtins: nodeLikeBuiltins
+          }), 'optionalAccess', _40 => _40.id]);
+        };
+        return {
+          name: "externalize-deps",
+          resolveId: {
+            filter: { id: /^[^.#].*/ },
+            async handler(id, importer, { kind }) {
+              if (!importer || _path2.default.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 (e9) {
+                  }
+                  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 = _url.pathToFileURL.call(void 0, idFsPath).href;
+              }
+              return { id: idFsPath, external: true };
+            }
+          }
+        };
+      })(),
+      {
+        name: "inject-file-scope-variables",
+        transform: {
+          filter: { id: /\.[cm]?[jt]s$/ },
+          async handler(code, id) {
+            const injectValues = `const ${dirnameVarName} = ${JSON.stringify(_path2.default.dirname(id))};const ${filenameVarName} = ${JSON.stringify(id)};const ${importMetaUrlVarName} = ${JSON.stringify(
+              _url.pathToFileURL.call(void 0, id).href
+            )};`;
+            return { code: injectValues + code, map: null };
+          }
+        }
+      }
+    ],
+    external: options.external
+    // preserveEntrySignatures: 'exports-only'
+  });
+  const result = await bundle.generate({
+    format: options.format,
+    sourcemap: "inline",
+    sourcemapPathTransform(relative) {
+      return _path2.default.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();
+  collectAllModules(bundleChunks, entryChunk.fileName, allModules);
+  allModules.delete(fileName);
+  return {
+    code: entryChunk.code,
+    dependencies: [...allModules]
+  };
+}
+var _require2 = _module.createRequire.call(void 0, _chunkQ6XJHTDBcjs.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 hash2 = `timestamp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+    const tempFileName = nodeModulesDir ? _path2.default.resolve(
+      nodeModulesDir,
+      `.vite-temp/${_path2.default.basename(fileName)}.${hash2}.${isESM ? "mjs" : "cjs"}`
+    ) : `${fileName}.${hash2}.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', _41 => _41.preserveTemporaryFile])) {
+        _fs2.default.unlink(outfile, () => {
+        });
+      }
+    }
+  } 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];
+    _require2.extensions[loaderExt] = (module, filename) => {
+      if (filename === realFileName) {
+        ;
+        module._compile(bundledCode, filename);
+      } else {
+        defaultLoader(module, filename);
+      }
+    };
+    delete _require2.cache[_require2.resolve(fileName)];
+    const raw = _require2(fileName);
+    _require2.extensions[loaderExt] = defaultLoader;
+    return raw.__esModule ? raw.default : raw;
+  }
+}
+async function bundleRequire(options) {
+  const resolvedPath = _path2.default.isAbsolute(options.filepath) ? options.filepath : _path2.default.resolve(options.cwd || _process2.default.cwd(), options.filepath);
+  const isESM = typeof _process2.default.versions.deno === "string" || isFilePathESM(resolvedPath);
+  if (options.tsconfig !== false) {
+    options.tsconfig = _nullishCoalesce(_nullishCoalesce(options.tsconfig, () => ( _optionalChain([_gettsconfig.getTsconfig.call(void 0, options.cwd, "tsconfig.json"), 'optionalAccess', _42 => _42.path]))), () => ( void 0));
+  } else {
+    options.tsconfig = void 0;
+  }
+  if (!options.format) {
+    options.format = isESM ? "esm" : "cjs";
+  }
+  const internalOptions = {
+    ...options,
+    isESM,
+    format: options.format,
+    tsconfig: options.tsconfig
+  };
+  const bundled = await bundleFile(
+    resolvedPath,
+    internalOptions
+  );
+  const mod = await loadFromBundledFile(
+    resolvedPath,
+    bundled.code,
+    internalOptions
+  );
+  return {
+    mod,
+    dependencies: bundled.dependencies
+  };
+}
+
+
+
+
+
+exports.bundleFile = bundleFile; exports.bundleRequire = bundleRequire; exports.configDefaults = configDefaults; exports.loadFromBundledFile = loadFromBundledFile;