/*

MIT License http://www.opensource.org/licenses/mit-license.php

Author Tobias Koppers @sokra

*/

"use strict";

const nodeModule = require("module");

const { isAbsolute } = require("path");

const { create: createResolver } = require("enhanced-resolve");

const asyncLib = require("neo-async");

const { DEFAULTS } = require("./config/defaults");

const AsyncQueue = require("./util/AsyncQueue");

const StackedCacheMap = require("./util/StackedCacheMap");

const createHash = require("./util/createHash");

const { dirname, join, lstatReadlinkAbsolute, relative } = require("./util/fs");

const makeSerializable = require("./util/makeSerializable");

const memoize = require("./util/memoize");

const processAsyncTree = require("./util/processAsyncTree");

/** @typedef {import("enhanced-resolve").ResolveRequest} ResolveRequest */

/** @typedef {import("enhanced-resolve").ResolveFunctionAsync} ResolveFunctionAsync */

/** @typedef {import("../declarations/WebpackOptions").HashFunction} HashFunction */

/** @typedef {import("./logging/Logger").Logger} Logger */

/** @typedef {import("./errors/WebpackError")} WebpackError */

/** @typedef {import("./util/fs").JsonObject} JsonObject */

/** @typedef {import("./util/fs").IStats} IStats */

/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */

/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */

/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */

/**

* Defines the processor callback type used by this module.

* @template T

* @typedef {import("./util/AsyncQueue").Callback<T>} ProcessorCallback

*/

/**

* Defines the processor type used by this module.

* @template T, R

* @typedef {import("./util/AsyncQueue").Processor<T, R>} Processor

*/

const supportsEsm = Number(process.versions.modules) >= 83;

/** @type {Set<string>} */

const builtinModules = new Set(nodeModule.builtinModules);

let FS_ACCURACY = 2000;

/** @type {Set<string>} */

const EMPTY_SET = new Set();

const RBDT_RESOLVE_INITIAL = 0;

const RBDT_RESOLVE_FILE = 1;

const RBDT_RESOLVE_DIRECTORY = 2;

const RBDT_RESOLVE_CJS_FILE = 3;

const RBDT_RESOLVE_CJS_FILE_AS_CHILD = 4;

const RBDT_RESOLVE_ESM_FILE = 5;

const RBDT_DIRECTORY = 6;

const RBDT_FILE = 7;

const RBDT_DIRECTORY_DEPENDENCIES = 8;

const RBDT_FILE_DEPENDENCIES = 9;

/** @typedef {RBDT_RESOLVE_INITIAL | RBDT_RESOLVE_FILE | RBDT_RESOLVE_DIRECTORY | RBDT_RESOLVE_CJS_FILE | RBDT_RESOLVE_CJS_FILE_AS_CHILD | RBDT_RESOLVE_ESM_FILE | RBDT_DIRECTORY | RBDT_FILE | RBDT_DIRECTORY_DEPENDENCIES | RBDT_FILE_DEPENDENCIES} JobType */

const INVALID = Symbol("invalid");

// eslint-disable-next-line jsdoc/ts-no-empty-object-type

/** @typedef {{ }} ExistenceOnlyTimeEntry */

/**

* Defines the file system info entry type used by this module.

* @typedef {object} FileSystemInfoEntry

* @property {number} safeTime

* @property {number=} timestamp

*/

/**

* Defines the resolved context file system info entry type used by this module.

* @typedef {object} ResolvedContextFileSystemInfoEntry

* @property {number} safeTime

* @property {string=} timestampHash

*/

/** @typedef {Set<string>} Symlinks */

/**

* Defines the context file system info entry type used by this module.

* @typedef {object} ContextFileSystemInfoEntry

* @property {number} safeTime

* @property {string=} timestampHash

* @property {ResolvedContextFileSystemInfoEntry=} resolved

* @property {Symlinks=} symlinks

*/

/**

* Defines the timestamp and hash type used by this module.

* @typedef {object} TimestampAndHash

* @property {number} safeTime

* @property {number=} timestamp

* @property {string} hash

*/

