/*

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

Author Tobias Koppers @sokra

*/

"use strict";

const querystring = require("querystring");

const { getContext, runLoaders } = require("loader-runner");

const {

AsyncSeriesBailHook,

HookMap,

SyncHook,

SyncWaterfallHook

} = require("tapable");

const {

CachedSource,

OriginalSource,

RawSource,

SourceMapSource

} = require("webpack-sources");

const Compilation = require("./Compilation");

const Module = require("./Module");

const ModuleGraphConnection = require("./ModuleGraphConnection");

const { JAVASCRIPT_MODULE_TYPE_AUTO } = require("./ModuleTypeConstants");

const RuntimeGlobals = require("./RuntimeGlobals");

const HookWebpackError = require("./errors/HookWebpackError");

const ModuleBuildError = require("./errors/ModuleBuildError");

const ModuleError = require("./errors/ModuleError");

const ModuleParseError = require("./errors/ModuleParseError");

const ModuleWarning = require("./errors/ModuleWarning");

const NonErrorEmittedError = require("./errors/NonErrorEmittedError");

const UnhandledSchemeError = require("./errors/UnhandledSchemeError");

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

const { isSubset } = require("./util/SetHelpers");

const { getScheme } = require("./util/URLAbsoluteSpecifier");

const {

compareLocations,

compareSelect,

concatComparators,

keepOriginalOrder,

sortWithSourceOrder

} = require("./util/comparators");

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

const { createFakeHook } = require("./util/deprecation");

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

const { join } = require("./util/fs");

const {

absolutify,

contextify,

makePathsRelative

} = require("./util/identifier");

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

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

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

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

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

/** @typedef {import("webpack-sources").Source} Source */

/** @typedef {import("webpack-sources").RawSourceMap} RawSourceMap */

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

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

/** @typedef {import("./config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */

/** @typedef {import("./Dependency")} Dependency */

/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */

/** @typedef {import("./Generator")} Generator */

/** @typedef {import("./Generator").GenerateErrorFn} GenerateErrorFn */

/** @typedef {import("./Module").BuildInfo} BuildInfo */

/** @typedef {import("./Module").FileSystemDependencies} FileSystemDependencies */

/** @typedef {import("./Module").BuildMeta} BuildMeta */

/** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */

/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */

/** @typedef {import("./Module").CodeGenerationResultData} CodeGenerationResultData */

/** @typedef {import("./Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */

/** @typedef {import("./Module").KnownBuildInfo} KnownBuildInfo */

/** @typedef {import("./Module").LibIdentOptions} LibIdentOptions */

/** @typedef {import("./Module").LibIdent} LibIdent */

/** @typedef {import("./Module").NameForCondition} NameForCondition */

/** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */

/** @typedef {import("./Module").NeedBuildCallback} NeedBuildCallback */

/** @typedef {import("./Module").BuildCallback} BuildCallback */

/** @typedef {import("./Module").RuntimeRequirements} RuntimeRequirements */

/** @typedef {import("./Module").Sources} Sources */

/** @typedef {import("./Module").SourceType} SourceType */

/** @typedef {import("./Module").SourceTypes} SourceTypes */

/** @typedef {import("./Module").UnsafeCacheData} UnsafeCacheData */

/** @typedef {import("./ModuleGraph")} ModuleGraph */

/** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */

/** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */

/** @typedef {import("./NormalModuleFactory").NormalModuleTypes} NormalModuleTypes */

/** @typedef {import("./NormalModuleFactory").ParserByType} ParserByType */

/** @typedef {import("./NormalModuleFactory").ParserOptionsByType} ParserOptionsByType */

/** @typedef {import("./NormalModuleFactory").GeneratorByType} GeneratorByType */

/** @typedef {import("./NormalModuleFactory").GeneratorOptionsByType} GeneratorOptionsByType */

/** @typedef {import("./NormalModuleFactory").ResourceSchemeData} ResourceSchemeData */

/** @typedef {import("./Parser")} Parser */

/** @typedef {import("./Parser").PreparsedAst} PreparsedAst */

/** @typedef {import("./RequestShortener")} RequestShortener */

/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */

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

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

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

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

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

/** @typedef {import("./util/identifier").AssociatedObjectForCache} AssociatedObjectForCache */

/**

* @template T

* @typedef {import("./util/deprecation").FakeHook<T>} FakeHook

*/

