filename = convertURLToCJSFilename(url);

}

return { __proto__: null, url, format, filename, parentURL };

const result = { __proto__: null, url, format, filename, parentURL };

debug('resolveForCJSWithHooks', specifier, parent?.id, '->', result);

return result;

}

/**

* @param {string} id The module ID (without the node: prefix)

* @param {string} url The module URL (with the node: prefix)

* @param {string} format Format from resolution.

* @returns {any} If there are no load hooks or the load hooks do not override the format of the

* builtin, load and return the exports of the builtin. Otherwise, return undefined.

* @returns {{builtinExports: any, resultFromHook: undefined|ModuleLoadResult}} If there are no load

* hooks or the load hooks do not override the format of the builtin, load and return the exports

* of the builtin module. Otherwise, return the loadResult for the caller to continue loading.

*/

function loadBuiltinWithHooks(id, url, format) {

let resultFromHook;

if (loadHooks.length) {

url ??= `node:${id}`;

debug('loadBuiltinWithHooks ', loadHooks.length, id, url, format);

// TODO(joyeecheung): do we really want to invoke the load hook for the builtins?

const loadResult = loadWithHooks(url, format || 'builtin', /* importAttributes */ undefined,

getCjsConditionsArray(), getDefaultLoad(url, id), validateLoadStrict);

if (loadResult.format && loadResult.format !== 'builtin') {

return undefined; // Format has been overridden, return undefined for the caller to continue loading.

resultFromHook = loadWithHooks(url, format || 'builtin', /* importAttributes */ undefined,

getCjsConditionsArray(), getDefaultLoad(url, id), validateLoadStrict);

if (resultFromHook.format && resultFromHook.format !== 'builtin') {

debug('loadBuiltinWithHooks overriding module', id, url, resultFromHook);

// Format has been overridden, return result for the caller to continue loading.

return { builtinExports: undefined, resultFromHook };

}

}

// No hooks or the hooks have not overridden the format. Load it as a builtin module and return the

// exports.

const mod = loadBuiltinModule(id);

return mod.exports;

return { builtinExports: mod.exports, resultFromHook: undefined };

}

/**

}

}

const { url, format, filename } = resolveForCJSWithHooks(request, parent, isMain);

const resolveResult = resolveForCJSWithHooks(request, parent, isMain);

let { format } = resolveResult;

const { url, filename } = resolveResult;

let resultFromLoadHook;

// For backwards compatibility, if the request itself starts with node:, load it before checking

// Module._cache. Otherwise, load it after the check.

if (StringPrototypeStartsWith(request, 'node:')) {

const result = loadBuiltinWithHooks(filename, url, format);

if (result) {

return result;

// TODO(joyeecheung): a more sensible handling is probably, if there are hooks, always go through the hooks

// first before checking the cache. Otherwise, check the cache first, then proceed to default loading.

if (request === url && StringPrototypeStartsWith(request, 'node:')) {

const normalized = BuiltinModule.normalizeRequirableId(request);

if (normalized) { // It's a builtin module.

const { resultFromHook, builtinExports } = loadBuiltinWithHooks(normalized, url, format);

if (builtinExports) {

return builtinExports;

}

// The format of the builtin has been overridden by user hooks. Continue loading.

resultFromLoadHook = resultFromHook;

format = resultFromLoadHook.format;

}

// The format of the builtin has been overridden by user hooks. Continue loading.

}

const cachedModule = Module._cache[filename];

if (cachedModule !== undefined) {

updateChildren(parent, cachedModule, true);

if (cachedModule.loaded) {

return cachedModule.exports;

}

// If it's not cached by the ESM loader, the loading request

// comes from required CJS, and we can consider it a circular

// dependency when it's cached.

if (!cachedModule[kIsCachedByESMLoader]) {

return getExportsForCircularRequire(cachedModule);

}

// If it's cached by the ESM loader as a way to indirectly pass

// the module in to avoid creating it twice, the loading request

// came from imported CJS. In that case use the kModuleCircularVisited

// to determine if it's loading or not.

if (cachedModule[kModuleCircularVisited]) {

return getExportsForCircularRequire(cachedModule);

// If load hooks overrides the format for a built-in, bypass the cache.

let cachedModule;

if (resultFromLoadHook === undefined) {

cachedModule = Module._cache[filename];

debug('Module._load checking cache for', filename, !!cachedModule);

if (cachedModule !== undefined) {

updateChildren(parent, cachedModule, true);

if (cachedModule.loaded) {

return cachedModule.exports;

}

// If it's not cached by the ESM loader, the loading request

// comes from required CJS, and we can consider it a circular

// dependency when it's cached.

if (!cachedModule[kIsCachedByESMLoader]) {

return getExportsForCircularRequire(cachedModule);

}

// If it's cached by the ESM loader as a way to indirectly pass

// the module in to avoid creating it twice, the loading request

// came from imported CJS. In that case use the kModuleCircularVisited

// to determine if it's loading or not.

if (cachedModule[kModuleCircularVisited]) {

return getExportsForCircularRequire(cachedModule);

}

// This is an ESM loader created cache entry, mark it as visited and fallthrough to loading the module.

cachedModule[kModuleCircularVisited] = true;

}

// This is an ESM loader created cache entry, mark it as visited and fallthrough to loading the module.

cachedModule[kModuleCircularVisited] = true;

}

if (BuiltinModule.canBeRequiredWithoutScheme(filename)) {

const result = loadBuiltinWithHooks(filename, url, format);

if (result) {

return result;

if (resultFromLoadHook === undefined && BuiltinModule.canBeRequiredWithoutScheme(filename)) {

const { resultFromHook, builtinExports } = loadBuiltinWithHooks(filename, url, format);

if (builtinExports) {

return builtinExports;

}

// The format of the builtin has been overridden by user hooks. Continue loading.

resultFromLoadHook = resultFromHook;

format = resultFromLoadHook.format;

}

// Don't call updateChildren(), Module constructor already does.

} else {

module[kIsMainSymbol] = false;

}

if (resultFromLoadHook !== undefined) {

module[kModuleSource] = resultFromLoadHook.source;

}

reportModuleToWatchMode(filename);

Module._cache[filename] = module;

return err;

}

function getExtensionForFormat(format) {

switch (format) {

case 'addon':

return '.node';

case 'json':

return '.json';

default:

return '.js';

}

}

/**

* Given a file name, pass it to the proper extension handler.

* @param {string} filename The `require` specifier

this.filename ??= filename;

this.paths ??= Module._nodeModulePaths(path.dirname(filename));

const extension = findLongestRegisteredExtension(filename);

// If the format is already overridden by hooks, convert that back to extension.

let extension;

if (this[kFormat] !== undefined) {

extension = getExtensionForFormat(this[kFormat]);

} else {

extension = findLongestRegisteredExtension(filename);

}

Module._extensions[extension](this, filename);

this.loaded = true;