/**

* Defines the resolved context timestamp and hash type used by this module.

* @typedef {object} ResolvedContextTimestampAndHash

* @property {number} safeTime

* @property {string=} timestampHash

* @property {string} hash

*/

/**

* Defines the context timestamp and hash type used by this module.

* @typedef {object} ContextTimestampAndHash

* @property {number} safeTime

* @property {string=} timestampHash

* @property {string} hash

* @property {ResolvedContextTimestampAndHash=} resolved

* @property {Symlinks=} symlinks

*/

/**

* Defines the context hash type used by this module.

* @typedef {object} ContextHash

* @property {string} hash

* @property {string=} resolved

* @property {Symlinks=} symlinks

*/

/** @typedef {Set<string>} SnapshotContent */

/**

* Defines the snapshot optimization entry type used by this module.

* @typedef {object} SnapshotOptimizationEntry

* @property {Snapshot} snapshot

* @property {number} shared

* @property {SnapshotContent | undefined} snapshotContent

* @property {Set<SnapshotOptimizationEntry> | undefined} children

*/

/** @typedef {Map<string, string | false | undefined>} ResolveResults */

/** @typedef {Set<string>} Files */

/** @typedef {Set<string>} Directories */

/** @typedef {Set<string>} Missing */

/**

* Defines the resolve dependencies type used by this module.

* @typedef {object} ResolveDependencies

* @property {Files} files list of files

* @property {Directories} directories list of directories

* @property {Missing} missing list of missing entries

*/

/**

* Defines the resolve build dependencies result type used by this module.

* @typedef {object} ResolveBuildDependenciesResult

* @property {Files} files list of files

* @property {Directories} directories list of directories

* @property {Missing} missing list of missing entries

* @property {ResolveResults} resolveResults stored resolve results

* @property {ResolveDependencies} resolveDependencies dependencies of the resolving

*/

/**

* Defines the snapshot options type used by this module.

* @typedef {object} SnapshotOptions

* @property {boolean=} hash should use hash to snapshot

* @property {boolean=} timestamp should use timestamp to snapshot

*/

const DONE_ITERATOR_RESULT = new Set().keys().next();

// cspell:word tshs

// Tsh = Timestamp + Hash

// Tshs = Timestamp + Hash combinations

class SnapshotIterator {

/**

* Creates an instance of SnapshotIterator.

* @param {() => IteratorResult<string>} next next

*/

constructor(next) {

this.next = next;

}

}

/**

* Defines the get maps function type used by this module.

* @template T

* @typedef {(snapshot: Snapshot) => T[]} GetMapsFunction

*/

/**

* Represents SnapshotIterable.

* @template T

*/

class SnapshotIterable {

/**

* Creates an instance of SnapshotIterable.

* @param {Snapshot} snapshot snapshot

* @param {GetMapsFunction<T>} getMaps get maps function

*/

constructor(snapshot, getMaps) {

/** @type {Snapshot} */

this.snapshot = snapshot;

/** @type {GetMapsFunction<T>} */

this.getMaps = getMaps;

}

[Symbol.iterator]() {

let state = 0;

/** @type {IterableIterator<string>} */

let it;

/** @type {GetMapsFunction<T>} */

let getMaps;

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

let maps;

/** @type {Snapshot} */

let snapshot;

/** @type {Snapshot[] | undefined} */

let queue;

return new SnapshotIterator(() => {

for (;;) {

switch (state) {

case 0:

snapshot = this.snapshot;

getMaps = this.getMaps;

maps = getMaps(snapshot);

state = 1;

/* falls through */

case 1:

if (maps.length > 0) {

const map = maps.pop();

if (map !== undefined) {

it =

/** @type {Set<string> | Map<string, EXPECTED_ANY>} */

(map).keys();

state = 2;

} else {

break;

}

} else {

state = 3;

break;

}

/* falls through */

case 2: {

const result = it.next();

if (!result.done) return result;

state = 1;

break;

}

case 3: {

const children = snapshot.children;

if (children !== undefined) {

if (children.size === 1) {

// shortcut for a single child

// avoids allocation of queue

for (const child of children) snapshot = child;

maps = getMaps(snapshot);

state = 1;

break;

}

if (queue === undefined) queue = [];

for (const child of children) {

queue.push(child);

}

}

if (queue !== undefined && queue.length > 0) {

snapshot = /** @type {Snapshot} */ (queue.pop());

maps = getMaps(snapshot);

state = 1;

break;

} else {

state = 4;

}

}

/* falls through */

case 4:

return DONE_ITERATOR_RESULT;

}

}

});

}

}