/** @typedef {{ [k: string]: EXPECTED_ANY }} ParserOptions */

/** @typedef {{ [k: string]: EXPECTED_ANY }} GeneratorOptions */

/**

* @template T

* @typedef {import("../declarations/LoaderContext").LoaderContext<T>} LoaderContext

*/

/**

* @template T

* @typedef {import("../declarations/LoaderContext").NormalModuleLoaderContext<T>} NormalModuleLoaderContext

*/

/** @typedef {(content: string) => boolean} NoParseFn */

const getInvalidDependenciesModuleWarning = memoize(() =>

require("./errors/InvalidDependenciesModuleWarning")

);

const getExtractSourceMap = memoize(() => require("./util/extractSourceMap"));

const getValidate = memoize(() => require("schema-utils").validate);

const getHarmonyImportSideEffectDependency = memoize(() =>

require("./dependencies/HarmonyImportSideEffectDependency")

);

/**

* @param {NormalModule} mod the module

* @param {ModuleGraph} moduleGraph the module graph

* @param {Dependency} dep the dep that triggered the bailout

*/

const recordSideEffectsBailout = (mod, moduleGraph, dep) => {

if (mod._addedSideEffectsBailout === undefined) {

mod._addedSideEffectsBailout = new WeakSet();

} else if (mod._addedSideEffectsBailout.has(moduleGraph)) {

return;

}

mod._addedSideEffectsBailout.add(moduleGraph);

moduleGraph

.getOptimizationBailout(mod)

.push(

() =>

`Dependency (${dep.type}) with side effects at ${formatLocation(dep.loc)}`

);

};

// Maximum recursive descent depth before switching to the iterative walker.

// #20986 reported overflow around 1300 modules in webpack 5.107.0 where each

// step consumed two stack frames (`NormalModule.getSideEffectsConnectionState`

// plus `HarmonyImportSideEffectDependency.getModuleEvaluationSideEffectsState`).

// `walkSideEffectsRecursive` folds the second call into the first and uses

// one frame per module, so this limit caps the native stack at half the depth

// where the original code overflowed — well within the safe range across

// platforms while keeping the common (shallow) case purely recursive.

const SIDE_EFFECTS_RECURSION_LIMIT = 2000;

/**

* Iterative form of the side-effects walker. Used as a fallback once the

* recursive form reaches `SIDE_EFFECTS_RECURSION_LIMIT` so deep chains

* (#20986) don't overflow V8's stack. Safe to enter while ancestors set

* `_isEvaluatingSideEffects` on their own modules — those are treated as

* `CIRCULAR_CONNECTION` if revisited, matching the original recursive

* behavior.

* @param {NormalModule} rootMod the module to walk

* @param {ModuleGraph} moduleGraph the module graph

* @returns {ConnectionState} the side-effects connection state

*/

