module_export_names_private_symbol,

module_circular_visited_private_symbol,

module_export_private_symbol,

module_parent_private_symbol,

module_first_parent_private_symbol,

module_last_parent_private_symbol,

},

isInsideNodeModules,

} = internalBinding('util');

*/

const kModuleExport = module_export_private_symbol;

/**

* {@link Module} parent module.

* {@link Module} The first parent module that loads a module with require().

*/

const kModuleParent = module_parent_private_symbol;

const kFirstModuleParent = module_first_parent_private_symbol;

/**

* {@link Module} The last parent module that loads a module with require().

*/

const kLastModuleParent = module_last_parent_private_symbol;

const kIsMainSymbol = Symbol('kIsMainSymbol');

const kIsCachedByESMLoader = Symbol('kIsCachedByESMLoader');

findLongestRegisteredExtension,

resolveForCJSWithHooks,

loadSourceForCJSWithHooks: loadSource,

populateCJSExportsFromESM,

wrapSafe,

wrapModuleLoad,

kIsMainSymbol,

this.id = id;

this.path = path.dirname(id);

setOwnProperty(this, 'exports', {});

this[kModuleParent] = parent;

this[kFirstModuleParent] = parent;

this[kLastModuleParent] = parent;

updateChildren(parent, this, false);

this.filename = null;

this.loaded = false;

* @returns {object}

*/

function getModuleParent() {

return this[kModuleParent];

return this[kFirstModuleParent];

}

/**

* @returns {void}

*/

function setModuleParent(value) {

this[kModuleParent] = value;

this[kFirstModuleParent] = value;

}

let debug = debuglog('module', (fn) => {

const requiredESM = module[kRequiredModuleSymbol];

if (requiredESM && requiredESM.getStatus() !== kEvaluated) {

let message = `Cannot require() ES Module ${module.id} in a cycle.`;

const parent = module[kModuleParent];

const parent = module[kLastModuleParent];

if (parent) {

message += ` (from ${parent.filename})`;

}

// load hooks for the module keyed by the (potentially customized) filename.

module[kURL] = url;

module[kFormat] = format;

} else {

module[kLastModuleParent] = parent;

}

if (parent !== undefined) {

const requireStack = [];

for (let cursor = parent;

cursor;

cursor = cursor[kModuleParent]) {

// TODO(joyeecheung): it makes more sense to use kLastModuleParent here.

cursor = cursor[kFirstModuleParent]) {

ArrayPrototypePush(requireStack, cursor.filename || cursor.id);

}

let message = `Cannot find module '${request}'`;

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

setOwnProperty(process, 'mainModule', undefined);

} else {

const parent = mod[kModuleParent];

const parent = mod[kLastModuleParent];

requireModuleWarningMode ??= getOptionValue('--trace-require-module');

if (requireModuleWarningMode) {

wrap,

namespace,

} = cascadedLoader.importSyncForRequire(mod, filename, source, isMain, parent);

// Tooling in the ecosystem have been using the __esModule property to recognize

// transpiled ESM in consuming code. For example, a 'log' package written in ESM:

//

// export default function log(val) { console.log(val); }

//

// Can be transpiled as:

//

// exports.__esModule = true;

// exports.default = function log(val) { console.log(val); }

//

// The consuming code may be written like this in ESM:

//

// import log from 'log'

//

// Which gets transpiled to:

//

// const _mod = require('log');

// const log = _mod.__esModule ? _mod.default : _mod;

//

// So to allow transpiled consuming code to recognize require()'d real ESM

// as ESM and pick up the default exports, we add a __esModule property by

// building a source text module facade for any module that has a default

// export and add .__esModule = true to the exports. This maintains the

// enumerability of the re-exported names and the live binding of the exports,

// without incurring a non-trivial per-access overhead on the exports.

//

// The source of the facade is defined as a constant per-isolate property

// required_module_default_facade_source_string, which looks like this

//

// export * from 'original';

// export { default } from 'original';

// export const __esModule = true;

//

// And the 'original' module request is always resolved by

// createRequiredModuleFacade() to `wrap` which is a ModuleWrap wrapping

// over the original module.

// We don't do this to modules that are marked as CJS ESM or that

// don't have default exports to avoid the unnecessary overhead.

// If __esModule is already defined, we will also skip the extension

// to allow users to override it.

if (ObjectHasOwn(namespace, 'module.exports')) {

mod.exports = namespace['module.exports'];

} else if (!ObjectHasOwn(namespace, 'default') || ObjectHasOwn(namespace, '__esModule')) {

mod.exports = namespace;

} else {

mod.exports = createRequiredModuleFacade(wrap);

}

populateCJSExportsFromESM(mod, wrap, namespace);

}

}

/**

* Populate the exports of a CJS module entry from an ESM module's namespace object for

* require(esm).

* @param {Module} mod CJS module instance

* @param {ModuleWrap} wrap ESM ModuleWrap instance.

* @param {object} namespace The ESM namespace object.

*/

function populateCJSExportsFromESM(mod, wrap, namespace) {

// Tooling in the ecosystem have been using the __esModule property to recognize

// transpiled ESM in consuming code. For example, a 'log' package written in ESM:

//

// export default function log(val) { console.log(val); }

//

// Can be transpiled as:

//

// exports.__esModule = true;

// exports.default = function log(val) { console.log(val); }

//

// The consuming code may be written like this in ESM:

//

// import log from 'log'

//

// Which gets transpiled to:

//

// const _mod = require('log');

// const log = _mod.__esModule ? _mod.default : _mod;

//

// So to allow transpiled consuming code to recognize require()'d real ESM

// as ESM and pick up the default exports, we add a __esModule property by

// building a source text module facade for any module that has a default

// export and add .__esModule = true to the exports. This maintains the

// enumerability of the re-exported names and the live binding of the exports,

// without incurring a non-trivial per-access overhead on the exports.

//

// The source of the facade is defined as a constant per-isolate property

// required_module_default_facade_source_string, which looks like this

//

// export * from 'original';

// export { default } from 'original';

// export const __esModule = true;

//

// And the 'original' module request is always resolved by

// createRequiredModuleFacade() to `wrap` which is a ModuleWrap wrapping

// over the original module.

// We don't do this to modules that are marked as CJS ESM or that

// don't have default exports to avoid the unnecessary overhead.

// If __esModule is already defined, we will also skip the extension

// to allow users to override it.

if (ObjectHasOwn(namespace, 'module.exports')) {

mod.exports = namespace['module.exports'];

} else if (!ObjectHasOwn(namespace, 'default') || ObjectHasOwn(namespace, '__esModule')) {

mod.exports = namespace;

} else {

mod.exports = createRequiredModuleFacade(wrap);

}

}

*/

function getRequireESMError(mod, pkg, content, filename) {

// This is an error path because `require` of a `.js` file in a `"type": "module"` scope is not allowed.

const parent = mod[kModuleParent];

const parent = mod[kFirstModuleParent];

const parentPath = parent?.filename;

const packageJsonPath = pkg?.path;

const usesEsm = containsModuleSyntax(content, filename);