if (process.noDeprecation) {

return;

}

const pjsonPath = fileURLToPath(pjsonUrl);

if (emittedPackageWarnings.has(pjsonPath + '|' + match)) { return; }

emittedPackageWarnings.add(pjsonPath + '|' + match);

process.emitWarning(

`Use of deprecated trailing slash pattern mapping "${match}" in the ` +

`"exports" field module resolution of the package at ${pjsonPath}${

'DeprecationWarning',

'DEP0155',

);

if (process.noDeprecation) {

return;

}

const pjsonPath = fileURLToPath(pjsonUrl);

const double = RegExpPrototypeExec(doubleSlashRegEx, isTarget ? target : request) !== null;

process.emitWarning(

`Use of deprecated ${double ? 'double slash' :

'leading or trailing slash matching'} resolving "${target}" for module ` +

`request "${request}" ${request !== match ? `matched to "${match}" ` : ''

'DeprecationWarning',

'DEP0166',

);

if (process.noDeprecation) {

return;

}

const format = defaultGetFormatWithoutErrors(url);

if (format !== 'module') { return; }

const basePath = fileURLToPath(base);

if (!main) {

process.emitWarning(

`No "main" or "exports" field defined in the package.json for ${pkgPath

'DeprecationWarning',

'DEP0151',

);

} else if (resolve(pkgPath, main) !== path) {

process.emitWarning(

`Package ${pkgPath} has a "main" field set to "${main}", ` +

`excluding the full filename and extension to the resolved file at "${

basePath}.\n Automatic extension resolution of the "main" field is ` +

'deprecated for ES modules.',

'DeprecationWarning',

'DEP0151',

);

}

assert(isURL(packageJSONUrl));

const pkgPath = fileURLToPath(new URL('.', packageJSONUrl));

const baseStringified = isURL(base) ? base.href : base;

const resolvedOption = loaderMethods.legacyMainResolve(pkgPath, packageConfig.main, baseStringified);

const maybeMain = resolvedOption <= legacyMainResolveExtensionsIndexes.kResolvedByMainIndexNode ?

packageConfig.main || './' : '';

const resolvedPath = resolve(pkgPath, maybeMain + legacyMainResolveExtensions[resolvedOption]);

const resolvedUrl = pathToFileURL(resolvedPath);

emitLegacyIndexDeprecation(resolvedUrl, resolvedPath, pkgPath, base, packageConfig.main);

return resolvedUrl;

if (RegExpPrototypeExec(encodedSepRegEx, resolved.pathname) !== null) {

let basePath;

try {

basePath = fileURLToPath(base);

} catch {

basePath = base;

}

throw new ERR_INVALID_MODULE_SPECIFIER(

resolved.pathname, 'must not include encoded "/" or "\\" characters',

basePath);

}

let path;

try {

path = fileURLToPath(resolved);

} catch (err) {

setOwnProperty(err, 'input', `${resolved}`);

setOwnProperty(err, 'module', `${base}`);

throw err;

}

const stats = loaderMethods.internalModuleStat(

StringPrototypeEndsWith(path, '/') ? StringPrototypeSlice(path, -1) : path,

);

// Check for stats.isDirectory()

if (stats === 1) {

let basePath;

try {

basePath = fileURLToPath(base);

} catch {

basePath = base;

}

throw new ERR_UNSUPPORTED_DIR_IMPORT(path, basePath, String(resolved));

} else if (stats !== 0) {

// Check for !stats.isFile()

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

process.send({ 'watch:require': [path || resolved.pathname] });

}

let basePath;

try {

basePath = fileURLToPath(base);

} catch {

basePath = base;

}

throw new ERR_MODULE_NOT_FOUND(

path || resolved.pathname, basePath, resolved);

}

if (!preserveSymlinks) {

// If you are reading this code to figure out how to patch Node.js module loading

// behavior - DO NOT depend on the patchability in new code: Node.js

// internals may stop going through the JavaScript fs module entirely.

// Prefer module.registerHooks() or other more formal fs hooks released in the future.

const real = loaderMethods.realpathSync(path);

const { search, hash } = resolved;

resolved =

pathToFileURL(real + (StringPrototypeEndsWith(path, sep) ? '/' : ''));

resolved.search = search;

resolved.hash = hash;

}

return resolved;

return new ERR_PACKAGE_IMPORT_NOT_DEFINED(

specifier, packageJSONUrl && fileURLToPath(new URL('.', packageJSONUrl)),

fileURLToPath(base));

return new ERR_PACKAGE_PATH_NOT_EXPORTED(

fileURLToPath(new URL('.', packageJSONUrl)), subpath,

base && fileURLToPath(base));

const reason = `request is not a valid match in pattern "${match}" for the "${

throw new ERR_INVALID_MODULE_SPECIFIER(request, reason,

base && fileURLToPath(base));

subpath, target, packageJSONUrl, internal, base) {

if (typeof target === 'object' && target !== null) {

target = JSONStringify(target, null, '');

} else {

target = `${target}`;

}

return new ERR_INVALID_PACKAGE_TARGET(

fileURLToPath(new URL('.', packageJSONUrl)), subpath, target,

internal, base && fileURLToPath(base));

target,

subpath,

match,

packageJSONUrl,

base,

pattern,

internal,

isPathMap,

conditions,

) {

if (subpath !== '' && !pattern && target[target.length - 1] !== '/') {

throw invalidPackageTarget(match, target, packageJSONUrl, internal, base);

}

if (!StringPrototypeStartsWith(target, './')) {

if (internal &&

target[0] !== '/' &&

!StringPrototypeStartsWith(target, '../')) {

// No need to convert target to string, since it's already presumed to be

if (!URLCanParse(target)) {

const exportTarget = pattern ?

RegExpPrototypeSymbolReplace(patternRegEx, target, () => subpath) :

target + subpath;

return packageResolve(

exportTarget, packageJSONUrl, conditions);

}

}

throw invalidPackageTarget(match, target, packageJSONUrl, internal, base);

}

if (RegExpPrototypeExec(invalidSegmentRegEx, StringPrototypeSlice(target, 2)) !== null) {

if (RegExpPrototypeExec(deprecatedInvalidSegmentRegEx, StringPrototypeSlice(target, 2)) === null) {

if (!isPathMap) {

const request = pattern ?

StringPrototypeReplace(match, '*', () => subpath) :

match + subpath;

const resolvedTarget = pattern ?

RegExpPrototypeSymbolReplace(patternRegEx, target, () => subpath) :

target;

emitInvalidSegmentDeprecation(resolvedTarget, request, match, packageJSONUrl, internal, base, true);

}

} else {

throw invalidPackageTarget(match, target, packageJSONUrl, internal, base);

}

}

const resolved = new URL(target, packageJSONUrl);

const resolvedPath = resolved.pathname;

const packagePath = new URL('.', packageJSONUrl).pathname;

if (!StringPrototypeStartsWith(resolvedPath, packagePath)) {

throw invalidPackageTarget(match, target, packageJSONUrl, internal, base);

}

if (subpath === '') { return resolved; }

if (RegExpPrototypeExec(invalidSegmentRegEx, subpath) !== null) {

const request = pattern ? StringPrototypeReplace(match, '*', () => subpath) : match + subpath;

if (RegExpPrototypeExec(deprecatedInvalidSegmentRegEx, subpath) === null) {

if (!isPathMap) {

const resolvedTarget = pattern ?

RegExpPrototypeSymbolReplace(patternRegEx, target, () => subpath) :

target;

emitInvalidSegmentDeprecation(resolvedTarget, request, match, packageJSONUrl, internal, base, false);

}

} else {

throwInvalidSubpath(request, match, packageJSONUrl, internal, base);

}

}

if (pattern) {

return new URL(

RegExpPrototypeSymbolReplace(patternRegEx, resolved.href, () => subpath),

);

}

return new URL(subpath, resolved);

const keyNum = +key;

if (`${keyNum}` !== key) { return false; }

return keyNum >= 0 && keyNum < 0xFFFF_FFFF;

base, pattern, internal, isPathMap, conditions) {

if (typeof target === 'string') {

return resolvePackageTargetString(

target, subpath, packageSubpath, packageJSONUrl, base, pattern, internal,

isPathMap, conditions);

} else if (ArrayIsArray(target)) {

if (target.length === 0) {

return null;

}

let lastException;

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

const targetItem = target[i];

let resolveResult;

try {

resolveResult = resolvePackageTarget(

packageJSONUrl, targetItem, subpath, packageSubpath, base, pattern,

internal, isPathMap, conditions);

} catch (e) {

lastException = e;

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

continue;

}

throw e;

}

if (resolveResult === undefined) {

continue;

}

if (resolveResult === null) {

lastException = null;

continue;

}

return resolveResult;

}

if (lastException == null) {

return lastException;

}

throw lastException;

} else if (typeof target === 'object' && target !== null) {

const keys = ObjectGetOwnPropertyNames(target);

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

const key = keys[i];

if (isArrayIndex(key)) {

throw new ERR_INVALID_PACKAGE_CONFIG(

fileURLToPath(packageJSONUrl), base,

'"exports" cannot contain numeric property keys.');

}

}

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