/** @typedef {Map<string, FileSystemInfoEntry | null>} FileTimestamps */

/** @typedef {Map<string, string | null>} FileHashes */

/** @typedef {Map<string, TimestampAndHash | string | null>} FileTshs */

/** @typedef {Map<string, ResolvedContextFileSystemInfoEntry | null>} ContextTimestamps */

/** @typedef {Map<string, string | null>} ContextHashes */

/** @typedef {Map<string, ResolvedContextTimestampAndHash | null>} ContextTshs */

/** @typedef {Map<string, boolean>} MissingExistence */

/** @typedef {Map<string, string>} ManagedItemInfo */

/** @typedef {Set<string>} ManagedFiles */

/** @typedef {Set<string>} ManagedContexts */

/** @typedef {Set<string>} ManagedMissing */

/** @typedef {Set<Snapshot>} Children */

class Snapshot {

constructor() {

/** @type {number} */

this._flags = 0;

/** @type {Iterable<string> | undefined} */

this._cachedFileIterable = undefined;

/** @type {Iterable<string> | undefined} */

this._cachedContextIterable = undefined;

/** @type {Iterable<string> | undefined} */

this._cachedMissingIterable = undefined;

/** @type {number | undefined} */

this.startTime = undefined;

/** @type {FileTimestamps | undefined} */

this.fileTimestamps = undefined;

/** @type {FileHashes | undefined} */

this.fileHashes = undefined;

/** @type {FileTshs | undefined} */

this.fileTshs = undefined;

/** @type {ContextTimestamps | undefined} */

this.contextTimestamps = undefined;

/** @type {ContextHashes | undefined} */

this.contextHashes = undefined;

/** @type {ContextTshs | undefined} */

this.contextTshs = undefined;

/** @type {MissingExistence | undefined} */

this.missingExistence = undefined;

/** @type {ManagedItemInfo | undefined} */

this.managedItemInfo = undefined;

/** @type {ManagedFiles | undefined} */

this.managedFiles = undefined;

/** @type {ManagedContexts | undefined} */

this.managedContexts = undefined;

/** @type {ManagedMissing | undefined} */

this.managedMissing = undefined;

/** @type {Children | undefined} */

this.children = undefined;

}

hasStartTime() {

return (this._flags & 1) !== 0;

}

/**

* Updates start time using the provided value.

* @param {number} value start value

*/

setStartTime(value) {

this._flags |= 1;

this.startTime = value;

}

/**

* Sets merged start time.

* @param {number | undefined} value value

* @param {Snapshot} snapshot snapshot

*/

setMergedStartTime(value, snapshot) {

if (value) {

if (snapshot.hasStartTime()) {

this.setStartTime(

Math.min(

value,

/** @type {NonNullable<Snapshot["startTime"]>} */

(snapshot.startTime)

)

);

} else {

this.setStartTime(value);

}

} else if (snapshot.hasStartTime()) {

this.setStartTime(

/** @type {NonNullable<Snapshot["startTime"]>} */

(snapshot.startTime)

);

}

}

hasFileTimestamps() {

return (this._flags & 2) !== 0;

}

/**

* Sets file timestamps.

* @param {FileTimestamps} value file timestamps

*/

setFileTimestamps(value) {

this._flags |= 2;

this.fileTimestamps = value;

}

hasFileHashes() {

return (this._flags & 4) !== 0;

}

/**

* Updates file hashes using the provided value.

* @param {FileHashes} value file hashes

*/

setFileHashes(value) {

this._flags |= 4;

this.fileHashes = value;

}

hasFileTshs() {

return (this._flags & 8) !== 0;

}

/**

* Updates file tshs using the provided value.

* @param {FileTshs} value file tshs

*/

setFileTshs(value) {

this._flags |= 8;

this.fileTshs = value;

}

hasContextTimestamps() {

return (this._flags & 0x10) !== 0;

}

/**

* Sets context timestamps.

* @param {ContextTimestamps} value context timestamps

*/

setContextTimestamps(value) {

this._flags |= 0x10;

this.contextTimestamps = value;

}

hasContextHashes() {

return (this._flags & 0x20) !== 0;

}

/**

* Sets context hashes.

* @param {ContextHashes} value context hashes

*/

setContextHashes(value) {

this._flags |= 0x20;

this.contextHashes = value;

}

hasContextTshs() {

return (this._flags & 0x40) !== 0;

}

/**

* Updates context tshs using the provided value.

* @param {ContextTshs} value context tshs

*/

setContextTshs(value) {

this._flags |= 0x40;

this.contextTshs = value;

}

hasMissingExistence() {

return (this._flags & 0x80) !== 0;

}

/**

* Sets missing existence.

* @param {MissingExistence} value context tshs

*/

setMissingExistence(value) {

this._flags |= 0x80;

this.missingExistence = value;

}

hasManagedItemInfo() {

return (this._flags & 0x100) !== 0;

}

/**

* Sets managed item info.

* @param {ManagedItemInfo} value managed item info

*/

setManagedItemInfo(value) {

this._flags |= 0x100;

this.managedItemInfo = value;

}

hasManagedFiles() {

return (this._flags & 0x200) !== 0;

}

/**

* Sets managed files.

* @param {ManagedFiles} value managed files

*/

setManagedFiles(value) {

this._flags |= 0x200;

this.managedFiles = value;

}

hasManagedContexts() {

return (this._flags & 0x400) !== 0;

}

/**

* Sets managed contexts.

* @param {ManagedContexts} value managed contexts

*/

setManagedContexts(value) {

this._flags |= 0x400;

this.managedContexts = value;

}

hasManagedMissing() {

return (this._flags & 0x800) !== 0;

}

/**

* Sets managed missing.

* @param {ManagedMissing} value managed missing

*/

setManagedMissing(value) {

this._flags |= 0x800;

this.managedMissing = value;

}

hasChildren() {

return (this._flags & 0x1000) !== 0;

}

/**

* Updates children using the provided value.

* @param {Children} value children

*/

setChildren(value) {

this._flags |= 0x1000;

this.children = value;

}

/**

* Adds the provided child to the snapshot.

* @param {Snapshot} child children

*/

addChild(child) {

if (!this.hasChildren()) {

this.setChildren(new Set());

}

/** @type {Children} */

(this.children).add(child);

}

/**

* Serializes this instance into the provided serializer context.

* @param {ObjectSerializerContext} context context

*/

serialize({ write }) {

write(this._flags);

if (this.hasStartTime()) write(this.startTime);

if (this.hasFileTimestamps()) write(this.fileTimestamps);

if (this.hasFileHashes()) write(this.fileHashes);

if (this.hasFileTshs()) write(this.fileTshs);

if (this.hasContextTimestamps()) write(this.contextTimestamps);

if (this.hasContextHashes()) write(this.contextHashes);

if (this.hasContextTshs()) write(this.contextTshs);

if (this.hasMissingExistence()) write(this.missingExistence);

if (this.hasManagedItemInfo()) write(this.managedItemInfo);

if (this.hasManagedFiles()) write(this.managedFiles);

if (this.hasManagedContexts()) write(this.managedContexts);

if (this.hasManagedMissing()) write(this.managedMissing);

if (this.hasChildren()) write(this.children);

}

/**

* Restores this instance from the provided deserializer context.

* @param {ObjectDeserializerContext} context context

*/

deserialize({ read }) {

this._flags = read();

if (this.hasStartTime()) this.startTime = read();

if (this.hasFileTimestamps()) this.fileTimestamps = read();

if (this.hasFileHashes()) this.fileHashes = read();

if (this.hasFileTshs()) this.fileTshs = read();

if (this.hasContextTimestamps()) this.contextTimestamps = read();

if (this.hasContextHashes()) this.contextHashes = read();

if (this.hasContextTshs()) this.contextTshs = read();

if (this.hasMissingExistence()) this.missingExistence = read();

if (this.hasManagedItemInfo()) this.managedItemInfo = read();

if (this.hasManagedFiles()) this.managedFiles = read();

if (this.hasManagedContexts()) this.managedContexts = read();

if (this.hasManagedMissing()) this.managedMissing = read();

if (this.hasChildren()) this.children = read();

}

/**

* Creates an iterable from the provided get map.

* @template T

* @param {GetMapsFunction<T>} getMaps first

* @returns {SnapshotIterable<T>} iterable

*/

_createIterable(getMaps) {

return new SnapshotIterable(this, getMaps);

}

/**

* Gets file iterable.

* @returns {Iterable<string>} iterable

*/

getFileIterable() {

if (this._cachedFileIterable === undefined) {

this._cachedFileIterable = this._createIterable((s) => [

s.fileTimestamps,

s.fileHashes,

s.fileTshs,

s.managedFiles

]);

}

return this._cachedFileIterable;

}

/**

* Gets context iterable.

* @returns {Iterable<string>} iterable

*/

getContextIterable() {

if (this._cachedContextIterable === undefined) {

this._cachedContextIterable = this._createIterable((s) => [

s.contextTimestamps,

s.contextHashes,

s.contextTshs,

s.managedContexts

]);

}

return this._cachedContextIterable;

}

/**

* Gets missing iterable.

* @returns {Iterable<string>} iterable

*/

getMissingIterable() {

if (this._cachedMissingIterable === undefined) {

this._cachedMissingIterable = this._createIterable((s) => [

s.missingExistence,

s.managedMissing

]);

}

return this._cachedMissingIterable;

}

}

