'use strict';

} = primordials;

const {

compileFunctionForCJSLoader,

} = internalBinding('contextify');

kIsCachedByESMLoader,

Module: CJSModule,

kModuleSource,

kModuleExport,

kModuleExportNames,

findLongestRegisteredExtension,

resolveForCJSWithHooks,

loadSourceForCJSWithHooks,

let debug = require('internal/util/debuglog').debuglog('esm', (fn) => {

debug = fn;

});

ERR_UNKNOWN_BUILTIN_MODULE,

} = require('internal/errors').codes;

/**

* Converts a URL to a file path if the URL protocol is 'file:'.

* @param {string} url - The URL to convert.

function errPath(url) {

const parsed = new URL(url);

if (parsed.protocol === 'file:') {

return fileURLToPath(parsed);

}

return url;

}

translators.set('module', function moduleStrategy(url, translateContext, parentURL) {

let { source } = translateContext;

const isMain = (parentURL === undefined);

const {

compileSourceTextModule, SourceTextModuleTypes: { kUser },

} = require('internal/modules/esm/utils');

});

const kShouldNotSkipModuleHooks = { __proto__: null, shouldSkipModuleHooks: false };

/**

* Loads a CommonJS module via the ESM Loader sync CommonJS translator.

* This translator creates its own version of the `require` function passed into CommonJS modules.

* Any monkey patches applied to the CommonJS Loader will not affect this module.

* Any `require` calls in this module will load all children in the same way.

* @param {import('internal/modules/cjs/loader').Module} module - The module to load.

* @param {string} source - The source code of the module.

* @param {string} url - The URL of the module.

* @param {string} filename - The filename of the module.

// Use the full URL as the V8 resource name so that any search params

// (e.g. ?node-test-mock) are preserved in coverage reports.

const compileResult = compileFunctionForCJSLoader(source, url, false /* is_sea_main */, false);

const __dirname = dirname(filename);

// eslint-disable-next-line func-name-matching,func-style

const requireFn = function require(specifier) {

// TODO: do not depend on the monkey-patchable CJS loader here.

const path = CJSModule._resolveFilename(specifier, module);

switch (extname(path)) {

case '.json':

importAttributes = { __proto__: null, type: 'json' };

break;

case '.node':

// If it gets here in the translators, the hooks must have already been invoked

// in the loader. Skip them in the synthetic module evaluation step.

return wrapModuleLoad(specifier, module, false, kShouldSkipModuleHooks);

// fall through

}

// NOTE: This re-invented require() is only used on the loader-hook worker thread.

// On the main thread, the authentic require() is used instead (fixed by #60380).

const request = { specifier, attributes: importAttributes, phase: kEvaluationPhase, __proto__: null };

const job = cascadedLoader.getOrCreateModuleJob(url, request, kRequireInImportedCJS);

let mod = cjsCache.get(job.url);

assert(job.module, `Imported CJS module ${url} failed to load module ${job.url} using require() due to race condition`);

if (job.module.synthetic) {

assert(mod, `Imported CJS module ${url} failed to load module ${job.url} using require() due to missed cache`);

return mod.exports;

}

// The module being required is a source text module.

if (!mod) {

mod = cjsEmplaceModuleCacheEntry(job.url);

cjsCache.set(job.url, mod);

}

// The module has been cached by the re-invented require. Update the exports object

// from the namespace object and return the evaluated exports.

if (!mod.loaded) {

debug('populateCJSExportsFromESM from require(esm) in imported CJS', url, mod, job.module);

populateCJSExportsFromESM(mod, job.module, job.module.getNamespace());

mod.loaded = true;

}

return mod.exports;

};

setOwnProperty(requireFn, 'resolve', function resolve(specifier) {

if (!StringPrototypeStartsWith(specifier, 'node:')) {

const {

filename, url: resolvedURL,

} = resolveForCJSWithHooks(specifier, module, false, kShouldNotSkipModuleHooks);

if (specifier !== filename) {

specifier = resolvedURL ?? `${pathToFileURL(filename)}`;

}

}

const request = { specifier, __proto__: null, attributes: kEmptyObject };

// Skip sync hooks in resolveSync since resolveForCJSWithHooks already ran them above.

const { url: resolvedURL } = cascadedLoader.resolveSync(url, request, /* shouldSkipSyncHooks */ true);

});

setOwnProperty(requireFn, 'main', process.mainModule);

FunctionPrototypeCall(compiledWrapper, module.exports,

module.exports, requireFn, module, filename, __dirname);

setOwnProperty(module, 'loaded', true);

}

// TODO: can we use a weak map instead?

const cjsCache = new SafeMap();

/**

* Creates a ModuleWrap object for a CommonJS module.

* @param {string} url - The URL of the module.

* @param {{ format: ModuleFormat, source: ModuleSource }} translateContext Context for the translator

* @param {string|undefined} parentURL URL of the module initiating the module loading for the first time.

* Undefined if it's the entry point.

* @returns {ModuleWrap} The ModuleWrap object for the CommonJS module.

*/

function createCJSModuleWrap(url, translateContext, parentURL, loadCJS = loadCJSModule) {

debug(`Translating CJSModule ${url}`, translateContext);

const { format: sourceFormat } = translateContext;

let { source } = translateContext;

const isMain = (parentURL === undefined);

if (!exportNames.has('default')) {

ArrayPrototypePush(wrapperNames, 'default');

}

if (!exportNames.has('module.exports')) {

ArrayPrototypePush(wrapperNames, 'module.exports');

}

if (isMain) {

setOwnProperty(process, 'mainModule', module);

}

}