const key = keys[i];

if (key === 'default' || conditions.has(key)) {

const conditionalTarget = target[key];

const resolveResult = resolvePackageTarget(

packageJSONUrl, conditionalTarget, subpath, packageSubpath, base,

pattern, internal, isPathMap, conditions);

if (resolveResult === undefined) { continue; }

return resolveResult;

}

}

return undefined;

} else if (target === null) {

return null;

}

throw invalidPackageTarget(packageSubpath, target, packageJSONUrl, internal,

base);

if (typeof exports === 'string' || ArrayIsArray(exports)) { return true; }

if (typeof exports !== 'object' || exports === null) { return false; }

const keys = ObjectGetOwnPropertyNames(exports);

let isConditionalSugar = false;

let i = 0;

for (let j = 0; j < keys.length; j++) {

const key = keys[j];

const curIsConditionalSugar = key === '' || key[0] !== '.';

if (i++ === 0) {

isConditionalSugar = curIsConditionalSugar;

} else if (isConditionalSugar !== curIsConditionalSugar) {

throw new ERR_INVALID_PACKAGE_CONFIG(

fileURLToPath(packageJSONUrl), base,

'"exports" cannot contain some keys starting with \'.\' and some not.' +

' The exports object must either be an object of package subpath keys' +

' or an object of main entry condition name keys only.');

}

}

