| Server IP : 167.235.224.122 / Your IP : 216.73.216.110 Web Server : Apache/2.4.58 (Ubuntu) System : Linux newplayground 6.8.0-136-generic #136-Ubuntu SMP PREEMPT_DYNAMIC Wed Jul 1 21:33:11 UTC 2026 aarch64 User : deploy ( 1000) PHP Version : 8.4.23 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : OFF Directory : /var/www/html/reef_analytics/node_modules/enhanced-resolve/lib/util/ |
Upload File : |
/*
MIT License http://www.opensource.org/licenses/mit-license.php
Author Ivan Kopeykin @vankop
*/
"use strict";
const { parseIdentifier } = require("./identifier");
/** @typedef {string | (string | ConditionalMapping)[]} DirectMapping */
/** @typedef {{ [k: string]: MappingValue }} ConditionalMapping */
/** @typedef {ConditionalMapping | DirectMapping | null} MappingValue */
/** @typedef {Record<string, MappingValue> | ConditionalMapping | DirectMapping} ExportsField */
/** @typedef {Record<string, MappingValue>} ImportsField */
/**
* Processing exports/imports field
* @callback FieldProcessor
* @param {string} request request
* @param {Set<string>} conditionNames condition names
* @returns {[string[], string | null]} resolved paths with used field
*/
/*
Example exports field:
{
".": "./main.js",
"./feature": {
"browser": "./feature-browser.js",
"default": "./feature.js"
}
}
Terminology:
Enhanced-resolve name keys ("." and "./feature") as exports field keys.
If value is string or string[], mapping is called as a direct mapping
and value called as a direct export.
If value is key-value object, mapping is called as a conditional mapping
and value called as a conditional export.
Key in conditional mapping is called condition name.
Conditional mapping nested in another conditional mapping is called nested mapping.
----------
Example imports field:
{
"#a": "./main.js",
"#moment": {
"browser": "./moment/index.js",
"default": "moment"
},
"#moment/": {
"browser": "./moment/",
"default": "moment/"
}
}
Terminology:
Enhanced-resolve name keys ("#a" and "#moment/", "#moment") as imports field keys.
If value is string or string[], mapping is called as a direct mapping
and value called as a direct export.
If value is key-value object, mapping is called as a conditional mapping
and value called as a conditional export.
Key in conditional mapping is called condition name.
Conditional mapping nested in another conditional mapping is called nested mapping.
*/
const slashCode = "/".charCodeAt(0);
const dotCode = ".".charCodeAt(0);
const hashCode = "#".charCodeAt(0);
const patternRegEx = /\*/g;
const DOLLAR_ESCAPE_RE = /\$/g;
/** @typedef {Record<string, MappingValue>} RecordMapping */
/**
* Cached `Object.keys()` for objects whose shape does not change after the
* first observation — i.e. parsed `package.json` fields and the nested
* conditional mappings inside them. `Object.keys` allocates a fresh array
* on every call; since `findMatch` / `conditionalMapping` run on every
* bare-specifier resolve, the allocation adds up quickly.
* @type {WeakMap<RecordMapping, string[]>}
*/
const _keysCache = new WeakMap();
/**
* @param {RecordMapping} obj object to read keys from
* @returns {string[]} cached keys array (DO NOT mutate)
*/
function cachedKeys(obj) {
let keys = _keysCache.get(obj);
if (keys === undefined) {
keys = Object.keys(obj);
_keysCache.set(obj, keys);
}
return keys;
}
/**
* Per-key precomputed info used by `findMatch`. Equivalent to what the
* previous implementation recomputed inline on every resolve.
* @typedef {object} FieldKeyInfo
* @property {string} key the original key
* @property {number} patternIndex position of the single "*" in the key, or -1 when absent
* @property {string} wildcardPrefix substring before "*" (empty when patternIndex === -1)
* @property {string} wildcardSuffix substring after "*" (empty when patternIndex === -1)
* @property {boolean} isLegacySubpath true when key is a legacy `./foo/`-style folder key with no "*"
* @property {boolean} isPattern true when key contains "*"
* @property {boolean} isSubpathMapping true when key ends with "/"
* @property {boolean} isValidPattern true when key has at most one "*"
*/
/**
* Cached per-field key metadata, keyed by the exports/imports field
* object. Computed lazily on first `findMatch` call and reused forever.
* Safe because `package.json` fields are immutable JSON values.
* @type {WeakMap<RecordMapping, FieldKeyInfo[]>}
*/
const _fieldKeyInfoCache = new WeakMap();
/**
* @param {ExportsField | ImportsField} field field object
* @returns {FieldKeyInfo[]} precomputed per-key info
*/
function getFieldKeyInfos(field) {
const fieldKey = /** @type {RecordMapping} */ (field);
let infos = _fieldKeyInfoCache.get(fieldKey);
if (infos !== undefined) return infos;
const keys = Object.getOwnPropertyNames(field);
infos = Array.from({ length: keys.length });
for (let i = 0; i < keys.length; i++) {
const key = keys[i];
const patternIndex = key.indexOf("*");
// `isValidPattern` is true when the key has at most one `*`. Searching
// from `patternIndex + 1` stops as soon as a second `*` is found, so
// we avoid the full-string scan that `lastIndexOf` would do — and the
// single-star common case finishes in one pass.
const isValidPattern =
patternIndex === -1 || !key.includes("*", patternIndex + 1);
const keyLen = key.length;
const endsWithSlash =
keyLen > 0 && key.charCodeAt(keyLen - 1) === slashCode;
infos[i] = {
key,
patternIndex,
wildcardPrefix: patternIndex === -1 ? "" : key.slice(0, patternIndex),
wildcardSuffix: patternIndex === -1 ? "" : key.slice(patternIndex + 1),
isLegacySubpath: patternIndex === -1 && endsWithSlash,
isPattern: patternIndex !== -1,
isSubpathMapping: endsWithSlash,
isValidPattern,
};
}
_fieldKeyInfoCache.set(fieldKey, infos);
return infos;
}
/**
* @param {string} a first string
* @param {string} b second string
* @returns {number} compare result
*/
function patternKeyCompare(a, b) {
const aPatternIndex = a.indexOf("*");
const bPatternIndex = b.indexOf("*");
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;
}
/** @typedef {[MappingValue, string, boolean, boolean, string] | null} MatchTuple */
/**
* Per-field memoization of `findMatch(request, field)`. For a given field
* the result depends only on the `request` string (it does NOT depend on
* `conditionNames` — that's applied separately by `conditionalMapping`),
* so we can cache the tuple keyed by request.
*
* Typical build traffic runs the same request through the resolver
* repeatedly (same import re-resolved from different source files, module
* graph traversals that revisit a package, etc.), and every one of those
* hits walks the same key list and allocates the same tuple. Caching the
* tuple turns the second-and-onward call into a single Map lookup.
*
* Keyed on the field object via a module-level `WeakMap`, so the cache
* is freed automatically when the owning description file is GC'd.
* @type {WeakMap<RecordMapping, Map<string, MatchTuple>>}
*/
const _findMatchCache = new WeakMap();
/**
* @param {string} request request
* @param {ExportsField | ImportsField} field exports or import field
* @returns {MatchTuple} match result (uncached)
*/
function computeFindMatch(request, field) {
const requestLen = request.length;
const requestEndsWithSlash =
requestLen > 0 && request.charCodeAt(requestLen - 1) === slashCode;
const requestHasStar = request.includes("*");
if (
!requestHasStar &&
!requestEndsWithSlash &&
Object.prototype.hasOwnProperty.call(field, request)
) {
const target = /** @type {{ [k: string]: MappingValue }} */ (field)[
request
];
return [target, "", false, false, request];
}
/** @type {string} */
let bestMatch = "";
/** @type {FieldKeyInfo | null} */
let bestMatchInfo = null;
/** @type {string | undefined} */
let bestMatchSubpath;
const infos = getFieldKeyInfos(field);
for (let i = 0; i < infos.length; i++) {
const info = infos[i];
const { key, patternIndex } = info;
if (patternIndex !== -1) {
if (
!info.isValidPattern ||
!request.startsWith(info.wildcardPrefix) ||
requestLen < key.length ||
!request.endsWith(info.wildcardSuffix) ||
patternKeyCompare(bestMatch, key) !== 1
) {
continue;
}
bestMatch = key;
bestMatchInfo = info;
bestMatchSubpath = request.slice(
patternIndex,
requestLen - info.wildcardSuffix.length,
);
} else if (
info.isLegacySubpath &&
request.startsWith(key) &&
patternKeyCompare(bestMatch, key) === 1
) {
bestMatch = key;
bestMatchInfo = info;
bestMatchSubpath = request.slice(key.length);
}
}
if (bestMatch === "") return null;
const target =
/** @type {{ [k: string]: MappingValue }} */
(field)[bestMatch];
return [
target,
/** @type {string} */ (bestMatchSubpath),
/** @type {FieldKeyInfo} */ (bestMatchInfo).isSubpathMapping,
/** @type {FieldKeyInfo} */ (bestMatchInfo).isPattern,
bestMatch,
];
}
/**
* Trying to match request to field
* @param {string} request request
* @param {ExportsField | ImportsField} field exports or import field
* @returns {MatchTuple} match or null, number is negative and one less when it's a folder mapping, number is request.length + 1 for direct mappings
*/
function findMatch(request, field) {
const fieldKey = /** @type {RecordMapping} */ (field);
let perRequest = _findMatchCache.get(fieldKey);
if (perRequest === undefined) {
perRequest = new Map();
_findMatchCache.set(fieldKey, perRequest);
} else {
// `computeFindMatch` only ever returns `MatchTuple | null` — never
// `undefined` — and `Map.set(k, null)` then `Map.get(k)` returns
// `null`, not `undefined`. So `get(...) === undefined` already
// unambiguously means "not cached yet"; one Map lookup is enough,
// no follow-up `has` needed to disambiguate "cached null".
const cached = perRequest.get(request);
if (cached !== undefined) return cached;
}
const result = computeFindMatch(request, field);
perRequest.set(request, result);
return result;
}
/**
* Sentinel stored in the conditional-mapping cache for inputs whose walk
* returns `null` ("no condition matched"). Using a non-null marker lets the
* cache-hit path be a single `WeakMap.get()` — we distinguish
* "cached null" from "not cached yet" without a second `has` call.
*/
const NULL_RESULT = Symbol("NULL_RESULT");
/**
* Memoization of `conditionalMapping(mapping, conditionNames)`. The result
* depends only on the mapping object (immutable — owned by a parsed
* `package.json`) and the `conditionNames` Set (owned by the resolver's
* options and stable for its lifetime), so it is safe to cache per (mapping,
* conditionNames) pair.
*
* A conditional `exports` entry that appears inside a `directMapping` array
* (the common `"browser": [...fallback list...]` shape, plus nested
* conditions) gets walked on every resolve that traverses the parent entry.
* Without this cache each of those walks re-reads `Object.keys` on the
* mapping and re-visits every condition until one matches, even though the
* inputs are identical.
*
* Outer key is the conditional mapping itself; inner key is the condition
* Set. Both are object references, so WeakMap-of-WeakMap lets both levels
* be collected automatically when the description file or resolver go away.
* @type {WeakMap<ConditionalMapping, WeakMap<Set<string>, DirectMapping | typeof NULL_RESULT>>}
*/
const _conditionalMappingCache = new WeakMap();
/**
* @param {ConditionalMapping} conditionalMapping_ conditional mapping
* @param {Set<string>} conditionNames condition names
* @returns {DirectMapping | null} direct mapping if found (uncached)
*/
function computeConditionalMapping(conditionalMapping_, conditionNames) {
/** @type {[ConditionalMapping, string[], number][]} */
const lookup = [[conditionalMapping_, cachedKeys(conditionalMapping_), 0]];
loop: while (lookup.length > 0) {
const top = lookup[lookup.length - 1];
const [mapping, conditions, j] = top;
for (let i = j; i < conditions.length; i++) {
const condition = conditions[i];
if (condition === "default" || conditionNames.has(condition)) {
const innerMapping = mapping[condition];
if (
innerMapping !== null &&
typeof innerMapping === "object" &&
!Array.isArray(innerMapping)
) {
const nested = /** @type {ConditionalMapping} */ (innerMapping);
top[2] = i + 1;
lookup.push([nested, cachedKeys(nested), 0]);
continue loop;
}
return /** @type {DirectMapping} */ (innerMapping);
}
}
lookup.pop();
}
return null;
}
/**
* @param {ConditionalMapping} conditionalMapping_ conditional mapping
* @param {Set<string>} conditionNames condition names
* @returns {DirectMapping | null} direct mapping if found
*/
function conditionalMapping(conditionalMapping_, conditionNames) {
let perSet = _conditionalMappingCache.get(conditionalMapping_);
if (perSet !== undefined) {
const cached = perSet.get(conditionNames);
if (cached !== undefined) {
return cached === NULL_RESULT
? null
: /** @type {DirectMapping} */ (cached);
}
} else {
perSet = new WeakMap();
_conditionalMappingCache.set(conditionalMapping_, perSet);
}
const result = computeConditionalMapping(conditionalMapping_, conditionNames);
perSet.set(conditionNames, result === null ? NULL_RESULT : result);
return result;
}
/**
* @param {string | undefined} remainingRequest remaining request when folder mapping, undefined for file mappings
* @param {boolean} isPattern true, if mapping is a pattern (contains "*")
* @param {boolean} isSubpathMapping true, for subpath mappings
* @param {string} mappingTarget direct export
* @param {(d: string, f: boolean) => void} assert asserting direct value
* @returns {string} mapping result
*/
function targetMapping(
remainingRequest,
isPattern,
isSubpathMapping,
mappingTarget,
assert,
) {
if (remainingRequest === undefined) {
assert(mappingTarget, false);
return mappingTarget;
}
if (isSubpathMapping) {
assert(mappingTarget, true);
return mappingTarget + remainingRequest;
}
assert(mappingTarget, false);
let result = mappingTarget;
if (isPattern) {
const escapedRemainder = remainingRequest.includes("$")
? remainingRequest.replace(DOLLAR_ESCAPE_RE, "$$")
: remainingRequest;
result = result.replace(patternRegEx, escapedRemainder);
}
return result;
}
/**
* @param {string | undefined} remainingRequest remaining request when folder mapping, undefined for file mappings
* @param {boolean} isPattern true, if mapping is a pattern (contains "*")
* @param {boolean} isSubpathMapping true, for subpath mappings
* @param {DirectMapping | null} mappingTarget direct export
* @param {Set<string>} conditionNames condition names
* @param {(d: string, f: boolean) => void} assert asserting direct value
* @returns {string[]} mapping result
*/
function directMapping(
remainingRequest,
isPattern,
isSubpathMapping,
mappingTarget,
conditionNames,
assert,
) {
if (mappingTarget === null) return [];
if (typeof mappingTarget === "string") {
return [
targetMapping(
remainingRequest,
isPattern,
isSubpathMapping,
mappingTarget,
assert,
),
];
}
/** @type {string[]} */
const targets = [];
for (let i = 0, len = mappingTarget.length; i < len; i++) {
const exp = mappingTarget[i];
if (typeof exp === "string") {
targets.push(
targetMapping(
remainingRequest,
isPattern,
isSubpathMapping,
exp,
assert,
),
);
continue;
}
const mapping = conditionalMapping(exp, conditionNames);
if (!mapping) continue;
const innerExports = directMapping(
remainingRequest,
isPattern,
isSubpathMapping,
mapping,
conditionNames,
assert,
);
for (let j = 0, innerLen = innerExports.length; j < innerLen; j++) {
targets.push(innerExports[j]);
}
}
return targets;
}
/** @type {[string[], null]} */
const EMPTY_NO_MATCH = /** @type {[string[], null]} */ ([[], null]);
/**
* @param {ExportsField | ImportsField} field root
* @param {(s: string) => string} normalizeRequest Normalize request, for `imports` field it adds `#`, for `exports` field it adds `.` or `./`
* @param {(s: string) => string} assertRequest assertRequest
* @param {(s: string, f: boolean) => void} assertTarget assertTarget
* @returns {FieldProcessor} field processor
*/
function createFieldProcessor(
field,
normalizeRequest,
assertRequest,
assertTarget,
) {
return function fieldProcessor(request, conditionNames) {
const match = findMatch(normalizeRequest(assertRequest(request)), field);
if (match === null) return EMPTY_NO_MATCH;
const [mapping, remainingRequest, isSubpathMapping, isPattern, usedField] =
match;
/** @type {DirectMapping | null} */
let direct;
if (
mapping !== null &&
typeof mapping === "object" &&
!Array.isArray(mapping)
) {
direct = conditionalMapping(
/** @type {ConditionalMapping} */ (mapping),
conditionNames,
);
if (direct === null) return EMPTY_NO_MATCH;
} else {
direct = /** @type {DirectMapping} */ (mapping);
}
return [
directMapping(
remainingRequest,
isPattern,
isSubpathMapping,
direct,
conditionNames,
assertTarget,
),
usedField,
];
};
}
/**
* @param {string} request request
* @returns {string} updated request
*/
function assertExportsFieldRequest(request) {
if (request.charCodeAt(0) !== dotCode) {
throw new Error('Request should be relative path and start with "."');
}
if (request.length === 1) return "";
if (request.charCodeAt(1) !== slashCode) {
throw new Error('Request should be relative path and start with "./"');
}
if (request.charCodeAt(request.length - 1) === slashCode) {
throw new Error("Only requesting file allowed");
}
return request.slice(2);
}
/**
* @param {ExportsField} field exports field
* @returns {ExportsField} normalized exports field
*/
function buildExportsField(field) {
// handle syntax sugar, if exports field is direct mapping for "."
if (typeof field === "string" || Array.isArray(field)) {
return { ".": field };
}
const keys = Object.keys(field);
for (let i = 0; i < keys.length; i++) {
const key = keys[i];
if (key.charCodeAt(0) !== dotCode) {
// handle syntax sugar, if exports field is conditional mapping for "."
if (i === 0) {
while (i < keys.length) {
const charCode = keys[i].charCodeAt(0);
if (charCode === dotCode || charCode === slashCode) {
throw new Error(
`Exports field key should be relative path and start with "." (key: ${JSON.stringify(
key,
)})`,
);
}
i++;
}
return { ".": field };
}
throw new Error(
`Exports field key should be relative path and start with "." (key: ${JSON.stringify(
key,
)})`,
);
}
if (key.length === 1) {
continue;
}
if (key.charCodeAt(1) !== slashCode) {
throw new Error(
`Exports field key should be relative path and start with "./" (key: ${JSON.stringify(
key,
)})`,
);
}
}
return field;
}
/**
* @param {string} exp export target
* @param {boolean} expectFolder is folder expected
*/
function assertExportTarget(exp, expectFolder) {
const parsedIdentifier = parseIdentifier(exp);
if (!parsedIdentifier) {
return;
}
const [relativePath] = parsedIdentifier;
const isFolder =
relativePath.charCodeAt(relativePath.length - 1) === slashCode;
if (isFolder !== expectFolder) {
throw new Error(
expectFolder
? `Expecting folder to folder mapping. ${JSON.stringify(
exp,
)} should end with "/"`
: `Expecting file to file mapping. ${JSON.stringify(
exp,
)} should not end with "/"`,
);
}
}
/**
* @param {ExportsField} exportsField the exports field
* @returns {FieldProcessor} process callback
*/
module.exports.processExportsField = function processExportsField(
exportsField,
) {
return createFieldProcessor(
buildExportsField(exportsField),
(request) => (request.length === 0 ? "." : `./${request}`),
assertExportsFieldRequest,
assertExportTarget,
);
};
/**
* @param {string} request request
* @returns {string} updated request
*/
function assertImportsFieldRequest(request) {
if (request.charCodeAt(0) !== hashCode) {
throw new Error('Request should start with "#"');
}
if (request.length === 1) {
throw new Error("Request should have at least 2 characters");
}
// Note: #/ patterns are now allowed per Node.js PR #60864
// https://github.com/nodejs/node/pull/60864
if (request.charCodeAt(request.length - 1) === slashCode) {
throw new Error("Only requesting file allowed");
}
return request.slice(1);
}
/**
* @param {string} imp import target
* @param {boolean} expectFolder is folder expected
*/
function assertImportTarget(imp, expectFolder) {
const parsedIdentifier = parseIdentifier(imp);
if (!parsedIdentifier) {
return;
}
const [relativePath] = parsedIdentifier;
const isFolder =
relativePath.charCodeAt(relativePath.length - 1) === slashCode;
if (isFolder !== expectFolder) {
throw new Error(
expectFolder
? `Expecting folder to folder mapping. ${JSON.stringify(
imp,
)} should end with "/"`
: `Expecting file to file mapping. ${JSON.stringify(
imp,
)} should not end with "/"`,
);
}
}
/**
* @param {ImportsField} importsField the exports field
* @returns {FieldProcessor} process callback
*/
module.exports.processImportsField = function processImportsField(
importsField,
) {
return createFieldProcessor(
importsField,
(request) => `#${request}`,
assertImportsFieldRequest,
assertImportTarget,
);
};