module: support ESM detection in the CJS loader · nodejs/node@a03faf2

kModuleExportNames,

kModuleCircularVisited,

initializeCJS,

entryPointSource: undefined, // Set below.

Module,

wrapSafe,

kIsMainSymbol,

const source = getMaybeCachedSource(mod, filename);

const cascadedLoader = require('internal/modules/esm/loader').getOrInitializeCascadedLoader();

const isMain = mod[kIsMainSymbol];

// TODO(joyeecheung): we may want to invent optional special handling for default exports here.

// For now, it's good enough to be identical to what `import()` returns.

mod.exports = cascadedLoader.importSyncForRequire(mod, filename, source, isMain, mod[kModuleParent]);

if (isMain) {

require('internal/modules/run_main').runEntryPointWithESMLoader((cascadedLoader) => {

const mainURL = pathToFileURL(filename).href;

cascadedLoader.import(mainURL, undefined, { __proto__: null }, true);

});

// ESM won't be accessible via process.mainModule.

setOwnProperty(process, 'mainModule', undefined);

} else {

// TODO(joyeecheung): we may want to invent optional special handling for default exports here.

// For now, it's good enough to be identical to what `import()` returns.

mod.exports = cascadedLoader.importSyncForRequire(mod, filename, source, isMain, mod[kModuleParent]);

}

}

/**

* @param {string} content The content of the file being loaded

* @param {Module} cjsModuleInstance The CommonJS loader instance

* @param {object} codeCache The SEA code cache

* @param {'commonjs'|undefined} format Intended format of the module.

*/

function wrapSafe(filename, content, cjsModuleInstance, codeCache) {

function wrapSafe(filename, content, cjsModuleInstance, codeCache, format) {

assert(format !== 'module'); // ESM should be handled in loadESMFromCJS().

const hostDefinedOptionId = vm_dynamic_import_default_internal;

const importModuleDynamically = vm_dynamic_import_default_internal;

if (patched) {

};

}

try {

const result = compileFunctionForCJSLoader(content, filename);

// cachedDataRejected is only set for cache coming from SEA.

if (codeCache &&

result.cachedDataRejected !== false &&

internalBinding('sea').isSea()) {

process.emitWarning('Code cache data rejected.');

}

const isMain = !!(cjsModuleInstance && cjsModuleInstance[kIsMainSymbol]);

const shouldDetectModule = (format !== 'commonjs' && getOptionValue('--experimental-detect-module'));

const result = compileFunctionForCJSLoader(content, filename, isMain, shouldDetectModule);

// Cache the source map for the module if present.

if (result.sourceMapURL) {

maybeCacheSourceMap(filename, content, this, false, undefined, result.sourceMapURL);

}

// cachedDataRejected is only set for cache coming from SEA.

if (codeCache &&

result.cachedDataRejected !== false &&

internalBinding('sea').isSea()) {

process.emitWarning('Code cache data rejected.');

}

return result;

} catch (err) {

if (process.mainModule === cjsModuleInstance) {

if (getOptionValue('--experimental-detect-module')) {

// For the main entry point, cache the source to potentially retry as ESM.

module.exports.entryPointSource = content;

} else {

// We only enrich the error (print a warning) if we're sure we're going to for-sure throw it; so if we're

// retrying as ESM, wait until we know whether we're going to retry before calling `enrichCJSError`.

const { enrichCJSError } = require('internal/modules/esm/translators');

enrichCJSError(err, content, filename);

}

}

throw err;

// Cache the source map for the module if present.

if (result.sourceMapURL) {

maybeCacheSourceMap(filename, content, this, false, undefined, result.sourceMapURL);

}

return result;

}

/**

* Run the file contents in the correct scope or sandbox. Expose the correct helper variables (`require`, `module`,

* `exports`) to the file. Returns exception, if any.

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

* @param {string} filename The file path of the module

* @param {boolean} loadAsESM Whether it's known to be ESM via .mjs or "type" in package.json.

* @param {'module'|'commonjs'|undefined} format Intended format of the module.

*/

Module.prototype._compile = function(content, filename, loadAsESM = false) {

Module.prototype._compile = function(content, filename, format) {

let moduleURL;

let redirects;

const manifest = policy()?.manifest;

manifest.assertIntegrity(moduleURL, content);

}

let compiledWrapper;

if (format !== 'module') {

const result = wrapSafe(filename, content, this, undefined, format);

compiledWrapper = result.function;

if (result.canParseAsESM) {

format = 'module';

}

}

// TODO(joyeecheung): when the module is the entry point, consider allowing TLA.

// Only modules being require()'d really need to avoid TLA.

if (loadAsESM) {

if (format === 'module') {

// Pass the source into the .mjs extension handler indirectly through the cache.

this[kModuleSource] = content;

loadESMFromCJS(this, filename);

return;

}

const { function: compiledWrapper } = wrapSafe(filename, content, this);

// TODO(joyeecheung): the detection below is unnecessarily complex. Using the

// kIsMainSymbol, or a kBreakOnStartSymbol that gets passed from

// higher level instead of doing hacky detection here.

// If already analyzed the source, then it will be cached.

const content = getMaybeCachedSource(module, filename);

let format;

if (StringPrototypeEndsWith(filename, '.js')) {

const pkg = packageJsonReader.readPackageScope(filename) || { __proto__: null };

// Function require shouldn't be used in ES modules.

if (pkg.data?.type === 'module') {

if (getOptionValue('--experimental-require-module')) {

module._compile(content, filename, true);

module._compile(content, filename, 'module');

return;

}

}

}

throw err;

} else if (pkg.data?.type === 'commonjs') {

format = 'commonjs';

}

} else if (StringPrototypeEndsWith(filename, '.cjs')) {

format = 'commonjs';

}

module._compile(content, filename, false);

module._compile(content, filename, format);

};

/**