const walkSideEffectsIterative = (rootMod, moduleGraph) => {

const SideEffectDep = getHarmonyImportSideEffectDependency();

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

const modStack = [rootMod];

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

const depsStack = [rootMod.dependencies];

const indexStack = [0];

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

const currentStack = [false];

rootMod._isEvaluatingSideEffects = true;

/**

* Result from a just-popped child frame, to be applied to the new

* top's current dep. `undefined` means "no pending; advance".

* @type {ConnectionState | undefined}

*/

let pending;

while (modStack.length > 0) {

const top = modStack.length - 1;

const topMod = modStack[top];

const deps = depsStack[top];

let index = indexStack[top];

let current = currentStack[top];

if (pending !== undefined) {

const state = pending;

pending = undefined;

const dep = deps[index];

if (state === true) {

recordSideEffectsBailout(topMod, moduleGraph, dep);

topMod._isEvaluatingSideEffects = false;

// `true` is monotonic — safe to memoize regardless of cycle

// status, matching the direct-bailout branch below.

topMod._sideEffectsStateGraph = moduleGraph;

topMod._sideEffectsStateValue = true;

modStack.pop();

depsStack.pop();

indexStack.pop();

currentStack.pop();

pending = true;

continue;

}

if (state !== ModuleGraphConnection.CIRCULAR_CONNECTION) {

current = ModuleGraphConnection.addConnectionStates(current, state);

}

index++;

}

let descended = false;

const depCount = deps.length;

while (index < depCount) {

const dep = deps[index];

/** @type {ConnectionState} */

let state;

if (dep instanceof SideEffectDep) {

const refModule = moduleGraph.getModule(dep);

if (!refModule) {

state = true;

} else if (refModule instanceof NormalModule) {

// Cache hit

if (refModule._sideEffectsStateGraph === moduleGraph) {

state = /** @type {ConnectionState} */ (

refModule._sideEffectsStateValue

);

}

// Fast-path checks inlined to avoid the helper call.

else if (refModule.factoryMeta !== undefined) {

if (refModule.factoryMeta.sideEffectFree) {

state = false;

} else if (refModule.factoryMeta.sideEffectFree === false) {

state = true;

} else if (

!(

refModule.buildMeta !== undefined &&

refModule.buildMeta.sideEffectFree

)

) {

state = true;

} else if (refModule._isEvaluatingSideEffects) {

_sideEffectsCircularSeen = true;

state = ModuleGraphConnection.CIRCULAR_CONNECTION;

} else {

// Descend

indexStack[top] = index;

currentStack[top] = current;

refModule._isEvaluatingSideEffects = true;

modStack.push(refModule);

depsStack.push(refModule.dependencies);

indexStack.push(0);

currentStack.push(false);

descended = true;

break;

}

} else if (

!(

refModule.buildMeta !== undefined &&

refModule.buildMeta.sideEffectFree

)

) {

state = true;

} else if (refModule._isEvaluatingSideEffects) {

_sideEffectsCircularSeen = true;

state = ModuleGraphConnection.CIRCULAR_CONNECTION;

} else {

// Descend

indexStack[top] = index;

currentStack[top] = current;

refModule._isEvaluatingSideEffects = true;

modStack.push(refModule);

depsStack.push(refModule.dependencies);

indexStack.push(0);

currentStack.push(false);

descended = true;

break;

}

} else {

_sideEffectsCircularSeen = true;

state = refModule.getSideEffectsConnectionState(moduleGraph);

}

} else {

state = dep.getModuleEvaluationSideEffectsState(moduleGraph);

}

if (state === true) {

recordSideEffectsBailout(topMod, moduleGraph, dep);

topMod._isEvaluatingSideEffects = false;

topMod._sideEffectsStateGraph = moduleGraph;

topMod._sideEffectsStateValue = true;

modStack.pop();

depsStack.pop();

indexStack.pop();

currentStack.pop();

pending = true;

descended = true;

break;

}

if (state !== ModuleGraphConnection.CIRCULAR_CONNECTION) {

current = ModuleGraphConnection.addConnectionStates(current, state);

}

index++;

}

if (descended) continue;

topMod._isEvaluatingSideEffects = false;

if (!_sideEffectsCircularSeen) {

topMod._sideEffectsStateGraph = moduleGraph;

topMod._sideEffectsStateValue = current;

}

pending = current;

modStack.pop();

depsStack.pop();

indexStack.pop();

currentStack.pop();

}

return /** @type {ConnectionState} */ (pending);

};

/**

* Tracks whether a cycle (CIRCULAR_CONNECTION) was encountered anywhere

* in the currently-executing walk. The walker uses this to decide whether

* an intermediate result is safe to memoize on the module: a result

* computed in the presence of a cycle can differ from the result computed

* fresh, because cycle short-circuiting hides the contribution of the

* back-edge target. Reset to `false` at the top-level entry; read and

* propagated by each recursive frame.

*/

let _sideEffectsCircularSeen = false;

/**

* Walks back up a stack of linear-chain ancestors, applying the result

* `state` of the chain's tail to each ancestor. Each ancestor in the

* stack had exactly one `HarmonyImportSideEffectDependency` returning

* `state`, so its result is just `state` (with the usual aggregation

* rules) and we can avoid building per-frame `current` accumulators.

* @param {(NormalModule | Dependency)[] | null} ancestors interleaved stack of `[mod, sideEffectDep, mod, sideEffectDep, …]` in descent order; `null` if there were none

* @param {ConnectionState} state result from the chain's tail

* @param {ModuleGraph} moduleGraph the module graph

* @returns {ConnectionState} the root ancestor's result

*/

