/*

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 {Iterator<SideEffectsWalk, ConnectionState, ConnectionState>} SideEffectsWalk */

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

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

/** @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)}`

);

};

/**

* Generator form of `getSideEffectsConnectionState` — descends through

* `HarmonyImportSideEffectDependency` via `yield` so the trampoline in

* `getSideEffectsConnectionState` can drive the walk iteratively (#20986).

* @param {NormalModule} mod the module being evaluated

* @param {ModuleGraph} moduleGraph the module graph

* @returns {SideEffectsWalk} the generator

*/

function* walkSideEffects(mod, moduleGraph) {

if (mod.factoryMeta !== undefined) {

if (mod.factoryMeta.sideEffectFree) return false;

if (mod.factoryMeta.sideEffectFree === false) return true;

}

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

return true;

}

if (mod._isEvaluatingSideEffects) {

return ModuleGraphConnection.CIRCULAR_CONNECTION;

}

const SideEffectDep = getHarmonyImportSideEffectDependency();

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 = yield walkSideEffects(refModule, moduleGraph);

} else {

state = refModule.getSideEffectsConnectionState(moduleGraph);

}

} else {

state = dep.getModuleEvaluationSideEffectsState(moduleGraph);

}

if (state === true) {

recordSideEffectsBailout(mod, moduleGraph, dep);

mod._isEvaluatingSideEffects = false;

return true;

}

if (state !== ModuleGraphConnection.CIRCULAR_CONNECTION) {

current = ModuleGraphConnection.addConnectionStates(current, state);

}

}

mod._isEvaluatingSideEffects = false;

// When caching is implemented here, make sure to not cache when

// at least one circular connection was folded into `current`.

return current;

}

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

*/

/**

* @typedef {object} NormalModuleCreateData

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

* @property {NormalModuleTypes | ""} 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 {Parser} parser the parser used

* @property {ParserOptions=} parserOptions the options of the parser used

* @property {Generator} generator the generator used

* @property {GeneratorOptions=} 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;

/**

* @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;

this.extractSourceMap = m.extractSourceMap;

}

/**

* Assuming this module is in the cache. Remove internal references to allow freeing some memory.

*/

cleanupForCache() {

// Make sure to cache types and sizes before cleanup when this module has been built

// They are accessed by the stats and we don't want them to crash after cleanup

// TODO reconsider this for webpack 6

if (this.buildInfo) {

if (this._sourceTypes === undefined) this.getSourceTypes();

for (const type of /** @type {SourceTypes} */ (this._sourceTypes)) {

this.size(type);

}

}

super.cleanupForCache();

this.parser = undefined;

this.parserOptions = undefined;

this.generator = undefined;

this.generatorOptions = undefined;

}

/**

* Module should be unsafe cached. Get data that's needed for that.

* This data will be passed to restoreFromUnsafeCache later.

* @returns {UnsafeCacheData} cached data

*/

getUnsafeCacheData() {

const data = super.getUnsafeCacheData();

data.parserOptions = this.parserOptions;

data.generatorOptions = this.generatorOptions;

return data;

}

/**

* restore unsafe cache data

* @param {UnsafeCacheData} unsafeCacheData data from getUnsafeCacheData

* @param {NormalModuleFactory} normalModuleFactory the normal module factory handling the unsafe caching

*/

restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory) {

this._restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory);

}

/**

* restore unsafe cache data

* @param {UnsafeCacheData} unsafeCacheData data from getUnsafeCacheData

* @param {NormalModuleFactory} normalModuleFactory the normal module factory handling the unsafe caching

*/

_restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory) {

super._restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory);

this.parserOptions = unsafeCacheData.parserOptions;

this.parser = normalModuleFactory.getParser(this.type, this.parserOptions);

this.generatorOptions = unsafeCacheData.generatorOptions;

this.generator = normalModuleFactory.getGenerator(

this.type,

this.generatorOptions

);

// we assume the generator behaves identically and keep cached sourceTypes/Sizes

}

/**

* @param {string} context the compilation context

* @param {string} name the asset name

* @param {string | Buffer} content the content

* @param {(string | RawSourceMap)=} sourceMap an optional source map

* @param {AssociatedObjectForCache=} associatedObjectForCache object for caching

* @returns {Source} the created source

*/

