// Copyright Joyent, Inc. and other Node contributors.

//

// Permission is hereby granted, free of charge, to any person obtaining a

// copy of this software and associated documentation files (the

// "Software"), to deal in the Software without restriction, including

// without limitation the rights to use, copy, modify, merge, publish,

// distribute, sublicense, and/or sell copies of the Software, and to permit

// persons to whom the Software is furnished to do so, subject to the

// following conditions:

//

// The above copyright notice and this permission notice shall be included

// in all copies or substantial portions of the Software.

//

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN

// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,

// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE

// USE OR OTHER DEALINGS IN THE SOFTWARE.

'use strict';

const {

ArrayIsArray,

ArrayPrototypeFilter,

ArrayPrototypeIncludes,

ArrayPrototypeIndexOf,

ArrayPrototypeJoin,

ArrayPrototypeMap,

ArrayPrototypePush,

ArrayPrototypePushApply,

ArrayPrototypeSlice,

ArrayPrototypeSplice,

ArrayPrototypeUnshift,

ArrayPrototypeUnshiftApply,

Boolean,

Error,

FunctionPrototypeCall,

JSONParse,

ObjectDefineProperty,

ObjectFreeze,

ObjectGetOwnPropertyDescriptor,

ObjectGetPrototypeOf,

ObjectHasOwn,

ObjectKeys,

ObjectPrototype,

ObjectPrototypeHasOwnProperty,

ObjectSetPrototypeOf,

Proxy,

ReflectSet,

RegExpPrototypeExec,

SafeMap,

SafeSet,

String,

StringPrototypeCharAt,

StringPrototypeCharCodeAt,

StringPrototypeEndsWith,

StringPrototypeIndexOf,

StringPrototypeRepeat,

StringPrototypeSlice,

StringPrototypeSplit,

StringPrototypeStartsWith,

Symbol,

} = primordials;

const {

privateSymbols: {

module_source_private_symbol,

module_export_names_private_symbol,

module_circular_visited_private_symbol,

module_export_private_symbol,

module_first_parent_private_symbol,

module_last_parent_private_symbol,

},

isInsideNodeModules,

} = internalBinding('util');

const { kEvaluated, createRequiredModuleFacade } = internalBinding('module_wrap');

// Internal properties for Module instances.

/**

* Cached {@link Module} source string.

*/

const kModuleSource = module_source_private_symbol;

/**

* Cached {@link Module} export names for ESM loader.

*/

const kModuleExportNames = module_export_names_private_symbol;

/**

* {@link Module} circular dependency visited flag.

*/

const kModuleCircularVisited = module_circular_visited_private_symbol;

/**

* {@link Module} export object snapshot for ESM loader.

*/

const kModuleExport = module_export_private_symbol;

/**

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

*/

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');

const kRequiredModuleSymbol = Symbol('kRequiredModuleSymbol');

const kIsExecuting = Symbol('kIsExecuting');

const kURL = Symbol('kURL');

const kFormat = Symbol('kFormat');

// Set first due to cycle with ESM loader functions.

module.exports = {

kModuleSource,

kModuleExport,

kModuleExportNames,

kModuleCircularVisited,

initializeCJS,

Module,

findLongestRegisteredExtension,

resolveForCJSWithHooks,

loadSourceForCJSWithHooks: loadSource,

populateCJSExportsFromESM,

wrapSafe,

wrapModuleLoad,

kIsMainSymbol,

kIsCachedByESMLoader,

kRequiredModuleSymbol,

kIsExecuting,

};

const { BuiltinModule } = require('internal/bootstrap/realm');

const {

maybeCacheSourceMap,

} = require('internal/source_map/source_map_cache');

const { pathToFileURL, fileURLToPath, isURL, URL } = require('internal/url');

const {

pendingDeprecate,

emitExperimentalWarning,

kEmptyObject,

setOwnProperty,

getLazy,

isWindows,

isUnderNodeModules,

} = require('internal/util');

const {

makeContextifyScript,

runScriptInThisContext,

} = require('internal/vm');

const {

containsModuleSyntax,

compileFunctionForCJSLoader,

} = internalBinding('contextify');