const propagateLinearResult = (ancestors, state, moduleGraph) => {

if (ancestors === null) return state;

while (ancestors.length > 0) {

const dep = /** @type {Dependency} */ (ancestors.pop());

const ancestor = /** @type {NormalModule} */ (ancestors.pop());

ancestor._isEvaluatingSideEffects = false;

if (state === true) {

recordSideEffectsBailout(ancestor, moduleGraph, dep);

// `true` is monotonic — safe to cache regardless of cycle status.

ancestor._sideEffectsStateGraph = moduleGraph;

ancestor._sideEffectsStateValue = true;

} else if (state === ModuleGraphConnection.CIRCULAR_CONNECTION) {

// CIRCULAR_CONNECTION is filtered before folding into `current`,

// so the ancestor's `current` stays at its initial `false`. From

// this point upward the propagated state is `false`, and the

// cycle taint prevents memoization further up (handled by

// `_sideEffectsCircularSeen`).

state = false;

} else if (!_sideEffectsCircularSeen) {

ancestor._sideEffectsStateGraph = moduleGraph;

ancestor._sideEffectsStateValue = state;

}

}

return state;

};

/**

* Recursive form of the side-effects walker. Folds the descent through

* `HarmonyImportSideEffectDependency.getModuleEvaluationSideEffectsState`

* directly into the loop so each module costs only one V8 stack frame

* (vs. two in the original recursive code).

*

* Linear-chain heads (modules with exactly one

* `HarmonyImportSideEffectDependency` to another `NormalModule`) are

* walked iteratively inside the function via an explicit

* `linearAncestors` stack — no additional V8 frame per descent — and

* their results are propagated back up by `propagateLinearResult`. This

* keeps stack consumption at O(1) for the common deep-import-chain

* pattern that motivated #20986 and also avoids the heavier iterative

* fallback.

*

* Falls back to `walkSideEffectsIterative` only when a *non-linear*

* walk reaches `SIDE_EFFECTS_RECURSION_LIMIT` — i.e. a deep tree, where

* each level genuinely needs its own recursion frame.

*

* Caches the result on the module when the walk did not encounter a

* cycle, so subsequent queries (e.g. repeated lookups during

* `SideEffectsFlagPlugin`'s incoming-connection optimization and its

* `exportInfo.getTarget` callbacks) return in O(1).

* @param {NormalModule} mod the module being walked

* @param {ModuleGraph} moduleGraph the module graph

* @param {number} depth current recursion depth (only counts true V8 frames)

* @param {EXPECTED_ANY} SideEffectDep `HarmonyImportSideEffectDependency` constructor, resolved once at the public entry to avoid repeated `require` lookups in the recursive call

* @returns {ConnectionState} the side-effects connection state

*/

