StringPrototypeEndsWith,

} = primordials;

const { containsModuleSyntax } = internalBinding('contextify');

const { getOptionValue } = require('internal/options');

const path = require('path');

const { pathToFileURL } = require('internal/url');

case 'commonjs':

return false;

default: { // No package.json or no `type` field.

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

// If the first argument of `containsModuleSyntax` is undefined, it will read `mainPath` from the file system.

return containsModuleSyntax(undefined, mainPath);

}

return false;

}

}

* by `require('module')`) even when the entry point is ESM.

* This monkey-patchable code is bypassed under `--experimental-default-type=module`.

* Because of backwards compatibility, this function is exposed publicly via `import { runMain } from 'node:module'`.

* When `--experimental-detect-module` is passed, this function will attempt to run ambiguous (no explicit extension, no

* `package.json` type field) entry points as CommonJS first; under certain conditions, it will retry running as ESM.

* @param {string} main - First positional CLI argument, such as `'entry.js'` from `node entry.js`

*/

function executeUserEntryPoint(main = process.argv[1]) {

const resolvedMain = resolveMainPath(main);

const useESMLoader = shouldUseESMLoader(resolvedMain);

if (useESMLoader) {

// Unless we know we should use the ESM loader to handle the entry point per the checks in `shouldUseESMLoader`, first

// try to run the entry point via the CommonJS loader; and if that fails under certain conditions, retry as ESM.

let retryAsESM = false;

if (!useESMLoader) {

const cjsLoader = require('internal/modules/cjs/loader');

const { Module } = cjsLoader;

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

try {

// Module._load is the monkey-patchable CJS module loader.

Module._load(main, null, true);

} catch (error) {

const source = cjsLoader.entryPointSource;

const { shouldRetryAsESM } = require('internal/modules/helpers');

retryAsESM = shouldRetryAsESM(error.message, source);

// In case the entry point is a large file, such as a bundle,

// ensure no further references can prevent it being garbage-collected.

cjsLoader.entryPointSource = undefined;

if (!retryAsESM) {

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

enrichCJSError(error, source, resolvedMain);

throw error;

}

}

} else { // `--experimental-detect-module` is not passed

Module._load(main, null, true);

}

}

if (useESMLoader || retryAsESM) {

const mainPath = resolvedMain || main;

const mainURL = pathToFileURL(mainPath).href;

// even after the event loop stops running.

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

});

} else {

// Module._load is the monkey-patchable CJS module loader.

const { Module } = require('internal/modules/cjs/loader');

Module._load(main, null, true);

}

}