createSourceForAsset(

context,

name,

content,

sourceMap,

associatedObjectForCache

) {

if (sourceMap) {

if (

typeof sourceMap === "string" &&

(this.useSourceMap || this.useSimpleSourceMap)

) {

return new OriginalSource(

content,

contextifySourceUrl(context, sourceMap, associatedObjectForCache)

);

}

if (this.useSourceMap) {

return new SourceMapSource(

content,

name,

contextifySourceMap(

context,

/** @type {RawSourceMap} */

(sourceMap),

associatedObjectForCache

)

);

}

}

return new RawSource(content);

}

/**

* @private

* @template T

* @param {ResolverWithOptions} resolver a resolver

* @param {WebpackOptions} options webpack options

* @param {Compilation} compilation the compilation

* @param {InputFileSystem} fs file system from reading

* @param {NormalModuleCompilationHooks} hooks the hooks

* @returns {import("../declarations/LoaderContext").LoaderContext<T>} loader context

*/

_createLoaderContext(resolver, options, compilation, fs, hooks) {

const { requestShortener } = compilation.runtimeTemplate;

const getCurrentLoaderName = () => {

const currentLoader = this.getCurrentLoader(

/** @type {AnyLoaderContext} */

(loaderContext)

);

if (!currentLoader) return "(not in loader scope)";

return requestShortener.shorten(currentLoader.loader);

};

/**

* @returns {ResolveContext} resolve context

*/

const getResolveContext = () => ({

fileDependencies: {

add: (d) =>

/** @type {AnyLoaderContext} */

(loaderContext).addDependency(d)

},

contextDependencies: {

add: (d) =>

/** @type {AnyLoaderContext} */

(loaderContext).addContextDependency(d)

},

missingDependencies: {

add: (d) =>

/** @type {AnyLoaderContext} */

(loaderContext).addMissingDependency(d)

}

});

const getAbsolutify = memoize(() =>

absolutify.bindCache(compilation.compiler.root)

);

const getAbsolutifyInContext = memoize(() =>

absolutify.bindContextCache(

/** @type {string} */

(this.context),

compilation.compiler.root

)

);

const getContextify = memoize(() =>

contextify.bindCache(compilation.compiler.root)

);

const getContextifyInContext = memoize(() =>

contextify.bindContextCache(

/** @type {string} */

(this.context),

compilation.compiler.root

)

);

const utils = {

/**

* @param {string} context context

* @param {string} request request

* @returns {string} result

*/

absolutify: (context, request) =>

context === this.context

? getAbsolutifyInContext()(request)

: getAbsolutify()(context, request),

/**

* @param {string} context context

* @param {string} request request

* @returns {string} result

*/

contextify: (context, request) =>

context === this.context

? getContextifyInContext()(request)

: getContextify()(context, request),

/**

* @param {HashFunction=} type type

* @returns {Hash} hash

*/

createHash: (type) =>

createHash(type || compilation.outputOptions.hashFunction)

};

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

const loaderContext = {

version: 2,

/**

* @param {import("../declarations/LoaderContext").Schema=} schema schema

* @returns {T} options

*/

getOptions: (schema) => {

const loader = this.getCurrentLoader(

/** @type {AnyLoaderContext} */

(loaderContext)

);

let { options } = /** @type {LoaderItem} */ (loader);

if (typeof options === "string") {

if (options.startsWith("{") && options.endsWith("}")) {

try {

options =

/** @type {LoaderItem["options"]} */

(parseJson(options));

} catch (err) {

throw new Error(

`Cannot parse string options: ${/** @type {Error} */ (err).message}`,

{ cause: err }

);

}

} else {

options = querystring.parse(options, "&", "=", {

maxKeys: 0

});

}

}

if (options === null || options === undefined) {

options = {};

}

if (schema && compilation.options.validate) {

let name = "Loader";

let baseDataPath = "options";

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

let match;

if (schema.title && (match = /^(.+) (.+)$/.exec(schema.title))) {

[, name, baseDataPath] = match;

}

getValidate()(schema, /** @type {EXPECTED_OBJECT} */ (options), {

name,

baseDataPath

});

}

return /** @type {T} */ (options);

},

emitWarning: (warning) => {

if (!(warning instanceof Error)) {

warning = new NonErrorEmittedError(warning);

}

this.addWarning(

new ModuleWarning(warning, {

from: getCurrentLoaderName()

})

);

},

emitError: (error) => {

if (!(error instanceof Error)) {

error = new NonErrorEmittedError(error);

}

this.addError(

new ModuleError(error, {

from: getCurrentLoaderName()

})

);

},

getLogger: (name) => {

const currentLoader = this.getCurrentLoader(

/** @type {AnyLoaderContext} */

(loaderContext)

);

return compilation.getLogger(() =>

[currentLoader && currentLoader.loader, name, this.identifier()]

.filter(Boolean)

.join("|")

);

},

resolve(context, request, callback) {

resolver.resolve({}, context, request, getResolveContext(), callback);

},

getResolve(options) {

const child = options ? resolver.withOptions(options) : resolver;

return /** @type {ReturnType<import("../declarations/LoaderContext").NormalModuleLoaderContext<T>["getResolve"]>} */ (

(context, request, callback) => {

if (callback) {

child.resolve(

{},

context,

request,

getResolveContext(),

callback

);

} else {

return new Promise((resolve, reject) => {

child.resolve(

{},

context,

request,

getResolveContext(),

(err, result) => {

if (err) reject(err);

else resolve(result);

}

);

});

}

}

);

},

emitFile: (name, content, sourceMap, assetInfo) => {

const buildInfo = /** @type {BuildInfo} */ (this.buildInfo);

if (!buildInfo.assets) {

buildInfo.assets = Object.create(null);

buildInfo.assetsInfo = new Map();

}

const assets =

/** @type {NonNullable<KnownBuildInfo["assets"]>} */

(buildInfo.assets);

const assetsInfo =

/** @type {NonNullable<KnownBuildInfo["assetsInfo"]>} */

(buildInfo.assetsInfo);

assets[name] = this.createSourceForAsset(

options.context,

name,

content,

sourceMap,

compilation.compiler.root

);

assetsInfo.set(name, assetInfo);

},

addBuildDependency: (dep) => {

const buildInfo = /** @type {BuildInfo} */ (this.buildInfo);

if (buildInfo.buildDependencies === undefined) {

buildInfo.buildDependencies = new LazySet();

}

buildInfo.buildDependencies.add(dep);

},

utils,

rootContext: options.context,

webpack: true,

sourceMap: Boolean(this.useSourceMap),

mode: options.mode || "production",

hashFunction: options.output.hashFunction,

hashDigest: options.output.hashDigest,

hashDigestLength: options.output.hashDigestLength,

hashSalt: options.output.hashSalt,

_module: this,

_compilation: compilation,

_compiler: compilation.compiler,

fs

};

Object.assign(loaderContext, options.loader);

hooks.loader.call(

/** @type {AnyLoaderContext} */

(loaderContext),

this

);

return /** @type {AnyLoaderContext} */ (loaderContext);

}