makeSerializable(Snapshot, "webpack/lib/FileSystemInfo", "Snapshot");

const MIN_COMMON_SNAPSHOT_SIZE = 3;

/**

* Defines the snapshot optimization value type used by this module.

* @template U, T

* @typedef {U extends true ? Set<string> : Map<string, T>} SnapshotOptimizationValue

*/

/**

* Represents SnapshotOptimization.

* @template T

* @template {boolean} [U=false]

*/

class SnapshotOptimization {

/**

* Creates an instance of SnapshotOptimization.

* @param {(snapshot: Snapshot) => boolean} has has value

* @param {(snapshot: Snapshot) => SnapshotOptimizationValue<U, T> | undefined} get get value

* @param {(snapshot: Snapshot, value: SnapshotOptimizationValue<U, T>) => void} set set value

* @param {boolean=} useStartTime use the start time of snapshots

* @param {U=} isSet value is an Set instead of a Map

*/

constructor(

has,

get,

set,

useStartTime = true,

isSet = /** @type {U} */ (false)

) {

this._has = has;

this._get = get;

this._set = set;

/** @type {boolean} */

this._useStartTime = useStartTime;

/** @type {U} */

this._isSet = isSet;

/** @type {Map<string, SnapshotOptimizationEntry>} */

this._map = new Map();

/** @type {number} */

this._statItemsShared = 0;

/** @type {number} */

this._statItemsUnshared = 0;

/** @type {number} */

this._statSharedSnapshots = 0;

/** @type {number} */

this._statReusedSharedSnapshots = 0;

}

getStatisticMessage() {

const total = this._statItemsShared + this._statItemsUnshared;

if (total === 0) return;

return `${

this._statItemsShared && Math.round((this._statItemsShared * 100) / total)

}% (${this._statItemsShared}/${total}) entries shared via ${

this._statSharedSnapshots

} shared snapshots (${

this._statReusedSharedSnapshots + this._statSharedSnapshots

} times referenced)`;

}

clear() {

this._map.clear();

this._statItemsShared = 0;

this._statItemsUnshared = 0;

this._statSharedSnapshots = 0;

this._statReusedSharedSnapshots = 0;

}

/**

* Processes the provided new snapshot.

* @param {Snapshot} newSnapshot snapshot

* @param {Set<string>} capturedFiles files to snapshot/share

* @returns {void}

*/

optimize(newSnapshot, capturedFiles) {

if (capturedFiles.size === 0) {

return;

}

/**

* Increase shared and store optimization entry.

* @param {SnapshotOptimizationEntry} entry optimization entry

* @returns {void}

*/

const increaseSharedAndStoreOptimizationEntry = (entry) => {

if (entry.children !== undefined) {

for (const child of entry.children) {

increaseSharedAndStoreOptimizationEntry(child);

}

}

entry.shared++;

storeOptimizationEntry(entry);

};

/**

* Stores optimization entry.

* @param {SnapshotOptimizationEntry} entry optimization entry

* @returns {void}

*/

const storeOptimizationEntry = (entry) => {

for (const path of /** @type {SnapshotContent} */ (

entry.snapshotContent

)) {

const old =

/** @type {SnapshotOptimizationEntry} */

(this._map.get(path));

if (old.shared < entry.shared) {

this._map.set(path, entry);

}

capturedFiles.delete(path);

}

};

/** @type {SnapshotOptimizationEntry | undefined} */

let newOptimizationEntry;

const capturedFilesSize = capturedFiles.size;

/** @type {Set<SnapshotOptimizationEntry> | undefined} */

const optimizationEntries = new Set();

for (const path of capturedFiles) {

const optimizationEntry = this._map.get(path);

if (optimizationEntry === undefined) {

if (newOptimizationEntry === undefined) {

newOptimizationEntry = {

snapshot: newSnapshot,

shared: 0,

snapshotContent: undefined,

children: undefined

};

}

this._map.set(path, newOptimizationEntry);

} else {

optimizationEntries.add(optimizationEntry);

}

}

optimizationEntriesLabel: for (const optimizationEntry of optimizationEntries) {

const snapshot = optimizationEntry.snapshot;

if (optimizationEntry.shared > 0) {

// It's a shared snapshot

// We can't change it, so we can only use it when all files match

// and startTime is compatible

if (

this._useStartTime &&

newSnapshot.startTime &&

(!snapshot.startTime || snapshot.startTime > newSnapshot.startTime)

) {

continue;

}

/** @type {Set<string>} */

const nonSharedFiles = new Set();

const snapshotContent =

/** @type {NonNullable<SnapshotOptimizationEntry["snapshotContent"]>} */

(optimizationEntry.snapshotContent);

const snapshotEntries =

/** @type {SnapshotOptimizationValue<U, T>} */

(this._get(snapshot));

for (const path of snapshotContent) {

if (!capturedFiles.has(path)) {

if (!snapshotEntries.has(path)) {

// File is not shared and can't be removed from the snapshot

// because it's in a child of the snapshot

continue optimizationEntriesLabel;

}

nonSharedFiles.add(path);

}

}

if (nonSharedFiles.size === 0) {

// The complete snapshot is shared

// add it as child

newSnapshot.addChild(snapshot);

increaseSharedAndStoreOptimizationEntry(optimizationEntry);

this._statReusedSharedSnapshots++;

} else {

// Only a part of the snapshot is shared

const sharedCount = snapshotContent.size - nonSharedFiles.size;

if (sharedCount < MIN_COMMON_SNAPSHOT_SIZE) {

// Common part it too small

continue;

}

// Extract common timestamps from both snapshots

/** @type {Set<string> | Map<string, T>} */

let commonMap;

if (this._isSet) {

commonMap = new Set();

for (const path of /** @type {Set<string>} */ (snapshotEntries)) {

if (nonSharedFiles.has(path)) continue;

commonMap.add(path);

snapshotEntries.delete(path);

}

} else {

commonMap = new Map();

const map = /** @type {Map<string, T>} */ (snapshotEntries);

for (const [path, value] of map) {

if (nonSharedFiles.has(path)) continue;

commonMap.set(path, value);

snapshotEntries.delete(path);

}

}

// Create and attach snapshot

const commonSnapshot = new Snapshot();

if (this._useStartTime) {

commonSnapshot.setMergedStartTime(newSnapshot.startTime, snapshot);

}

this._set(

commonSnapshot,

/** @type {SnapshotOptimizationValue<U, T>} */ (commonMap)

);

newSnapshot.addChild(commonSnapshot);

snapshot.addChild(commonSnapshot);

// Create optimization entry

const newEntry = {

snapshot: commonSnapshot,

shared: optimizationEntry.shared + 1,

snapshotContent: new Set(commonMap.keys()),

children: undefined

};

if (optimizationEntry.children === undefined) {

optimizationEntry.children = new Set();

}

optimizationEntry.children.add(newEntry);

storeOptimizationEntry(newEntry);

this._statSharedSnapshots++;

}

} else {

// It's a unshared snapshot

// We can extract a common shared snapshot

// with all common files

const snapshotEntries = this._get(snapshot);

if (snapshotEntries === undefined) {

// Incomplete snapshot, that can't be used

continue;

}

/** @type {Set<string> | Map<string, T>} */

let commonMap;

if (this._isSet) {

commonMap = new Set();

const set = /** @type {Set<string>} */ (snapshotEntries);

if (capturedFiles.size < set.size) {

for (const path of capturedFiles) {

if (set.has(path)) commonMap.add(path);

}

} else {

for (const path of set) {

if (capturedFiles.has(path)) commonMap.add(path);

}

}

} else {

commonMap = new Map();

const map = /** @type {Map<string, T>} */ (snapshotEntries);

for (const path of capturedFiles) {

const ts = map.get(path);

if (ts === undefined) continue;

commonMap.set(path, ts);

}

}

if (commonMap.size < MIN_COMMON_SNAPSHOT_SIZE) {

// Common part it too small

continue;

}

// Create and attach snapshot

const commonSnapshot = new Snapshot();

if (this._useStartTime) {

commonSnapshot.setMergedStartTime(newSnapshot.startTime, snapshot);

}

this._set(

commonSnapshot,

/** @type {SnapshotOptimizationValue<U, T>} */

(commonMap)

);

newSnapshot.addChild(commonSnapshot);

snapshot.addChild(commonSnapshot);

// Remove files from snapshot

for (const path of commonMap.keys()) snapshotEntries.delete(path);

const sharedCount = commonMap.size;

this._statItemsUnshared -= sharedCount;

this._statItemsShared += sharedCount;

// Create optimization entry

storeOptimizationEntry({

snapshot: commonSnapshot,

shared: 2,

snapshotContent: new Set(commonMap.keys()),

children: undefined

});

this._statSharedSnapshots++;

}

}

const unshared = capturedFiles.size;

this._statItemsUnshared += unshared;

this._statItemsShared += capturedFilesSize - unshared;

}

}

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