const walkSideEffectsRecursive = (mod, moduleGraph, depth, SideEffectDep) => {

// Interleaved `[mod, linearDep, mod, linearDep, …]` for the linear

// chain head; `null` until the first descent.

/** @type {(NormalModule | Dependency)[] | null} */

let linearAncestors = null;

// Walk the linear-chain head iteratively. Every loop iteration peels

// off one module without consuming a V8 stack frame.

while (true) {

if (mod._sideEffectsStateGraph === moduleGraph) {

return propagateLinearResult(

linearAncestors,

/** @type {ConnectionState} */ (mod._sideEffectsStateValue),

moduleGraph

);

}

if (mod.factoryMeta !== undefined) {

if (mod.factoryMeta.sideEffectFree) {

return propagateLinearResult(linearAncestors, false, moduleGraph);

}

if (mod.factoryMeta.sideEffectFree === false) {

return propagateLinearResult(linearAncestors, true, moduleGraph);

}

}

if (!(mod.buildMeta !== undefined && mod.buildMeta.sideEffectFree)) {

return propagateLinearResult(linearAncestors, true, moduleGraph);

}

if (mod._isEvaluatingSideEffects) {

_sideEffectsCircularSeen = true;

return propagateLinearResult(

linearAncestors,

ModuleGraphConnection.CIRCULAR_CONNECTION,

moduleGraph

);

}

// A real ESM module's `dependencies` typically include one

// `HarmonyImportSideEffectDependency` plus several non-recursive deps

// (export specifiers, const dependencies, …) that report

// `false`/`CIRCULAR_CONNECTION` from

// `getModuleEvaluationSideEffectsState`. Walk the deps in order

// here: as long as at most one is a `SideEffectDep` and no

// non-recursive dep triggers a bailout or contributes a non-`false`

// state, we can still tail-call iteratively through that one

// `SideEffectDep` — no V8 frame needed. This is what keeps the

// 1300-module cyclic chain from #20986 from overflowing V8's stack

// even though each generated module has multiple `dependencies`.

const deps = mod.dependencies;

/** @type {Dependency | null} */

let linearDep = null;

/** @type {ConnectionState} */

let nonRecursiveCurrent = false;

let linearOk = true;

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

const dep = deps[i];

if (dep instanceof SideEffectDep) {

if (linearDep !== null) {

// Two `SideEffectDep`s in the same module — fall back to

// the general walk so each can recurse normally.

linearOk = false;

break;

}

linearDep = dep;

} else {

const state = dep.getModuleEvaluationSideEffectsState(moduleGraph);

if (state === true) {

recordSideEffectsBailout(mod, moduleGraph, dep);

mod._sideEffectsStateGraph = moduleGraph;

mod._sideEffectsStateValue = true;

return propagateLinearResult(linearAncestors, true, moduleGraph);

}

if (state !== ModuleGraphConnection.CIRCULAR_CONNECTION) {

nonRecursiveCurrent = ModuleGraphConnection.addConnectionStates(

nonRecursiveCurrent,

state

);

}

}

}

if (!linearOk || nonRecursiveCurrent !== false) {

// Multiple `SideEffectDep`s, or a non-recursive dep contributed

// a non-`false` state (e.g. `TRANSITIVE_ONLY`). The linear

// propagation rule "ancestor's current = chain state" no longer

// holds, so fall back to the general walk.

break;

}

if (linearDep === null) {

// No `SideEffectDep` — the module is a leaf as far as the

// side-effects graph is concerned. Cache and propagate `false`.

if (!_sideEffectsCircularSeen) {

mod._sideEffectsStateGraph = moduleGraph;

mod._sideEffectsStateValue = false;

}

return propagateLinearResult(linearAncestors, false, moduleGraph);

}

const refModule = moduleGraph.getModule(linearDep);

if (!refModule) {

recordSideEffectsBailout(mod, moduleGraph, linearDep);

mod._sideEffectsStateGraph = moduleGraph;

mod._sideEffectsStateValue = true;

return propagateLinearResult(linearAncestors, true, moduleGraph);

}

if (!(refModule instanceof NormalModule)) {

// Non-NormalModule's `getSideEffectsConnectionState` re-enters

// the public method; defer to the general walk for safety.

break;

}

mod._isEvaluatingSideEffects = true;

if (linearAncestors === null) linearAncestors = [];

// Push (mod, linearDep) so `propagateLinearResult` records bailouts

// against the actual `SideEffectDep` that triggered the descent —

// which may not be `dependencies[0]` when the module also has

// export / const dependencies.

linearAncestors.push(mod, linearDep);

mod = refModule;

continue;

}

// Non-linear walk. Each genuine recursive call costs one V8 frame, so

// honour the depth limit here.

if (depth >= SIDE_EFFECTS_RECURSION_LIMIT) {

return propagateLinearResult(

linearAncestors,

walkSideEffectsIterative(mod, moduleGraph),

moduleGraph

);

}

mod._isEvaluatingSideEffects = true;

/** @type {ConnectionState} */

let current = false;

for (const dep of mod.dependencies) {

/** @type {ConnectionState} */

let state;

if (dep instanceof SideEffectDep) {

const refModule = moduleGraph.getModule(dep);

if (!refModule) {

state = true;

} else if (refModule instanceof NormalModule) {

state = walkSideEffectsRecursive(

refModule,

moduleGraph,

depth + 1,

SideEffectDep

);

} else {

// Non-NormalModule's `getSideEffectsConnectionState` (notably

// `ConcatenatedModule` delegating to its root) re-enters the

// public method and may walk through modules that the outer

// walk has marked as evaluating. We can't observe whether

// the inner walk hit a cycle that reflected the outer's

// state, so treat the walk as cycle-tainted and skip the

// cache for safety.

_sideEffectsCircularSeen = true;

state = refModule.getSideEffectsConnectionState(moduleGraph);

}

} else {

state = dep.getModuleEvaluationSideEffectsState(moduleGraph);

}

if (state === true) {

recordSideEffectsBailout(mod, moduleGraph, dep);

mod._isEvaluatingSideEffects = false;

// `true` is monotonic — once any dep declares side effects, the

// answer is `true` regardless of how cycles resolve, so it's

// always safe to memoize.

mod._sideEffectsStateGraph = moduleGraph;

mod._sideEffectsStateValue = true;

return propagateLinearResult(linearAncestors, true, moduleGraph);

}

if (state !== ModuleGraphConnection.CIRCULAR_CONNECTION) {

current = ModuleGraphConnection.addConnectionStates(current, state);

}

}