/**

* @param {AnyLoaderContext} loaderContext loader context

* @param {number} index index

* @returns {LoaderItem | null} loader

*/

getCurrentLoader(loaderContext, index = loaderContext.loaderIndex) {

if (

this.loaders &&

this.loaders.length &&

index < this.loaders.length &&

index >= 0 &&

this.loaders[index]

) {

return this.loaders[index];

}

return null;

}

/**

* @param {string} context the compilation context

* @param {string | Buffer} content the content

* @param {(string | RawSourceMap | null)=} sourceMap an optional source map

* @param {AssociatedObjectForCache=} associatedObjectForCache object for caching

* @returns {Source} the created source

*/

createSource(context, content, sourceMap, associatedObjectForCache) {

if (Buffer.isBuffer(content)) {

return new RawSource(content);

}

// if there is no identifier return raw source

if (!this.identifier) {

return new RawSource(content);

}

// from here on we assume we have an identifier

const identifier = this.identifier();

if (this.useSourceMap && sourceMap) {

return new SourceMapSource(

content,

contextifySourceUrl(context, identifier, associatedObjectForCache),

contextifySourceMap(context, sourceMap, associatedObjectForCache)

);

}

if (this.useSourceMap || this.useSimpleSourceMap) {

return new OriginalSource(

content,

contextifySourceUrl(context, identifier, associatedObjectForCache)

);

}