return isConditionalSugar;

packageJSONUrl, packageSubpath, packageConfig, base, conditions) {

let { exports } = packageConfig;

if (isConditionalExportsMainSugar(exports, packageJSONUrl, base)) {

exports = { '.': exports };

}

if (ObjectPrototypeHasOwnProperty(exports, packageSubpath) &&

!StringPrototypeIncludes(packageSubpath, '*') &&

!StringPrototypeEndsWith(packageSubpath, '/')) {

const target = exports[packageSubpath];

const resolveResult = resolvePackageTarget(

packageJSONUrl, target, '', packageSubpath, base, false, false, false,

conditions,

);

if (resolveResult == null) {

throw exportsNotFound(packageSubpath, packageJSONUrl, base);

}

return resolveResult;

}

let bestMatch = '';

let bestMatchSubpath;

const keys = ObjectGetOwnPropertyNames(exports);

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

const key = keys[i];

const patternIndex = StringPrototypeIndexOf(key, '*');

if (patternIndex !== -1 &&

StringPrototypeStartsWith(packageSubpath,

StringPrototypeSlice(key, 0, patternIndex))) {

// When this reaches EOL, this can throw at the top of the whole function:

//

// if (StringPrototypeEndsWith(packageSubpath, '/'))

// throwInvalidSubpath(packageSubpath)

//

// To match "imports" and the spec.

if (StringPrototypeEndsWith(packageSubpath, '/')) {

emitTrailingSlashPatternDeprecation(packageSubpath, packageJSONUrl,

base);

}

const patternTrailer = StringPrototypeSlice(key, patternIndex + 1);

if (packageSubpath.length >= key.length &&

StringPrototypeEndsWith(packageSubpath, patternTrailer) &&

patternKeyCompare(bestMatch, key) === 1 &&

StringPrototypeLastIndexOf(key, '*') === patternIndex) {

bestMatch = key;

bestMatchSubpath = StringPrototypeSlice(

packageSubpath, patternIndex,

packageSubpath.length - patternTrailer.length);

}

}

}

if (bestMatch) {

const target = exports[bestMatch];

const resolveResult = resolvePackageTarget(

packageJSONUrl,

target,

bestMatchSubpath,

bestMatch,

base,

true,

false,

StringPrototypeEndsWith(packageSubpath, '/'),

conditions);

if (resolveResult == null) {

throw exportsNotFound(packageSubpath, packageJSONUrl, base);

}

return resolveResult;

}

throw exportsNotFound(packageSubpath, packageJSONUrl, base);

const aPatternIndex = StringPrototypeIndexOf(a, '*');

const bPatternIndex = StringPrototypeIndexOf(b, '*');

const baseLenA = aPatternIndex === -1 ? a.length : aPatternIndex + 1;

const baseLenB = bPatternIndex === -1 ? b.length : bPatternIndex + 1;

if (baseLenA > baseLenB) { return -1; }

if (baseLenB > baseLenA) { return 1; }

if (aPatternIndex === -1) { return 1; }

if (bPatternIndex === -1) { return -1; }