const assert = require('internal/assert');

const fs = require('fs');

const path = require('path');

const internalFsBinding = internalBinding('fs');

const { safeGetenv } = internalBinding('credentials');

const {

getCjsConditions,

getCjsConditionsArray,

initializeCjsConditions,

loadBuiltinModule,

makeRequireFunction,

setHasStartedUserCJSExecution,

stripBOM,

toRealPath,

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

const {

convertCJSFilenameToURL,

convertURLToCJSFilename,

loadHooks,

loadWithHooks,

registerHooks,

resolveHooks,

resolveWithHooks,

validateLoadStrict,

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

const { stripTypeScriptModuleTypes } = require('internal/modules/typescript');

const packageJsonReader = require('internal/modules/package_json_reader');

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

const shouldReportRequiredModules = getLazy(() => process.env.WATCH_REPORT_DEPENDENCIES);

const {

hasPackageMap,

packageMapResolve,

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

const {

vm_dynamic_import_default_internal,

} = internalBinding('symbols');

const {

codes: {

ERR_INVALID_ARG_TYPE,

ERR_INVALID_ARG_VALUE,

ERR_INVALID_MODULE_SPECIFIER,

ERR_REQUIRE_CYCLE_MODULE,

ERR_REQUIRE_ESM,

ERR_UNKNOWN_BUILTIN_MODULE,

ERR_UNKNOWN_MODULE_FORMAT,

},

setArrowMessage,

} = require('internal/errors');

const { validateString } = require('internal/validators');

const {

CHAR_BACKWARD_SLASH,

CHAR_COLON,

CHAR_DOT,

CHAR_FORWARD_SLASH,

} = require('internal/constants');

const {

isProxy,

} = require('internal/util/types');

const { debuglog, debugWithTimer } = require('internal/util/debuglog');

let { startTimer, endTimer } = debugWithTimer('module_timer', (start, end) => {

startTimer = start;

endTimer = end;

});

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

const onRequire = getLazy(() => tracingChannel('module.require'));

const relativeResolveCache = { __proto__: null };

let requireDepth = 0;

let isPreloading = false;

let statCache = null;

/**

* Internal method to add tracing capabilities for Module._load.

*

* See more {@link Module._load}

* @returns {object}

*/

function wrapModuleLoad(request, parent, isMain, options) {

const logLabel = `[${parent?.id || ''}] [${request}]`;

const traceLabel = `require('${request}')`;

const channel = onRequire();

startTimer(logLabel, traceLabel);

try {

if (channel.hasSubscribers) {

return onRequire().traceSync(Module._load, {

__proto__: null,

parentFilename: parent?.filename,

id: request,

}, Module, request, parent, isMain, options);

}

// No subscribers, skip the wrapping to avoid clobbering stack traces

// and debugging steps.

return Module._load(request, parent, isMain, options);

} finally {

endTimer(logLabel, traceLabel);

}

}

/**

* Get a path's properties, using an in-memory cache to minimize lookups.

* @param {string} filename Absolute path to the file

* @returns {number}

*/

function stat(filename) {

// Guard against internal bugs where a non-string filename is passed in by mistake.

assert(typeof filename === 'string');

filename = path.toNamespacedPath(filename);

if (statCache !== null) {

const result = statCache.get(filename);

if (result !== undefined) { return result; }

}

const result = internalFsBinding.internalModuleStat(filename);

if (statCache !== null && result >= 0) {

// Only set cache when `internalModuleStat(filename)` succeeds.

statCache.set(filename, result);

}

return result;

}

let _stat = stat;

ObjectDefineProperty(Module, '_stat', {

__proto__: null,

get() { return _stat; },

set(stat) {

emitExperimentalWarning('Module._stat');

_stat = stat;

return true;

},

configurable: true,

});

/**

* Update the parent's children array with the child module.

* @param {Module} parent Module requiring the children

* @param {Module} child Module being required

* @param {boolean} scan Add the child to the parent's children if not already present

* @returns {void}

*/

function updateChildren(parent, child, scan) {

const children = parent?.children;

if (children && !(scan && ArrayPrototypeIncludes(children, child))) {

ArrayPrototypePush(children, child);

}

}

/**

* Tell the watch mode that a module was required.

* @param {string} filename Absolute path of the module

* @returns {void}

*/

function reportModuleToWatchMode(filename) {

if (shouldReportRequiredModules() && process.send) {

process.send({ 'watch:require': [filename] });

}

}

/**

* Tell the watch mode that a module was not found.

* @param {string} basePath The absolute path that errored

* @param {string[]} extensions The extensions that were tried

* @returns {void}

*/

function reportModuleNotFoundToWatchMode(basePath, extensions) {

if (shouldReportRequiredModules() && process.send) {

process.send({ 'watch:require': ArrayPrototypeMap(extensions, (ext) => path.resolve(`${basePath}${ext}`)) });

}

}

/**

* Tell the watch mode that a module was required, from within a worker thread.

* @param {string} filename Absolute path of the module

* @returns {void}

*/

function reportModuleToWatchModeFromWorker(filename) {

if (!shouldReportRequiredModules()) {

return;

}

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

if (isMainThread) {

return;

}

// Lazy require to avoid circular dependency: worker_threads is loaded after

// the CJS loader is fully set up.

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

if (!parentPort) {

return;

}

parentPort.postMessage({ 'watch:require': [filename] });

}

/**

* Create a new module instance.

* @param {string} id

* @param {Module} parent

* @returns {void}

*/

function Module(id = '', parent) {

this.id = id;

this.path = path.dirname(id);

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

this[kFirstModuleParent] = parent;

this[kLastModuleParent] = parent;

updateChildren(parent, this, false);

this.filename = null;

this.loaded = false;

this.children = [];

}

/** @type {Record<string, Module>} */

Module._cache = { __proto__: null };

/** @type {Record<string, string>} */

Module._pathCache = { __proto__: null };

/** @type {{[key: string]: function(Module, string): void}} */

Module._extensions = { __proto__: null };

/** @type {string[]} */

let modulePaths = [];

/** @type {string[]} */

Module.globalPaths = [];

let patched = false;

/**

* Add the CommonJS wrapper around a module's source code.

* @param {string} script Module source code

* @returns {string}

*/

let wrap = function(script) { // eslint-disable-line func-style

return Module.wrapper[0] + script + Module.wrapper[1];

};

const wrapper = [

'(function (exports, require, module, __filename, __dirname) { ',

'\n});',

];

let wrapperProxy = new Proxy(wrapper, {

__proto__: null,

set(target, property, value, receiver) {

patched = true;

return ReflectSet(target, property, value, receiver);

},

defineProperty(target, property, descriptor) {

patched = true;

return ObjectDefineProperty(target, property, descriptor);

},

});

ObjectDefineProperty(Module, 'wrap', {

__proto__: null,

get() {

return wrap;

},

set(value) {

patched = true;

wrap = value;

},

});

ObjectDefineProperty(Module, 'wrapper', {

__proto__: null,

get() {

return wrapperProxy;

},

set(value) {

patched = true;

wrapperProxy = value;

},

});

const isPreloadingDesc = { get() { return isPreloading; } };

ObjectDefineProperty(Module.prototype, 'isPreloading', isPreloadingDesc);

ObjectDefineProperty(BuiltinModule.prototype, 'isPreloading', isPreloadingDesc);

/**

* Get the parent of the current module from our cache.

* @this {Module}

* @returns {object}

*/

function getModuleParent() {

return this[kFirstModuleParent];

}

/**

* Set the parent of the current module in our cache.

* @this {Module}

* @param {Module} value

* @returns {void}

*/

function setModuleParent(value) {

this[kFirstModuleParent] = value;

}

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

debug = fn;

});

ObjectDefineProperty(Module.prototype, 'parent', {

__proto__: null,

get: pendingDeprecate(

getModuleParent,

'module.parent is deprecated due to accuracy issues. Please use ' +

'require.main to find program entry point instead.',

'DEP0144',

),

set: pendingDeprecate(

setModuleParent,

'module.parent is deprecated due to accuracy issues. Please use ' +

'require.main to find program entry point instead.',

'DEP0144',

),

});

Module.isBuiltin = BuiltinModule.isBuiltin;

/**

* Prepare to run CommonJS code.

* This function is called during pre-execution, before any user code is run.

* @returns {void}

*/

function initializeCJS() {

// This need to be done at runtime in case --expose-internals is set.

let modules = Module.builtinModules = BuiltinModule.getAllBuiltinModuleIds();

if (!getOptionValue('--experimental-dtls')) {

modules = modules.filter((i) => i !== 'node:dtls');

}

if (!getOptionValue('--experimental-quic')) {

modules = modules.filter((i) => i !== 'node:quic');

}

if (!getOptionValue('--experimental-ffi')) {

modules = modules.filter((i) => i !== 'node:ffi');

}

if (!getOptionValue('--experimental-vfs')) {

modules = modules.filter((i) => i !== 'node:vfs');

}

Module.builtinModules = ObjectFreeze(modules);

initializeCjsConditions();

if (!getEmbedderOptions().noGlobalSearchPaths) {

Module._initPaths();

}

// TODO(joyeecheung): deprecate this in favor of a proper hook?

Module.runMain =

require('internal/modules/run_main').executeUserEntryPoint;

}

// Given a module name, and a list of paths to test, returns the first

// matching file in the following precedence.

//

// require("a.<ext>")

// -> a.<ext>

//

// require("a")

// -> a

// -> a.<ext>

// -> a/index.<ext>

let _readPackage = (requestPath) => packageJsonReader.read(path.resolve(requestPath, 'package.json'));

ObjectDefineProperty(Module, '_readPackage', {

__proto__: null,

get() { return _readPackage; },

set(readPackage) {

emitExperimentalWarning('Module._readPackage');

_readPackage = readPackage;

return true;

},

configurable: true,

});

/**

* Try to load a specifier as a package.

* @param {string} requestPath The path to what we are trying to load

* @param {string[]} exts File extensions to try appending in order to resolve the file

* @param {boolean} isMain Whether the file is the main entry point of the app

* @param {string} originalPath The specifier passed to `require`

* @returns {any}

*/

function tryPackage(requestPath, exts, isMain, originalPath) {

const { main: pkg, pjsonPath } = _readPackage(requestPath);

if (!pkg) {

return tryExtensions(path.resolve(requestPath, 'index'), exts, isMain);

}

const filename = path.resolve(requestPath, pkg);

let actual = tryFile(filename, isMain) ||

tryExtensions(filename, exts, isMain) ||

tryExtensions(path.resolve(filename, 'index'), exts, isMain);

if (actual === false) {

actual = tryExtensions(path.resolve(requestPath, 'index'), exts, isMain);

if (!actual) {

// eslint-disable-next-line no-restricted-syntax

const err = new Error(

`Cannot find module '${filename}'. ` +

'Please verify that the package.json has a valid "main" entry',

);

err.code = 'MODULE_NOT_FOUND';

err.path = pjsonPath;

err.requestPath = originalPath;

// TODO(BridgeAR): Add the requireStack as well.

throw err;

} else {

process.emitWarning(

`Invalid 'main' field in '${pjsonPath}' of '${pkg}'. ` +

'Please either fix that or report it to the module author',

'DeprecationWarning',

'DEP0128',

);

}

}

return actual;

}

/**

* Check if the file exists and is not a directory if using `--preserve-symlinks` and `isMain` is false or

* `--preserve-symlinks-main` and `isMain` is true , keep symlinks intact, otherwise resolve to the absolute realpath.

* @param {string} requestPath The path to the file to load.

* @param {boolean} isMain Whether the file is the main module.

* @returns {string|undefined}

*/

function tryFile(requestPath, isMain) {

const rc = _stat(requestPath);

if (rc !== 0) { return; }

if (getOptionValue(isMain ? '--preserve-symlinks-main' : '--preserve-symlinks')) {

return path.resolve(requestPath);

}

return toRealPath(requestPath);

}

/**

* Given a path, check if the file exists with any of the set extensions.

* @param {string} basePath The path and filename without extension

* @param {string[]} exts The extensions to try

* @param {boolean} isMain Whether the module is the main module

* @returns {string|false}

*/

function tryExtensions(basePath, exts, isMain) {

for (let i = 0; i < exts.length; i++) {

const filename = tryFile(basePath + exts[i], isMain);

if (filename) {

return filename;

}

}

return false;

}

/**

* Find the longest (possibly multi-dot) extension registered in `Module._extensions`.

* @param {string} filename The filename to find the longest registered extension for.

* @returns {string}

*/

function findLongestRegisteredExtension(filename) {

const name = path.basename(filename);

let currentExtension;

let index;

let startIndex = 0;

while ((index = StringPrototypeIndexOf(name, '.', startIndex)) !== -1) {

startIndex = index + 1;

if (index === 0) { continue; } // Skip dotfiles like .gitignore

currentExtension = StringPrototypeSlice(name, index);

if (Module._extensions[currentExtension]) { return currentExtension; }

}

return '.js';

}

/**

* Tries to get the absolute file path of the parent module.

* @param {Module} parent The parent module object.

* @returns {string|false|void}

*/

function trySelfParentPath(parent) {

if (!parent) { return false; }

if (parent.filename) {

return parent.filename;

} else if (parent.id === '<repl>' || parent.id === 'internal/preload') {

try {

return process.cwd() + path.sep;

} catch {

return false;

}

}

}

/**

* Attempt to resolve a module request using the parent module package metadata.

* @param {string} parentPath The path of the parent module

* @param {string} request The module request to resolve

* @param {unknown} conditions

* @returns {false|string}

*/

function trySelf(parentPath, request, conditions) {

if (!parentPath) { return false; }

const pkg = packageJsonReader.getNearestParentPackageJSON(parentPath);

if (pkg?.data.exports === undefined || pkg.data.name === undefined) {

return false;

}

let expansion;

if (request === pkg.data.name) {

expansion = '.';

} else if (StringPrototypeStartsWith(request, `${pkg.data.name}/`)) {

expansion = '.' + StringPrototypeSlice(request, pkg.data.name.length);

} else {

return false;

}

return resolveExpansion(expansion, pkg.path, pkg.data, parentPath, conditions);

}

/**

* Try to resolve using package map (if enabled via --experimental-package-map).

* @param {string} request - The bare specifier

* @param {Module} parent - The parent module

* @param {Set<string>} conditions - Export conditions

* @returns {string|undefined}

*/

function tryPackageMapResolveCJS(request, parent, conditions) {

if (!hasPackageMap()) { return undefined; }

const parentPath = trySelfParentPath(parent);

if (!parentPath) { return undefined; }

const mapped = packageMapResolve(request, parentPath);

if (mapped === undefined) {

const requireStack = getRequireStack(parent);

const message = getRequireStackMessage(request, requireStack);

// eslint-disable-next-line no-restricted-syntax

const err = new Error(message);

setOwnProperty(err, 'code', 'MODULE_NOT_FOUND');

setOwnProperty(err, 'requireStack', requireStack);

throw err;

}

const { packagePath, subpath } = mapped;

const packageJSONPath = path.resolve(packagePath, 'package.json');

const pkg = packageJsonReader.read(packageJSONPath);

if (pkg.exports !== undefined) {

return resolveExpansion(subpath, packageJSONPath, pkg, parentPath, conditions);

}

// No exports - try standard path resolution within the package

return Module._findPath(subpath, [packagePath], false, conditions);

}

function resolveExpansion(expansion, pkgJsonPath, pkgData, parentPath, conditions) {

const pkgPath = path.dirname(pkgJsonPath);

try {

const { packageExportsResolve } = require('internal/modules/esm/resolve');

return finalizeEsmResolution(packageExportsResolve(

pathToFileURL(pkgJsonPath), expansion, pkgData,

pathToFileURL(parentPath), conditions), parentPath, pkgPath);

} catch (e) {

if (e.code === 'ERR_MODULE_NOT_FOUND') {

throw createEsmNotFoundErr(expansion, pkgPath);

}

throw e;

}

}

/**

* This only applies to requests of a specific form:

* 1. `name/.*`

* 2. `@scope/name/.*`

*/

const EXPORTS_PATTERN = /^((?:@[^/\\%]+\/)?[^./\\%][^/\\%]*)(\/.*)?$/;

/**

* Resolves the exports for a given module path and request.

* @param {string} nmPath The path to the module.

* @param {string} request The request for the module.

* @param {Set<string>} conditions The conditions to use for resolution.

* @returns {undefined|string}

*/

function resolveExports(nmPath, request, conditions) {

// The implementation's behavior is meant to mirror resolution in ESM.

const { 1: name, 2: expansion = '' } =

RegExpPrototypeExec(EXPORTS_PATTERN, request) || kEmptyObject;

if (!name) { return; }

const pkgPath = path.resolve(nmPath, name);

const pkg = _readPackage(pkgPath);

if (pkg.exists && pkg.exports != null) {

try {

const { packageExportsResolve } = require('internal/modules/esm/resolve');

return finalizeEsmResolution(packageExportsResolve(

pathToFileURL(pkgPath + '/package.json'), '.' + expansion, pkg, null,

conditions), null, pkgPath);

} catch (e) {

if (e.code === 'ERR_MODULE_NOT_FOUND') {

throw createEsmNotFoundErr(request, pkgPath + '/package.json');

}

throw e;

}

}

}

/**

* Get the absolute path to a module.

* @param {string} request Relative or absolute file path

* @param {Array<string>} paths Folders to search as file paths

* @param {boolean} isMain Whether the request is the main app entry point

* @returns {string | false}

*/

Module._findPath = function(request, paths, isMain, conditions = getCjsConditions()) {

const absoluteRequest = path.isAbsolute(request);

if (absoluteRequest) {

paths = [''];

} else if (!paths || paths.length === 0) {

return false;

}

const cacheKey = request + '\x00' + ArrayPrototypeJoin(paths, '\x00');

const entry = Module._pathCache[cacheKey];

if (entry) {

return entry;

}

let exts;

const trailingSlash = request.length > 0 &&

(StringPrototypeCharCodeAt(request, request.length - 1) === CHAR_FORWARD_SLASH || (

StringPrototypeCharCodeAt(request, request.length - 1) === CHAR_DOT &&

(

request.length === 1 ||

StringPrototypeCharCodeAt(request, request.length - 2) === CHAR_FORWARD_SLASH ||

(StringPrototypeCharCodeAt(request, request.length - 2) === CHAR_DOT && (

request.length === 2 ||

StringPrototypeCharCodeAt(request, request.length - 3) === CHAR_FORWARD_SLASH

))

)

));

let insidePath = true;

if (isRelative(request)) {

const normalizedRequest = path.normalize(request);

if (StringPrototypeStartsWith(normalizedRequest, '..')) {

insidePath = false;

}

}

// For each path

for (let i = 0; i < paths.length; i++) {

// Don't search further if path doesn't exist

const curPath = paths[i];

if (typeof curPath !== 'string') {

throw new ERR_INVALID_ARG_TYPE('paths', 'array of strings', paths);

}

if (insidePath && curPath && _stat(curPath) < 1) {

continue;

}

if (!absoluteRequest) {

const exportsResolved = resolveExports(curPath, request, conditions);

if (exportsResolved) {

return exportsResolved;

}

}

const basePath = path.resolve(curPath, request);

let filename;

const rc = _stat(basePath);

if (!trailingSlash) {

if (rc === 0) { // File.

if (!isMain) {

if (getOptionValue('--preserve-symlinks')) {

filename = path.resolve(basePath);

} else {

filename = toRealPath(basePath);

}

} else if (getOptionValue('--preserve-symlinks-main')) {

// For the main module, we use the --preserve-symlinks-main flag instead

// mainly for backward compatibility, as the preserveSymlinks flag

// historically has not applied to the main module. Most likely this

// was intended to keep .bin/ binaries working, as following those

// symlinks is usually required for the imports in the corresponding

// files to resolve; that said, in some use cases following symlinks

// causes bigger problems which is why the --preserve-symlinks-main option

// is needed.

filename = path.resolve(basePath);

} else {

filename = toRealPath(basePath);

}

}

if (!filename) {

// Try it with each of the extensions

if (exts === undefined) {

exts = ObjectKeys(Module._extensions);

}

filename = tryExtensions(basePath, exts, isMain);

}

}

if (!filename && rc === 1) { // Directory.

// try it with each of the extensions at "index"

if (exts === undefined) {

exts = ObjectKeys(Module._extensions);

}

filename = tryPackage(basePath, exts, isMain, request);

}

if (filename) {

Module._pathCache[cacheKey] = filename;

return filename;

}

const extensions = [''];

if (exts !== undefined) {

ArrayPrototypePushApply(extensions, exts);

}

reportModuleNotFoundToWatchMode(basePath, extensions);

}

return false;

};

/** `node_modules` character codes reversed */

const nmChars = [ 115, 101, 108, 117, 100, 111, 109, 95, 101, 100, 111, 110 ];

const nmLen = nmChars.length;

if (isWindows) {

/**

* Get the paths to the `node_modules` folder for a given path.

* @param {string} from `__dirname` of the module

* @returns {string[]}

*/

Module._nodeModulePaths = function(from) {

// Guarantee that 'from' is absolute.

from = path.resolve(from);

// note: this approach *only* works when the path is guaranteed

// to be absolute. Doing a fully-edge-case-correct path.split

// that works on both Windows and Posix is non-trivial.

// return root node_modules when path is 'D:\\'.

// path.resolve will make sure from.length >=3 in Windows.

if (StringPrototypeCharCodeAt(from, from.length - 1) ===

CHAR_BACKWARD_SLASH &&

StringPrototypeCharCodeAt(from, from.length - 2) === CHAR_COLON) {

return [from + 'node_modules'];

}

/** @type {string[]} */

const paths = [];

for (let i = from.length - 1, p = 0, last = from.length; i >= 0; --i) {

const code = StringPrototypeCharCodeAt(from, i);

// The path segment separator check ('\' and '/') was used to get

// node_modules path for every path segment.

// Use colon as an extra condition since we can get node_modules

// path for drive root like 'C:\node_modules' and don't need to

// parse drive name.

if (code === CHAR_BACKWARD_SLASH ||

code === CHAR_FORWARD_SLASH ||

code === CHAR_COLON) {

if (p !== nmLen) {

ArrayPrototypePush(

paths,

StringPrototypeSlice(from, 0, last) + '\\node_modules',

);

}

last = i;

p = 0;

} else if (p !== -1) {

if (nmChars[p] === code) {

++p;

} else {

p = -1;

}

}

}

return paths;

};

} else { // posix

/**

* Get the paths to the `node_modules` folder for a given path.

* @param {string} from `__dirname` of the module

* @returns {string[]}

*/

Module._nodeModulePaths = function(from) {

// Guarantee that 'from' is absolute.

from = path.resolve(from);

// Return early not only to avoid unnecessary work, but to *avoid* returning

// an array of two items for a root: [ '//node_modules', '/node_modules' ]

if (from === '/') {

return ['/node_modules'];

}

// note: this approach *only* works when the path is guaranteed

// to be absolute. Doing a fully-edge-case-correct path.split

// that works on both Windows and Posix is non-trivial.

/** @type {string[]} */

const paths = [];

for (let i = from.length - 1, p = 0, last = from.length; i >= 0; --i) {

const code = StringPrototypeCharCodeAt(from, i);

if (code === CHAR_FORWARD_SLASH) {

if (p !== nmLen) {

ArrayPrototypePush(

paths,

StringPrototypeSlice(from, 0, last) + '/node_modules',

);

}

last = i;

p = 0;

} else if (p !== -1) {

if (nmChars[p] === code) {

++p;

} else {

p = -1;

}

}

}

// Append /node_modules to handle root paths.

ArrayPrototypePush(paths, '/node_modules');

return paths;

};

}

/**

* Get the paths for module resolution.

* @param {string} request

* @param {Module} parent

* @returns {null|string[]}