mod._isEvaluatingSideEffects = false;

// Only memoize when no cycle has been observed anywhere in the walk

// since the public entry. A cycle anywhere can affect any ancestor's

// result (the back-edge target's contribution is hidden by

// CIRCULAR_CONNECTION short-circuiting), so this single flag is the

// conservative-but-cheap approximation of "this subtree's result is

// independent of cycle context". The public entry resets the flag.

if (!_sideEffectsCircularSeen) {

mod._sideEffectsStateGraph = moduleGraph;

mod._sideEffectsStateValue = current;

}

return propagateLinearResult(linearAncestors, current, moduleGraph);

};

const ABSOLUTE_PATH_REGEX = /^(?:[a-z]:\\|\\\\|\/)/i;

/**

* @typedef {object} LoaderItem

* @property {string} loader

* @property {string | null | undefined | Record<string, EXPECTED_ANY>} options

* @property {string | null=} ident

* @property {string | null=} type

*/

/**

* @param {string} context absolute context path

* @param {string} source a source path

* @param {AssociatedObjectForCache=} associatedObjectForCache an object to which the cache will be attached

* @returns {string} new source path

*/

const contextifySourceUrl = (context, source, associatedObjectForCache) => {

if (source.startsWith("webpack://")) return source;

return `webpack://${makePathsRelative(

context,

source,

associatedObjectForCache

)}`;

};

/**

* @param {string} context absolute context path

* @param {string | RawSourceMap} sourceMap a source map

* @param {AssociatedObjectForCache=} associatedObjectForCache an object to which the cache will be attached

* @returns {string | RawSourceMap} new source map

*/

const contextifySourceMap = (context, sourceMap, associatedObjectForCache) => {

if (typeof sourceMap === "string" || !Array.isArray(sourceMap.sources)) {

return sourceMap;

}

const { sourceRoot } = sourceMap;

/** @type {(source: string) => string} */

const mapper = !sourceRoot

? (source) => source

: sourceRoot.endsWith("/")

? (source) =>

source.startsWith("/")

? `${sourceRoot.slice(0, -1)}${source}`

: `${sourceRoot}${source}`

: (source) =>

source.startsWith("/")

? `${sourceRoot}${source}`

: `${sourceRoot}/${source}`;

const newSources = sourceMap.sources.map((source) =>

contextifySourceUrl(context, mapper(source), associatedObjectForCache)

);

return {

...sourceMap,

file: "x",

sourceRoot: undefined,

sources: newSources

};

};

/**

* @param {string | Buffer} input the input

* @returns {string} the converted string

*/

const asString = (input) => {

if (Buffer.isBuffer(input)) {

return input.toString("utf8");

}

return input;

};

/**

* @param {string | Buffer} input the input

* @returns {Buffer} the converted buffer

*/

const asBuffer = (input) => {

if (!Buffer.isBuffer(input)) {

return Buffer.from(input, "utf8");

}

return input;

};

/** @typedef {[string | Buffer, string | RawSourceMap | undefined, PreparsedAst | undefined]} Result */

/** @typedef {LoaderContext<EXPECTED_ANY>} AnyLoaderContext */

/**

* @deprecated Use the `readResource` hook instead.

* @typedef {HookMap<FakeHook<AsyncSeriesBailHook<[string, NormalModule], string | Buffer | null>>>} DeprecatedReadResourceForScheme

*/

/**

* @typedef {object} NormalModuleCompilationHooks

* @property {SyncHook<[AnyLoaderContext, NormalModule]>} loader

* @property {SyncHook<[LoaderItem[], NormalModule, AnyLoaderContext]>} beforeLoaders

* @property {SyncHook<[NormalModule]>} beforeParse

* @property {SyncHook<[NormalModule]>} beforeSnapshot

* @property {DeprecatedReadResourceForScheme} readResourceForScheme

* @property {HookMap<AsyncSeriesBailHook<[AnyLoaderContext], string | Buffer | null>>} readResource

* @property {SyncWaterfallHook<[Result, NormalModule]>} processResult

* @property {AsyncSeriesBailHook<[NormalModule, NeedBuildContext], boolean>} needBuild

*/