if (module[kModuleExport] !== undefined) {

exports = module[kModuleExport];

module[kModuleExport] = undefined;

}

for (const exportName of exportNames) {

if (exportName === 'default' || exportName === 'module.exports' ||

!ObjectPrototypeHasOwnProperty(exports, exportName)) {

// We might trigger a getter -> dont fail.

let value;

try {

value = exports[exportName];

} catch {

// Continue regardless of error.

}

}

this.setExport('default', exports);

}

/**

* Creates a ModuleWrap object for a CommonJS module without source texts.

* @param {string} url - The URL of the module.

* @returns {ModuleWrap} The ModuleWrap object for the CommonJS module.

*/

const filename = urlToFilename(url);

const module = cjsEmplaceModuleCacheEntry(filename);

cjsCache.set(url, module);

if (isMain) {

setOwnProperty(process, 'mainModule', module);

}

// Addon export names are not known until the addon is loaded.

const exportNames = ['default', 'module.exports'];

return new ModuleWrap(url, undefined, exportNames, function evaluationCallback() {

debug(`Loading CJSModule ${url}`);

if (!module.loaded) {

// If it gets here in the translators, the hooks must have already been invoked

// in the loader. Skip them in the synthetic module evaluation step.

wrapModuleLoad(filename, null, isMain, kShouldSkipModuleHooks);

}

/** @type {import('./loader').ModuleExports} */

let exports;

if (module[kModuleExport] !== undefined) {

exports = module[kModuleExport];

module[kModuleExport] = undefined;

} else {

({ exports } = module);

}

this.setExport('default', exports);

this.setExport('module.exports', exports);

}, module);

}

translators.set('commonjs-sync', function requireCommonJS(url, translateContext, parentURL) {

return createCJSModuleWrap(url, translateContext, parentURL, loadCJSModuleWithModuleLoad);

});

// Handle CommonJS modules referenced by `require` calls.

// This translator function must be sync, as `require` is sync.

translators.set('require-commonjs', (url, translateContext, parentURL) => {

return createCJSModuleWrap(url, translateContext, parentURL);

});

// Handle CommonJS modules referenced by `require` calls.

// This translator function must be sync, as `require` is sync.

translators.set('require-commonjs-typescript', (url, translateContext, parentURL) => {

translateContext.source = stripTypeScriptModuleTypes(stringify(translateContext.source), url);

return createCJSModuleWrap(url, translateContext, parentURL);

});

// This goes through Module._load to accommodate monkey-patchers.

function loadCJSModuleWithModuleLoad(module, source, url, filename, isMain) {

assert(module === CJSModule._cache[filename]);

// If it gets here in the translators, the hooks must have already been invoked

// in the loader. Skip them in the synthetic module evaluation step.

wrapModuleLoad(filename, undefined, isMain, kShouldSkipModuleHooks);

}

// Handle CommonJS modules referenced by `import` statements or expressions,

// or as the initial entry point when the ESM loader handles a CommonJS entry.

// CJS source associated with a `file:` URL - that usually means the source is not

// customized (is loaded by default load) or the hook author wants it to be reloaded

// through CJS routine. In this case, the source is obtained by calling the

// monkey-patchable CJS loader.

// TODO(joyeecheung): just use wrapModuleLoad and let the CJS loader

// invoke the off-thread hooks. Use a special parent to avoid invoking in-thread

// hooks twice.

const shouldReloadByCJSLoader = (translateContext.shouldBeReloadedByCJSLoader || translateContext.source == null);

const cjsLoader = shouldReloadByCJSLoader ? loadCJSModuleWithModuleLoad : loadCJSModule;

try {

// We still need to read the FS to detect the exports.

// If you are reading this code to figure out how to patch Node.js module loading

// behavior - DO NOT depend on the patchability in new code: Node.js

// internals may stop going through the JavaScript fs module entirely.

// Prefer module.registerHooks() or other more formal fs hooks released in the future.

translateContext.source ??= fs.readFileSync(new URL(url), 'utf8');

} catch {

// Continue regardless of error.

}

});

/**

* Get or create an entry in the CJS module cache for the given filename.

* @param {string} filename CJS module filename

* @returns {CJSModule} the cached CJS module entry

*/

// TODO: Do we want to keep hitting the user mutable CJS loader here?

let cjsMod = CJSModule._cache[filename];

if (cjsMod) {

return cjsMod;

}

cjsMod.filename = filename;

cjsMod.paths = CJSModule._nodeModulePaths(cjsMod.path);

cjsMod[kIsCachedByESMLoader] = true;

CJSModule._cache[filename] = cjsMod;

return cjsMod;

}

/**

* Pre-parses a CommonJS module's exports and re-exports.

* @param {string} filename - The filename of the module.

* @param {string} [source] - The source code of the module.

function cjsPreparseModuleExports(filename, source, format) {

const module = cjsEmplaceModuleCacheEntry(filename);

if (module[kModuleExportNames] !== undefined) {

}

if (source === undefined) {

({ source } = loadSourceForCJSWithHooks(module, filename, format));

}

module[kModuleSource] = source;

debug(`Preparsing exports of ${filename}`);

// Set first for cycles.

// If there are any re-exports e.g. `module.exports = { ...require(...) }`,

// pre-parse the dependencies to find transitively exported names.

module.filename ??= filename;

module.paths ??= CJSModule._nodeModulePaths(dirname(filename));

const reexport = reexports[i];

let resolved;

} catch (e) {

debug(`Failed to resolve '${reexport}', skipping`, e);

continue;

}

if (format === 'commonjs' ||

(!BuiltinModule.normalizeRequirableId(resolved) && findLongestRegisteredExtension(resolved) === '.js')) {