/**

#defaultConditions = getDefaultConditions();

/**

#resolveCache = new ResolveCache();

/**

loadCache = new LoadCache();

/**

isForAsyncLoaderHookWorker = false;

/**

#asyncLoaderHooks;

constructor(asyncLoaderHooks) {

this.#setAsyncLoaderHooks(asyncLoaderHooks);

}

/**

#setAsyncLoaderHooks(asyncLoaderHooks) {

this.#asyncLoaderHooks = asyncLoaderHooks;

if (asyncLoaderHooks) {

this.isForAsyncLoaderHookWorker = asyncLoaderHooks.isForAsyncLoaderHookWorker;

} else {

this.isForAsyncLoaderHookWorker = false;

}

}

/**

createModuleWrap(source, url, context = kEmptyObject) {

return compileSourceTextModule(url, source, kUser, context);

}

/**

async executeModuleJob(url, wrap, isEntryPoint = false) {

const module = await onImport.tracePromise(async () => {

const job = new ModuleJob(this, url, undefined, wrap, kEvaluationPhase, false, false, kImportInImportedESM);

this.loadCache.set(url, undefined, job);

const { module } = await job.run(isEntryPoint);

return module;

}, {

__proto__: null,

parentURL: '<eval>',

url,

});

return {

__proto__: null,

namespace: module.getNamespace(),

module,

};

}

/**

eval(source, url, isEntryPoint = false) {

const context = isEntryPoint ? { isMain: true } : undefined;

const wrap = this.createModuleWrap(source, url, context);

return this.executeModuleJob(url, wrap, isEntryPoint);

}

/**

importSyncForRequire(mod, filename, source, isMain, parent) {

const url = pathToFileURL(filename).href;

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

throw new ERR_REQUIRE_ESM(url, true);

}

let job = this.loadCache.get(url, kImplicitTypeAttribute);

// This module job is already created:

// 1. If it was loaded by `require()` before, at this point the instantiation

// is already completed and we can check whether it is in a cycle

// (in that case the module status is kEvaluating), and whether the

// required graph is synchronous.

// 2. If it was loaded by `import` before, only allow it if it's already evaluated

// to forbid cycles.

// TODO(joyeecheung): ensure that imported synchronous graphs are evaluated

// synchronously so that any previously imported synchronous graph is already

// evaluated at this point.

// TODO(joyeecheung): add something similar to CJS loader's requireStack to help

// debugging the problematic links in the graph for import.

debug('importSyncForRequire', parent?.filename, '->', filename, job);

if (job !== undefined) {

mod[kRequiredModuleSymbol] = job.module;

const parentFilename = urlToFilename(parent?.filename);

// This race should only be possible on the loader hook thread. See https://github.com/nodejs/node/issues/59666

if (!job.module) {

throw new ERR_REQUIRE_ESM_RACE_CONDITION(filename, parentFilename, this.isForAsyncLoaderHookWorker);

}

const status = job.module.getStatus();

debug('Module status', job, status);

// hasAsyncGraph is available after module been instantiated.

if (status >= kInstantiated) {

job.throwIfAsyncGraph(parent);

}

if (status === kEvaluated) {

return { wrap: job.module, namespace: job.module.getNamespace() };

} else if (status === kInstantiated) {

// When it's an async job cached by another import request,

// which has finished linking but has not started its

// evaluation because the async run() task would be later

// in line. Then start the evaluation now with runSync(), which

// is guaranteed to finish by the time the other run() get to it,

// and the other task would just get the cached evaluation results,

// similar to what would happen when both are async.

mod[kRequiredModuleSymbol] = job.module;

const { namespace } = job.runSync(parent);

return { wrap: job.module, namespace: namespace || job.module.getNamespace() };

} else if (status === kErrored) {

// If the module was previously imported and errored, throw the error.

throw job.module.getError();

}

// When the cached async job have already encountered a linking

// error that gets wrapped into a rejection, but is still later

// in line to throw on it, just unwrap and throw the linking error

// from require().

if (job.instantiated) {

throwIfPromiseRejected(job.instantiated);

}

if (status !== kEvaluating) {

assert(status === kUninstantiated, `Unexpected module status ${status}`);

// If we get here, either there's a race where the job is still being instantiated

// by an in-flight import(), or the cached module previously encountered an

// instantiation error during a prior load (e.g. due to a mismatched import).

// TODO(joyeecheung): the current check is too broad. We should attempt to

// get the potential instantiation error and throw it.

throw new ERR_REQUIRE_ESM_RACE_CONDITION(filename, parentFilename, false);

}

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

if (parentFilename) {

message += ` (from ${parentFilename})`;

}

message += ' A cycle involving require(esm) is not allowed to maintain ';

message += 'invariants mandated by the ECMAScript specification. ';

message += 'Try making at least part of the dependency in the graph lazily loaded.';

throw new ERR_REQUIRE_CYCLE_MODULE(message);

}

// TODO(joyeecheung): refactor this so that we pre-parse in C++ and hit the

// cache here, or use a carrier object to carry the compiled module script

// into the constructor to ensure cache hit.

const wrap = compileSourceTextModule(url, source, kUser);

const inspectBrk = (isMain && getOptionValue('--inspect-brk'));

job = new ModuleJobSync(this, url, kEmptyObject, wrap, kEvaluationPhase, isMain, inspectBrk,

kImportInRequiredESM);

this.loadCache.set(url, kImplicitTypeAttribute, job);

mod[kRequiredModuleSymbol] = job.module;

return { wrap: job.module, namespace: job.runSync(parent).namespace };

}

/**

#checkCachedJobForRequireESM(specifier, url, parentURL, job) {

// This race should only be possible on the loader hook thread. See https://github.com/nodejs/node/issues/59666

if (!job.module) {

throw new ERR_REQUIRE_ESM_RACE_CONDITION(url, parentURL, this.isForAsyncLoaderHookWorker);

}

// This module is being evaluated, which means it's imported in a previous link

// in a cycle.

if (job.module.getStatus() === kEvaluating) {

const parentFilename = urlToFilename(parentURL);

let message = `Cannot import Module ${specifier} in a cycle.`;

if (parentFilename) {

message += ` (from ${parentFilename})`;

}

throw new ERR_REQUIRE_CYCLE_MODULE(message);

}

// Otherwise the module could be imported before but the evaluation may be already

// completed (e.g. the require call is lazy) so it's okay. We will return the

// job and check asynchronicity of the entire graph later, before the

// graph is evaluated.

}

/**

loadAndTranslateForImportInRequiredESM(resolveResult, loadContext, parentURL, request) {

const { url } = resolveResult;

const loadResult = this.#loadSync(url, loadContext);

// Use the synchronous commonjs translator which can deal with cycles.

const formatFromLoad = loadResult.format;

const translatorKey = (formatFromLoad === 'commonjs' || formatFromLoad === 'commonjs-typescript') ?

'commonjs-sync' : formatFromLoad;

const translateContext = {

...resolveResult,

...loadResult,

translatorKey,

__proto__: null,

};

const wrap = this.#translate(url, translateContext, parentURL);

assert(wrap instanceof ModuleWrap, `Translator used for require(${url}) should not be async`);

const cjsModule = wrap[imported_cjs_symbol];

if (cjsModule) {

// Check if the ESM initiating import CJS is being required by the same CJS module.

if (cjsModule?.[kIsExecuting]) {

const parentFilename = urlToFilename(parentURL);

let message = `Cannot import CommonJS Module ${request.specifier} in a cycle.`;

if (parentFilename) {

message += ` (from ${parentFilename})`;

}

throw new ERR_REQUIRE_CYCLE_MODULE(message);

}

}

return wrap;

}

/**

#translate(url, translateContext, parentURL) {

const { translatorKey, format } = translateContext;

this.validateLoadResult(url, format);

const translator = translators.get(translatorKey);

if (!translator) {

throw new ERR_UNKNOWN_MODULE_FORMAT(translatorKey, url);

}

const result = FunctionPrototypeCall(translator, this, url, translateContext, parentURL);

assert(result instanceof ModuleWrap, `The ${format} module returned is not a ModuleWrap`);

if (format === 'commonjs' || format === 'commonjs-sync' || format === 'require-commonjs') {

result.isCommonJS = true;

}

return result;

}

/**

loadAndTranslateForRequireInImportedCJS(resolveResult, loadContext, parentURL) {

const { url } = resolveResult;

const loadResult = this.#loadSync(url, loadContext);

const formatFromLoad = loadResult.format;

if (formatFromLoad === 'wasm') { // require(wasm) is not supported.

throw new ERR_UNKNOWN_MODULE_FORMAT(formatFromLoad, url);

}

if (formatFromLoad === 'module' || formatFromLoad === 'module-typescript') {

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

throw new ERR_REQUIRE_ESM(url, true);

}

}

let translatorKey = formatFromLoad;

if (formatFromLoad === 'commonjs') {

translatorKey = 'require-commonjs';

}

if (formatFromLoad === 'commonjs-typescript') {

translatorKey = 'require-commonjs-typescript';

}

const translateContext = {

...resolveResult,

...loadResult,

translatorKey,

__proto__: null,

};

const wrap = this.#translate(url, translateContext, parentURL);

assert(wrap instanceof ModuleWrap, `Translator used for require(${url}) should not be async`);

return wrap;

}

/**

loadAndTranslate(resolveResult, loadContext, parentURL) {

const { url } = resolveResult;

const maybePromise = this.load(url, loadContext);

const afterLoad = (loadResult) => {

const translateContext = {

...resolveResult,

...loadResult,

translatorKey: loadResult.format,

__proto__: null,

};

return this.#translate(url, translateContext, parentURL);

};

if (isPromise(maybePromise)) {

return PromisePrototypeThen(maybePromise, afterLoad);

}

return afterLoad(maybePromise);

}

/**

#getOrCreateModuleJobAfterResolve(parentURL, resolveResult, request, requestType) {

const { url, format } = resolveResult;

if (process.env.WATCH_REPORT_DEPENDENCIES && process.send) {

const type = requestType === kRequireInImportedCJS ? 'require' : 'import';

process.send({ [`watch:${type}`]: [url] });

}

// Relay Events from worker to main thread

if (process.env.WATCH_REPORT_DEPENDENCIES && !process.send) {

const { isMainThread } = internalBinding('worker');

if (!isMainThread) {

const { parentPort } = require('worker_threads');

if (parentPort) {

parentPort.postMessage({ 'watch:import': [url] });

}

}

}

// TODO(joyeecheung): update the module requests to use importAttributes as property names.

const importAttributes = resolveResult.importAttributes ?? request.attributes;

let job = this.loadCache.get(url, importAttributes.type);

if (job !== undefined) {

if (requestType === kImportInRequiredESM) {

this.#checkCachedJobForRequireESM(request.specifier, url, parentURL, job);

}

job.ensurePhase(request.phase, requestType);

return job;

}

const context = { format, importAttributes, __proto__: null };

let moduleOrModulePromise;

if (requestType === kRequireInImportedCJS) {

moduleOrModulePromise = this.loadAndTranslateForRequireInImportedCJS(resolveResult, context, parentURL);

} else if (requestType === kImportInRequiredESM) {

moduleOrModulePromise = this.loadAndTranslateForImportInRequiredESM(resolveResult, context, parentURL, request);

} else {

moduleOrModulePromise = this.loadAndTranslate(resolveResult, context, parentURL);

}

if (requestType === kImportInRequiredESM || requestType === kRequireInImportedCJS ||

!this.isForAsyncLoaderHookWorker) {

assert(moduleOrModulePromise instanceof ModuleWrap, `Expected ModuleWrap for loading ${url}`);

}

// TODO(joyeecheung): use ModuleJobSync for kRequireInImportedCJS too.

const ModuleJobCtor = (requestType === kImportInRequiredESM ? ModuleJobSync : ModuleJob);

const isMain = (parentURL === undefined);

const inspectBrk = (isMain && getOptionValue('--inspect-brk'));

job = new ModuleJobCtor(

this,

url,

importAttributes,

moduleOrModulePromise,

request.phase,

isMain,

inspectBrk,

requestType,

);

this.loadCache.set(url, importAttributes.type, job);

return job;

}

/**

getOrCreateModuleJob(parentURL, request, requestType) {

let maybePromise;

if (requestType === kRequireInImportedCJS || requestType === kImportInRequiredESM) {

// In these two cases, resolution must be synchronous.

maybePromise = this.resolveSync(parentURL, request);

assert(!isPromise(maybePromise));

} else {

maybePromise = this.#resolve(parentURL, request);

}

const afterResolve = (resolveResult) => {

return this.#getOrCreateModuleJobAfterResolve(parentURL, resolveResult, request, requestType);

};

if (isPromise(maybePromise)) {

return PromisePrototypeThen(maybePromise, afterResolve);

}

return afterResolve(maybePromise);

}

/**

async import(specifier, parentURL, importAttributes, phase = kEvaluationPhase, isEntryPoint = false) {

return onImport.tracePromise(async () => {

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

let moduleJob;

try {

moduleJob = await this.getOrCreateModuleJob(parentURL, request);

} catch (e) {

if (e?.code === 'ERR_ASYNC_LOADER_REQUEST_NEVER_SETTLED') {

return new Promise(() => {});

}

throw e;

}

if (phase === kSourcePhase) {

const module = await moduleJob.modulePromise;

return module.getModuleSourceObject();

}

const { module } = await moduleJob.run(isEntryPoint);

return module.getNamespace();

}, {

__proto__: null,

parentURL,

url: specifier,

});

}

/**

register(specifier, parentURL, data, transferList, isInternal) {

if (!this.#asyncLoaderHooks) {

// On the loader hook worker thread, the #asyncLoaderHooks must already have been initialized

// to be an instance of AsyncLoaderHooksOnLoaderHookWorker, so this branch can only ever

// be hit on a non-loader-hook thread that will talk to the loader hook worker thread.

const { AsyncLoaderHooksProxiedToLoaderHookWorker } = require('internal/modules/esm/hooks');

this.#setAsyncLoaderHooks(new AsyncLoaderHooksProxiedToLoaderHookWorker());

}

return this.#asyncLoaderHooks.register(`${specifier}`, `${parentURL}`, data, transferList, isInternal);

}

/**

#resolve(parentURL, request) {

if (this.isForAsyncLoaderHookWorker) {

const specifier = `${request.specifier}`;

const importAttributes = request.attributes ?? kEmptyObject;

// TODO(joyeecheung): invoke the synchronous hooks in the default step on loader thread.

return this.#asyncLoaderHooks.resolve(specifier, parentURL, importAttributes);

}

return this.resolveSync(parentURL, request);

}

/**

#cachedDefaultResolve(specifier, context) {

const { parentURL, importAttributes } = context;

const requestKey = this.#resolveCache.serializeKey(specifier, importAttributes);

const cachedResult = this.#resolveCache.get(requestKey, parentURL);

if (cachedResult != null) {

return cachedResult;

}

const result = defaultResolve(specifier, context);

this.#resolveCache.set(requestKey, parentURL, result);

return result;

}

/**

#resolveAndMaybeBlockOnLoaderThread(out, specifier, context) {

if (this.#asyncLoaderHooks?.resolveSync) {

return this.#asyncLoaderHooks.resolveSync(specifier, context.parentURL, context.importAttributes);

}

out.isResolvedByDefaultResolve = true;

return this.#cachedDefaultResolve(specifier, context);

}

/**

resolveSync(parentURL, request, shouldSkipSyncHooks = false) {

const specifier = `${request.specifier}`;

const importAttributes = request.attributes ?? kEmptyObject;

// Use an output parameter to track the state and avoid polluting the user-visible resolve results.

const out = { isResolvedByDefaultResolve: false, __proto__: null };

let result;

let isResolvedBySyncHooks = false;

if (!shouldSkipSyncHooks && syncResolveHooks.length) {

// Has module.registerHooks() hooks, chain the asynchronous hooks in the default step.

result = resolveWithSyncHooks(specifier, parentURL, importAttributes, this.#defaultConditions,

this.#resolveAndMaybeBlockOnLoaderThread.bind(this, out));

// If the default step ran, sync hooks did not short-circuit the resolution.

isResolvedBySyncHooks = !out.isResolvedByDefaultResolve;

} else {

const context = {

...request,

conditions: this.#defaultConditions,

parentURL,

importAttributes,

__proto__: null,

};

result = this.#resolveAndMaybeBlockOnLoaderThread(out, specifier, context);

}

result.isResolvedBySyncHooks = isResolvedBySyncHooks;

return result;

}

/**

load(url, context) {

if (this.isForAsyncLoaderHookWorker) {

// TODO(joyeecheung): invoke the synchronous hooks in the default step on loader thread.

return this.#asyncLoaderHooks.load(url, context);

}

return this.#loadSync(url, context);

}

/**

#loadAndMaybeBlockOnLoaderThread(out, url, context) {

if (this.#asyncLoaderHooks?.loadSync) {

out.isSourceLoadedSynchronously = false;

return this.#asyncLoaderHooks.loadSync(url, context);

}

out.isSourceLoadedSynchronously = true;

return defaultLoadSync(url, context);

}

/**

#loadSync(url, context) {

// Use an output parameter to track the state and avoid polluting the user-visible resolve results.

const out = {

isSourceLoadedSynchronously: true,

__proto__: null,

};

let result;

if (syncLoadHooks.length) {

// Has module.registerHooks() hooks, chain the asynchronous hooks in the default step.

// TODO(joyeecheung): construct the ModuleLoadContext in the loaders directly instead

// of converting them from plain objects in the hooks.

result = loadWithSyncHooks(

url,

context.format,

context.importAttributes,

this.#defaultConditions,

this.#loadAndMaybeBlockOnLoaderThread.bind(this, out),

validateLoadSloppy,

);

} else {

result = this.#loadAndMaybeBlockOnLoaderThread(out, url, context);

}

result.isSourceLoadedSynchronously = out.isSourceLoadedSynchronously;

return result;

}

validateLoadResult(url, format) {

if (format == null) {

throwUnknownModuleFormat(url, format);

}

}

/**

waitForAsyncLoaderHookInitialization() {

this.#asyncLoaderHooks?.waitForLoaderHookInitialization();

}

// Don't spawn a new loader hook worker if we are already in a loader hook worker to avoid infinite recursion.

if (shouldSpawnLoaderHookWorker()) {

assert(asyncLoaderHooks === undefined, 'asyncLoaderHooks should only be provided on the loader hook thread itself');

const userLoaderPaths = getOptionValue('--experimental-loader');

if (userLoaderPaths.length > 0) {

if (!emittedLoaderFlagWarning) {

const readableURIEncode = (string) => ArrayPrototypeReduce(

[

[/'/g, '%27'], // We need to URL-encode the single quote as it's the delimiter for the --import flag.

[/%22/g, '"'], // We can decode the double quotes to improve readability.

[/%2F/ig, '/'], // We can decode the slashes to improve readability.

],

(str, { 0: regex, 1: replacement }) => RegExpPrototypeSymbolReplace(hardenRegExp(regex), str, replacement),

encodeURIComponent(string));

process.emitWarning(

'`--experimental-loader` may be removed in the future; instead use `register()`:\n' +

`--import 'data:text/javascript,import { register } from "node:module"; import { pathToFileURL } from "node:url"; ${ArrayPrototypeJoin(

'ExperimentalWarning',

);

emittedLoaderFlagWarning = true;

}

const { AsyncLoaderHooksProxiedToLoaderHookWorker } = require('internal/modules/esm/hooks');

asyncLoaderHooks = new AsyncLoaderHooksProxiedToLoaderHookWorker();

}

}

return new ModuleLoader(asyncLoaderHooks);

/**

return function resolve(specifier, parentURL) {

// The second argument is ignored unless --experimental-import-meta-resolve is enabled.

// Even then, if it's not provided, parentURL defaults to the url of the module accessing

// import.meta.resolve.

allowImportMetaResolveParentURL ??= getOptionValue('--experimental-import-meta-resolve');

parentURL = allowImportMetaResolveParentURL ? (parentURL ?? moduleURL) : moduleURL;

let url;

try {

({ url } = loader.resolveSync(parentURL, { specifier, __proto__: null }));

return url;

} catch (error) {

switch (error?.code) {

case 'ERR_UNSUPPORTED_DIR_IMPORT':

case 'ERR_MODULE_NOT_FOUND':

({ url } = error);

if (url) {

return url;

}

}

throw error;

}

};

if (!cascadedLoader) {

cascadedLoader = createModuleLoader(asyncLoaderHooks);

// import.meta.resolve is not allowed in the async loader hook worker thread.

// So only set up the import.meta.resolve initializer when we are initializing

// the non-loader-hook-thread cascaded loader. When the native land doesn't see it,

// it knows the loader is running on the loader hook thread.

if (!(asyncLoaderHooks?.isForAsyncLoaderHookWorker)) {

setImportMetaResolveInitializer(createImportMetaResolve.bind(null, cascadedLoader));

}

}

return cascadedLoader;