/**

* @template {NormalModuleTypes | ""} [T=NormalModuleTypes | ""]

* @typedef {object} NormalModuleCreateData

* @property {string=} layer an optional layer in which the module is

* @property {T} type module type. When deserializing, this is set to an empty string "".

* @property {string} request request string

* @property {string} userRequest request intended by user (without loaders from config)

* @property {string} rawRequest request without resolving

* @property {LoaderItem[]} loaders list of loaders

* @property {string} resource path + query of the real resource

* @property {(ResourceSchemeData & Partial<ResolveRequest>)=} resourceResolveData resource resolve data

* @property {string} context context directory for resolving

* @property {string=} matchResource path + query of the matched resource (virtual)

* @property {ParserByType[T]} parser the parser used

* @property {ParserOptionsByType[T]=} parserOptions the options of the parser used

* @property {GeneratorByType[T]} generator the generator used

* @property {GeneratorOptionsByType[T]=} generatorOptions the options of the generator used

* @property {ResolveOptions=} resolveOptions options used for resolving requests from this module

* @property {boolean} extractSourceMap enable/disable extracting source map

*/

/**

* @typedef {(resourcePath: string, getLoaderContext: (resourcePath: string) => AnyLoaderContext) => Promise<string | Buffer<ArrayBufferLike>>} ReadResource

*/

/** @type {WeakMap<Compilation, NormalModuleCompilationHooks>} */

const compilationHooksMap = new WeakMap();