if (a.length > b.length) { return -1; }

if (b.length > a.length) { return 1; }

return 0;

if (name === '#' || StringPrototypeEndsWith(name, '/')) {

const reason = 'is not a valid internal imports specifier name';

throw new ERR_INVALID_MODULE_SPECIFIER(name, reason, fileURLToPath(base));

}

let packageJSONUrl;

const packageConfig = packageJsonReader.getPackageScopeConfig(base);

if (packageConfig.exists) {

packageJSONUrl = pathToFileURL(packageConfig.pjsonPath);

const imports = packageConfig.imports;

if (imports) {

if (ObjectPrototypeHasOwnProperty(imports, name) &&

!StringPrototypeIncludes(name, '*')) {

const resolveResult = resolvePackageTarget(

packageJSONUrl, imports[name], '', name, base, false, true, false,

conditions,

);

if (resolveResult != null) {

return resolveResult;

}

} else {

let bestMatch = '';

let bestMatchSubpath;

const keys = ObjectGetOwnPropertyNames(imports);

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

const key = keys[i];

const patternIndex = StringPrototypeIndexOf(key, '*');

if (patternIndex !== -1 &&

StringPrototypeStartsWith(name,

StringPrototypeSlice(key, 0,

patternIndex))) {

const patternTrailer = StringPrototypeSlice(key, patternIndex + 1);

if (name.length >= key.length &&

StringPrototypeEndsWith(name, patternTrailer) &&

patternKeyCompare(bestMatch, key) === 1 &&

StringPrototypeLastIndexOf(key, '*') === patternIndex) {

bestMatch = key;

bestMatchSubpath = StringPrototypeSlice(

name, patternIndex, name.length - patternTrailer.length);

}

}

}

if (bestMatch) {

const target = imports[bestMatch];

const resolveResult = resolvePackageTarget(packageJSONUrl, target,

bestMatchSubpath,

bestMatch, base, true,

true, false, conditions);

if (resolveResult != null) {

return resolveResult;

}

}

}

}

}

throw importNotDefined(name, packageJSONUrl, base);

// TODO(@anonrig): Move this to a C++ function.

if (BuiltinModule.canBeRequiredWithoutScheme(specifier)) {

return new URL('node:' + specifier);

}

let packageJSONUrl, packageJSONPath, packageSubpath;

if (hasPackageMap()) {

// Package map is enabled - use it exclusively

const parentPath = fileURLToPath(base);

const mapped = packageMapResolve(specifier, parentPath);

if (mapped === undefined) {

throw new ERR_MODULE_NOT_FOUND(specifier, fileURLToPath(base), null);

}

const { packagePath, subpath } = mapped;

packageJSONPath = join(packagePath, 'package.json');

packageJSONUrl = pathToFileURL(packageJSONPath);

packageSubpath = subpath;

} else {

// Standard node_modules resolution

({ packageJSONUrl, packageJSONPath, packageSubpath } =

packageJsonReader.getPackageJSONURL(specifier, base));

}

const packageConfig = packageJsonReader.read(packageJSONPath, {

__proto__: null, specifier, base, isESM: true,

});

if (packageConfig.exports != null) {

return packageExportsResolve(

packageJSONUrl, packageSubpath, packageConfig, base, conditions);

}

if (packageSubpath === '.') {

return legacyMainResolve(packageJSONUrl, packageConfig, base);

}

return new URL(packageSubpath, packageJSONUrl);

if (specifier[0] === '.') {

if (specifier.length === 1 || specifier[1] === '/') { return true; }

if (specifier[1] === '.') {

if (specifier.length === 2 || specifier[2] === '/') { return true; }

}

}

return false;

if (specifier === '') { return false; }

if (specifier[0] === '/') { return true; }

return isRelativeSpecifier(specifier);

const protocol = typeof base === 'string' ?

StringPrototypeSlice(base, 0, StringPrototypeIndexOf(base, ':') + 1) :

base.protocol;

const isData = protocol === 'data:';

// Order swapped from spec for minor perf gain.

// Ok since relative URLs cannot parse as URLs.

let resolved;

if (shouldBeTreatedAsRelativeOrAbsolutePath(specifier)) {

try {

resolved = new URL(specifier, base);

} catch (cause) {

const error = new ERR_UNSUPPORTED_RESOLVE_REQUEST(specifier, base);

setOwnProperty(error, 'cause', cause);

throw error;

}

} else if (protocol === 'file:' && specifier[0] === '#') {

resolved = packageImportsResolve(specifier, base, conditions);

} else {

const url = URLParse(specifier);

if (url !== null) {

resolved = url;

} else {

if (isData && !BuiltinModule.canBeRequiredWithoutScheme(specifier)) {

const error = new ERR_UNSUPPORTED_RESOLVE_REQUEST(specifier, base);

setOwnProperty(error, 'cause', new ERR_INVALID_URL(specifier));

throw error;

}

resolved = packageResolve(specifier, base, conditions);

}

}