const ESCAPES = {

n: "\n",

r: "\r",

t: "\t",

b: "\b",

f: "\f",

v: "\v"

};

/**

* Cooks a JS string/template literal specifier into its evaluated value,

* matching ECMAScript escape semantics (sloppy-mode for string literals).

* @param {string} str input including the surrounding quotes

* @returns {string | null} result, or null when not a quoted literal

* @throws {Error} on a malformed escape sequence, like the JS parser would

*/

const parseString = (str) => {

const q = str[0];

if (q !== '"' && q !== "'" && q !== "`") {

return null;

}

const template = q === "`";

const inner = str.slice(1, -1);

const len = inner.length;

let result = "";

let i = 0;

while (i < len) {

const ch = inner[i];

if (ch !== "\\") {

// Template value normalizes raw <CR> and <CRLF> to <LF>

if (template && ch === "\r") {

result += "\n";

i += inner[i + 1] === "\n" ? 2 : 1;

} else {

result += ch;

i++;

}

continue;

}

i++;

if (i >= len) throw new Error("Unterminated escape sequence");

const esc = inner[i];

if (esc === "x") {

const hex = inner.slice(i + 1, i + 3);

if (!/^[0-9a-fA-F]{2}$/.test(hex)) {

throw new Error("Invalid hexadecimal escape sequence");

}

result += String.fromCharCode(Number.parseInt(hex, 16));

i += 3;

} else if (esc === "u") {

if (inner[i + 1] === "{") {

// \u{N...}

const closeIdx = inner.indexOf("}", i + 2);

const codeStr = closeIdx === -1 ? "" : inner.slice(i + 2, closeIdx);

const code = Number.parseInt(codeStr, 16);