class NormalModule extends Module {

/**

* @param {Compilation} compilation the compilation

* @returns {NormalModuleCompilationHooks} the attached hooks

*/

static getCompilationHooks(compilation) {

if (!(compilation instanceof Compilation)) {

throw new TypeError(

"The 'compilation' argument must be an instance of Compilation"

);

}

let hooks = compilationHooksMap.get(compilation);

if (hooks === undefined) {

hooks = {

loader: new SyncHook(["loaderContext", "module"]),

beforeLoaders: new SyncHook(["loaders", "module", "loaderContext"]),

beforeParse: new SyncHook(["module"]),

beforeSnapshot: new SyncHook(["module"]),

// TODO webpack 6 deprecate

readResourceForScheme: new HookMap((scheme) => {

const hook =

/** @type {NormalModuleCompilationHooks} */

(hooks).readResource.for(scheme);

return createFakeHook(

/** @type {AsyncSeriesBailHook<[string, NormalModule], string | Buffer | null>} */ ({

tap: (options, fn) =>

hook.tap(options, (loaderContext) =>

fn(

loaderContext.resource,

/** @type {NormalModule} */ (loaderContext._module)

)

),

tapAsync: (options, fn) =>

hook.tapAsync(options, (loaderContext, callback) =>

fn(

loaderContext.resource,

/** @type {NormalModule} */ (loaderContext._module),

callback

)

),

tapPromise: (options, fn) =>

hook.tapPromise(options, (loaderContext) =>

fn(

loaderContext.resource,

/** @type {NormalModule} */ (loaderContext._module)

)

)

})

);

}),

readResource: new HookMap(

() => new AsyncSeriesBailHook(["loaderContext"])

),

processResult: new SyncWaterfallHook(["result", "module"]),

needBuild: new AsyncSeriesBailHook(["module", "context"])

};

compilationHooksMap.set(

compilation,

/** @type {NormalModuleCompilationHooks} */ (hooks)

);

}

return /** @type {NormalModuleCompilationHooks} */ (hooks);

}

/**

* @param {NormalModuleCreateData} options options object

*/

constructor({

layer,

type,

request,

userRequest,

rawRequest,

loaders,

resource,

resourceResolveData,

context,

matchResource,

parser,

parserOptions,

generator,

generatorOptions,

resolveOptions,

extractSourceMap

}) {

super(type, context || getContext(resource), layer);

// Info from Factory

/** @type {NormalModuleCreateData['request']} */

this.request = request;

/** @type {NormalModuleCreateData['userRequest']} */

this.userRequest = userRequest;

/** @type {NormalModuleCreateData['rawRequest']} */

this.rawRequest = rawRequest;

/** @type {boolean} */

this.binary = /^(?:asset|webassembly)\b/.test(type);

/** @type {NormalModuleCreateData['parser'] | undefined} */

this.parser = parser;

/** @type {NormalModuleCreateData['parserOptions']} */

this.parserOptions = parserOptions;

/** @type {NormalModuleCreateData['generator'] | undefined} */

this.generator = generator;

/** @type {NormalModuleCreateData['generatorOptions']} */

this.generatorOptions = generatorOptions;

/** @type {NormalModuleCreateData['resource']} */

this.resource = resource;

/** @type {NormalModuleCreateData['resourceResolveData']} */

this.resourceResolveData = resourceResolveData;

/** @type {NormalModuleCreateData['matchResource']} */

this.matchResource = matchResource;

/** @type {NormalModuleCreateData['loaders']} */

this.loaders = loaders;

if (resolveOptions !== undefined) {

// already declared in super class

/** @type {NormalModuleCreateData['resolveOptions']} */

this.resolveOptions = resolveOptions;

}

/** @type {NormalModuleCreateData['extractSourceMap']} */

this.extractSourceMap = extractSourceMap;

// Info from Build

/** @type {Error | null} */

this.error = null;

/**

* @private

* @type {Source | null}

*/

this._source = null;

/**

* @private

* @type {Map<undefined | SourceType, number> | undefined}

*/

this._sourceSizes = undefined;

/**

* @private

* @type {undefined | SourceTypes}

*/

this._sourceTypes = undefined;

// Cache

/**

* @private

* @type {BuildMeta}

*/

this._lastSuccessfulBuildMeta = {};

/**

* @private

* @type {boolean}

*/

this._forceBuild = true;

/**

* @type {boolean}

*/

this._isEvaluatingSideEffects = false;

/**

* @type {WeakSet<ModuleGraph> | undefined}

*/

this._addedSideEffectsBailout = undefined;

/**

* Memoizes the result of `getSideEffectsConnectionState`. The

* graph slot keys the cached value to the `ModuleGraph` it was

* computed against so stale values never leak across compilations

* — a walk that targets a different graph just overwrites both

* slots. Populated only for results computed without encountering

* a circular connection (see `walkSideEffectsRecursive`).

* @type {ModuleGraph | undefined}

*/

this._sideEffectsStateGraph = undefined;

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

this._sideEffectsStateValue = undefined;

/**

* @private

* @type {CodeGenerationResultData}

*/

this._codeGeneratorData = new Map();

}

/**

* Returns the unique identifier used to reference this module.

* @returns {string} a unique identifier of the module

*/

identifier() {

if (this.layer === null) {

if (this.type === JAVASCRIPT_MODULE_TYPE_AUTO) {

return this.request;

}

return `${this.type}|${this.request}`;

}

return `${this.type}|${this.request}|${this.layer}`;

}

/**

* Returns a human-readable identifier for this module.

* @param {RequestShortener} requestShortener the request shortener

* @returns {string} a user readable identifier of the module

*/

readableIdentifier(requestShortener) {

return /** @type {string} */ (requestShortener.shorten(this.userRequest));

}

/**

* @returns {string | null} return the resource path

*/

getResource() {

return this.matchResource || this.resource;

}

/**

* Gets the library identifier.

* @param {LibIdentOptions} options options

* @returns {LibIdent | null} an identifier for library inclusion

*/

libIdent(options) {

let ident = contextify(

options.context,

this.userRequest,

options.associatedObjectForCache

);

if (this.layer) ident = `(${this.layer})/${ident}`;

return ident;

}

/**

* Returns the path used when matching this module against rule conditions.

* @returns {NameForCondition | null} absolute path which should be used for condition matching (usually the resource path)

*/

nameForCondition() {

const resource = /** @type {string} */ (this.getResource());

const idx = resource.indexOf("?");

if (idx >= 0) return resource.slice(0, idx);

return resource;

}

/**

* Assuming this module is in the cache. Update the (cached) module with

* the fresh module from the factory. Usually updates internal references

* and properties.

* @param {Module} module fresh module

* @returns {void}

*/

updateCacheModule(module) {

super.updateCacheModule(module);

const m = /** @type {NormalModule} */ (module);

this.binary = m.binary;

this.request = m.request;

this.userRequest = m.userRequest;

this.rawRequest = m.rawRequest;

this.parser = m.parser;

this.parserOptions = m.parserOptions;

this.generator = m.generator;

this.generatorOptions = m.generatorOptions;

this.resource = m.resource;

this.resourceResolveData = m.resourceResolveData;

this.context = m.context;

this.matchResource = m.matchResource;

this.loaders = m.loaders;