rolldown-require
Version:
bundle and require a file using rolldown!
1,117 lines (1,084 loc) • 39.8 kB
JavaScript
;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 __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
}) : x)(function(x) {
if (typeof require !== "undefined") return require.apply(this, arguments);
throw Error('Dynamic require of "' + x + '" is not supported');
});
// ../../node_modules/.pnpm/tsup@8.5.0_@swc+core@1.13.4_jiti@2.5.1_postcss@8.5.6_tsx@4.20.5_typescript@5.9.2_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;
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');
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 _pluginutils = require('@rollup/pluginutils');
// src/constants.ts
var { version } = JSON.parse(
_fs.readFileSync.call(void 0, new URL("../package.json", importMetaUrl)).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
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(path6) {
const file = cleanUrl(path6);
return { file, postfix: path6.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, importMetaUrl);
var _dirname = _path2.default.dirname(_url.fileURLToPath.call(void 0, importMetaUrl));
var urlCanParse = _nullishCoalesce(_url.URL.canParse, () => ( ((path6, base) => {
try {
new (0, _url.URL)(path6, base);
return true;
} catch (e2) {
return false;
}
})));
function normalizePath(id) {
return _path2.default.posix.normalize(isWindows ? slash(id) : id);
}
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(path6) {
const realPath = _fs2.default.realpathSync.native(path6);
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(path6) {
if (!firstSafeRealPathSyncRun) {
optimizeSafeRealPathSync();
firstSafeRealPathSyncRun = true;
}
return _fs2.default.realpathSync(path6);
}
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, importMetaUrl) : __require;
return fn(id);
};
// src/packages.ts
var pnp;
if (_process2.default.versions.pnp) {
try {
pnp = _module.createRequire.call(void 0, 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(path6, key, suffix) {
return key.endsWith(suffix) && key.slice(0, -suffix.length) === path6;
}
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(path6) {
const stat = tryStatSync(path6);
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
"#module-sync-enabled"
)))).default;
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', _38 => _38.rolldownOptions, 'optionalAccess', _39 => _39.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: [
/* @__PURE__ */ (() => {
const packageCache = /* @__PURE__ */ new Map();
const resolveByViteResolver = (id, importer, isRequire) => {
return _optionalChain([tryNodeResolve, 'call', _40 => _40(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', _41 => _41.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 rolldownOutputOptions = _optionalChain([options, 'optionalAccess', _42 => _42.rolldownOptions, 'optionalAccess', _43 => _43.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();
collectAllModules(bundleChunks, entryChunk.fileName, allModules);
allModules.delete(fileName);
return {
code: entryChunk.code,
dependencies: [...allModules]
};
}
var _require2 = _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 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', _44 => _44.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', _45 => _45.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;