if (resolved.protocol !== 'file:') {

return resolved;

}

return finalizeResolution(resolved, base, preserveSymlinks);

try {

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

const parent = fileURLToPath(parentURL);

const tmpModule = new CJSModule(parent, null);

tmpModule.paths = CJSModule._nodeModulePaths(parent);

let found = CJSModule._resolveFilename(specifier, tmpModule, false);

// If it is a relative specifier return the relative path

// to the parent

if (isRelativeSpecifier(specifier)) {

const foundURL = pathToFileURL(found).pathname;

found = relativePosixPath(

StringPrototypeSlice(parentURL, 'file://'.length, StringPrototypeLastIndexOf(parentURL, '/')),

foundURL);

// Add './' if the path does not start with '../'

// This should be a safe assumption because when loading

// esm modules there should be always a file specified so

// there should not be a specifier like '..' or '.'

if (!StringPrototypeStartsWith(found, '../')) {

found = `./${found}`;

}

} else if (isBareSpecifier(specifier)) {

// If it is a bare specifier return the relative path within the

// module

const i = StringPrototypeIndexOf(specifier, '/');

const pkg = i === -1 ? specifier : StringPrototypeSlice(specifier, 0, i);

const needle = `${sep}node_modules${sep}${pkg}${sep}`;

const index = StringPrototypeLastIndexOf(found, needle);

if (index !== -1) {

found = pkg + '/' + ArrayPrototypeJoin(

ArrayPrototypeMap(

StringPrototypeSplit(StringPrototypeSlice(found, index + needle.length), sep),

// Escape URL-special characters to avoid generating a incorrect suggestion

encodeURIComponent,

),

'/',

);

} else {

found = `${pathToFileURL(found)}`;

}

}

return found;

} catch {

return false;

}

if (parentURL === undefined) {

return; // Main entry point, so no parent

}

if (typeof parentURL !== 'string' && !isURL(parentURL)) {

throw new ERR_INVALID_ARG_TYPE('parentURL', ['string', 'URL'], parentURL);

}

let { parentURL, conditions } = context;

throwIfInvalidParentURL(parentURL);

let parsedParentURL;

if (parentURL) {

parsedParentURL = URLParse(parentURL);

}

let parsed, protocol;

if (shouldBeTreatedAsRelativeOrAbsolutePath(specifier)) {

parsed = URLParse(specifier, parsedParentURL);

} else {

parsed = URLParse(specifier);

}

if (parsed != null) {

// Avoid accessing the `protocol` property due to the lazy getters.

protocol = parsed.protocol;

if (protocol === 'data:') {

return { __proto__: null, url: parsed.href };

}

}

protocol ??= parsed?.protocol;

if (protocol === 'node:') { return { __proto__: null, url: specifier }; }

const isMain = parentURL === undefined;

if (isMain) {

parentURL = getCWDURL().href;

// This is the initial entry point to the program, and --input-type has

// been passed as an option; but --input-type can only be used with

// --eval, --print or STDIN string input. It is not allowed with file

// input, to avoid user confusion over how expansive the effect of the

// flag should be (i.e. entry point only, package scope surrounding the

// entry point, etc.).

if (getOptionValue('--input-type')) { throw new ERR_INPUT_TYPE_NOT_ALLOWED(); }

}

conditions = getConditionsSet(conditions);

let url;

try {

url = moduleResolve(

specifier,

parentURL,

conditions,

isMain ? getOptionValue('--preserve-symlinks-main') : getOptionValue('--preserve-symlinks'),

);

} catch (error) {

// Try to give the user a hint of what would have been the

// resolved CommonJS module

if (error.code === 'ERR_MODULE_NOT_FOUND' ||

error.code === 'ERR_UNSUPPORTED_DIR_IMPORT') {

if (StringPrototypeStartsWith(specifier, 'file://')) {

specifier = fileURLToPath(specifier);

}

decorateErrorWithCommonJSHints(error, specifier, parentURL);

}

throw error;

}

return {

__proto__: null,

// Do NOT cast `url` to a string: that will work even when there are real

// problems, silencing them

url: url.href,

format: defaultGetFormatWithoutErrors(url, context),

};