kErrored,

kSourcePhase,

throwIfPromiseRejected,

setImportMetaResolveInitializer,

} = internalBinding('module_wrap');

const {

urlToFilename,

loadWithHooks: loadWithSyncHooks,

validateLoadSloppy,

} = require('internal/modules/customization_hooks');

let defaultResolve, defaultLoadSync, importMetaInitializer;

let defaultResolve, defaultLoadSync;

const { tracingChannel } = require('diagnostics_channel');

const onImport = tracingChannel('module.import');

*/

translators = getTranslators();

/**

* Truthy to allow the use of `import.meta.resolve`. This is needed

* currently because the `Hooks` class does not have `resolveSync`

* implemented and `import.meta.resolve` requires it.

*/

allowImportMetaResolve;

/**

* @see {AsyncLoaderHooks.isForAsyncLoaderHookWorker}

* Shortcut to this.#asyncLoaderHooks.isForAsyncLoaderHookWorker.

* Asynchronous loader hooks to pass requests to.

*

* Note that this value _MUST_ be set with `#setAsyncLoaderHooks`

* because it needs to copy `#asyncLoaderHooks.allowImportMetaResolve`

* to this property and failure to do so will cause undefined

* behavior when invoking `import.meta.resolve`.

* because it needs to copy `#asyncLoaderHooks.isForAsyncLoaderHookWorker`

* to this property.

* TODO(joyeecheung): this was a legacy of the previous setup of import.meta.resolve

* configuration; put this information in the environment directly instead.

*

* When the ModuleLoader is created on a loader hook thread, this is

* {@link AsyncLoaderHooksOnLoaderHookWorker}, and its methods directly call out

#setAsyncLoaderHooks(asyncLoaderHooks) {

this.#asyncLoaderHooks = asyncLoaderHooks;

if (asyncLoaderHooks) {

this.allowImportMetaResolve = asyncLoaderHooks.allowImportMetaResolve;

this.isForAsyncLoaderHookWorker = asyncLoaderHooks.isForAsyncLoaderHookWorker;

} else {

this.allowImportMetaResolve = true;

this.isForAsyncLoaderHookWorker = false;

}

}

}

}

importMetaInitialize(meta, context) {

if (this.#asyncLoaderHooks) {

return this.#asyncLoaderHooks.importMetaInitialize(meta, context, this);

}

importMetaInitializer ??= require('internal/modules/esm/initialize_import_meta').initializeImportMeta;

meta = importMetaInitializer(meta, context, this);

return meta;

}

/**

* Block until the async loader hooks have been initialized.

*

return new ModuleLoader(asyncLoaderHooks);

}

let cascadedLoader;

let allowImportMetaResolveParentURL;

/**

* This is only called from the native ImportMetaObjectInitialize function to set up import.meta.resolve

* when import.meta.resolve is accessed for the first time in a module.

* @param {ModuleLoader} loader The cascaded loader to use. Bound when this function gets passed to native land.

* @param {string} moduleURL URL of the module accessing import.meta

* @returns {function(string, URL['href']=): string} The import.meta.resolve function

*/

function createImportMetaResolve(loader, moduleURL) {

/**

* @param {string} specifier The module specifier to resolve.

* @param {URL['href']} [parentURL] Optional parent URL to resolve against. Ignored unless

* `--experimental-import-meta-resolve` is enabled.

* @returns {string}

*/

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;

}

};

}

let cascadedLoader;

/**

* This is a singleton ESM loader that integrates the loader hooks, if any.

* It it used by other internal built-ins when they need to load user-land ESM code

* @returns {ModuleLoader}

*/

function getOrInitializeCascadedLoader(asyncLoaderHooks) {

cascadedLoader ??= createModuleLoader(asyncLoaderHooks);

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;

}