/*

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

Author Tobias Koppers @sokra

*/

"use strict";

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

const {

AsyncSeriesBailHook,

HookMap,

SyncBailHook,

SyncHook,

SyncWaterfallHook

} = require("tapable");

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

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

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

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

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

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

const { ImportPhaseUtils } = require("./dependencies/ImportPhase");

const { getContext } = require("./loaders/LoaderRunner");

const BasicEffectRulePlugin = require("./rules/BasicEffectRulePlugin");

const BasicMatcherRulePlugin = require("./rules/BasicMatcherRulePlugin");

const ObjectMatcherRulePlugin = require("./rules/ObjectMatcherRulePlugin");

const RuleSetCompiler = require("./rules/RuleSetCompiler");

const UseEffectRulePlugin = require("./rules/UseEffectRulePlugin");

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

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

const { cachedCleverMerge, cachedSetProperty } = require("./util/cleverMerge");

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

const {

escapeHashInPathRequest,

parseResource,

parseResourceWithoutFragment

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

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

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

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

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

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

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

/** @typedef {import("./ModuleFactory").ModuleFactoryCallback} ModuleFactoryCallback */

/** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */

/** @typedef {import("./ModuleFactory").ModuleFactoryCreateDataContextInfo} ModuleFactoryCreateDataContextInfo */

/** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */

/** @typedef {import("./NormalModule").GeneratorOptions} GeneratorOptions */

/** @typedef {import("./NormalModule").LoaderItem} LoaderItem */

/** @typedef {import("./NormalModule").NormalModuleCreateData} NormalModuleCreateData */

/** @typedef {import("./NormalModule").ParserOptions} ParserOptions */

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

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

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

/** @typedef {import("./dependencies/ModuleDependency")} ModuleDependency */

/** @typedef {import("./dependencies/ImportPhase").ImportPhaseType} ImportPhaseType */

/** @typedef {import("./dependencies/ImportPhase").ImportPhaseName} ImportPhaseName */

/** @typedef {import("./javascript/JavascriptParser").ImportAttributes} ImportAttributes */

/** @typedef {import("./rules/RuleSetCompiler").RuleSetRules} RuleSetRules */

/** @typedef {import("./rules/RuleSetCompiler").RuleSet} RuleSet */

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

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

/**

* Defines the callback type used by this module.

* @template T

* @typedef {import("./Compiler").Callback<T>} Callback

*/

/** @typedef {Pick<RuleSetRule, "type" | "sideEffects" | "parser" | "generator" | "resolve" | "layer" | "extractSourceMap">} ModuleSettings */

/** @typedef {NormalModuleCreateData & { settings: ModuleSettings }} CreateData */

/**

* Defines the resolve data type used by this module.

* @typedef {object} ResolveData

* @property {ModuleFactoryCreateData["contextInfo"]} contextInfo

* @property {ModuleFactoryCreateData["resolveOptions"]} resolveOptions

* @property {string} context

* @property {string} request

* @property {ImportPhaseName=} phase

* @property {ImportAttributes=} attributes

* @property {ModuleDependency[]} dependencies

* @property {string} dependencyType

* @property {Partial<CreateData>} createData

* @property {FileSystemDependencies} fileDependencies

* @property {FileSystemDependencies} missingDependencies

* @property {FileSystemDependencies} contextDependencies

* @property {Module=} ignoredModule

* @property {boolean} cacheable allow to use the unsafe cache

*/

/**

* Defines the resource data type used by this module.

* @typedef {object} ResourceData

* @property {string} resource

* @property {string=} path

* @property {string=} query

* @property {string=} fragment

* @property {string=} context

*/

/**

* Defines the resource scheme data type used by this module.

* @typedef {object} ResourceSchemeData

* @property {string=} mimetype mime type of the resource

* @property {string=} parameters additional parameters for the resource

* @property {"base64" | false=} encoding encoding of the resource

* @property {string=} encodedContent encoded content of the resource

*/

/** @typedef {ResourceData & { data: ResourceSchemeData & Partial<ResolveRequest> }} ResourceDataWithData */

/**

* Defines the parsed loader request type used by this module.

* @typedef {object} ParsedLoaderRequest

* @property {string} loader loader

* @property {string | undefined} options options

*/

/**

* Dependencies captured while resolving a loader.

* @typedef {object} ResolveDependencies

* @property {LazySet<string>} fileDependencies file dependencies of the resolve

* @property {LazySet<string>} contextDependencies context dependencies of the resolve

* @property {LazySet<string>} missingDependencies missing dependencies of the resolve

*/

/**

* Memoized result of resolving a loader for a given (context, request).

* @typedef {ResolveDependencies & { loader: string, query: string | undefined, type: string | undefined }} LoaderResolveCacheEntry

*/

/** @typedef {import("./ModuleTypeConstants").JAVASCRIPT_MODULE_TYPE_AUTO} JAVASCRIPT_MODULE_TYPE_AUTO */

/** @typedef {import("./ModuleTypeConstants").JAVASCRIPT_MODULE_TYPE_DYNAMIC} JAVASCRIPT_MODULE_TYPE_DYNAMIC */

/** @typedef {import("./ModuleTypeConstants").JAVASCRIPT_MODULE_TYPE_ESM} JAVASCRIPT_MODULE_TYPE_ESM */

/** @typedef {import("./ModuleTypeConstants").JSON_MODULE_TYPE} JSON_MODULE_TYPE */

/** @typedef {import("./ModuleTypeConstants").ASSET_MODULE_TYPE} ASSET_MODULE_TYPE */

/** @typedef {import("./ModuleTypeConstants").ASSET_MODULE_TYPE_INLINE} ASSET_MODULE_TYPE_INLINE */

/** @typedef {import("./ModuleTypeConstants").ASSET_MODULE_TYPE_RESOURCE} ASSET_MODULE_TYPE_RESOURCE */

/** @typedef {import("./ModuleTypeConstants").ASSET_MODULE_TYPE_SOURCE} ASSET_MODULE_TYPE_SOURCE */

/** @typedef {import("./ModuleTypeConstants").ASSET_MODULE_TYPE_BYTES} ASSET_MODULE_TYPE_BYTES */

/** @typedef {import("./ModuleTypeConstants").WEBASSEMBLY_MODULE_TYPE_ASYNC} WEBASSEMBLY_MODULE_TYPE_ASYNC */

/** @typedef {import("./ModuleTypeConstants").WEBASSEMBLY_MODULE_TYPE_SYNC} WEBASSEMBLY_MODULE_TYPE_SYNC */

/** @typedef {import("./ModuleTypeConstants").CSS_MODULE_TYPE} CSS_MODULE_TYPE */

/** @typedef {import("./ModuleTypeConstants").CSS_MODULE_TYPE_GLOBAL} CSS_MODULE_TYPE_GLOBAL */

/** @typedef {import("./ModuleTypeConstants").CSS_MODULE_TYPE_MODULE} CSS_MODULE_TYPE_MODULE */

/** @typedef {import("./ModuleTypeConstants").CSS_MODULE_TYPE_AUTO} CSS_MODULE_TYPE_AUTO */

/** @typedef {import("./ModuleTypeConstants").HTML_MODULE_TYPE} HTML_MODULE_TYPE */

/** @typedef {JAVASCRIPT_MODULE_TYPE_AUTO | JAVASCRIPT_MODULE_TYPE_DYNAMIC | JAVASCRIPT_MODULE_TYPE_ESM | JSON_MODULE_TYPE | ASSET_MODULE_TYPE | ASSET_MODULE_TYPE_INLINE | ASSET_MODULE_TYPE_RESOURCE | ASSET_MODULE_TYPE_SOURCE | WEBASSEMBLY_MODULE_TYPE_ASYNC | WEBASSEMBLY_MODULE_TYPE_SYNC | CSS_MODULE_TYPE | CSS_MODULE_TYPE_GLOBAL | CSS_MODULE_TYPE_MODULE | CSS_MODULE_TYPE_AUTO | HTML_MODULE_TYPE} KnownNormalModuleTypes */

/** @typedef {KnownNormalModuleTypes | string} NormalModuleTypes */

const EMPTY_RESOLVE_OPTIONS = {};

/** @type {ParserOptions} */

const EMPTY_PARSER_OPTIONS = {};

/** @type {GeneratorOptions} */

const EMPTY_GENERATOR_OPTIONS = {};

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

const EMPTY_ELEMENTS = [];

const MATCH_RESOURCE_REGEX = /^([^!]+)!=!/;

const LEADING_DOT_EXTENSION_REGEX = /^[^.]/;

/**

* Replays the file/context/missing dependencies captured by a loader resolve

* into a resolve context, so memoized loaders still record everything needed

* for watch invalidation.

* @param {ResolveContext} resolveContext resolve context to add dependencies to

* @param {ResolveDependencies} source captured resolve dependencies

* @returns {void}

*/

const replayResolveDependencies = (resolveContext, source) => {

// On this path resolveContext always carries the three LazySet dependency

// sets built in the `resolve` hook, so they are safe to treat as LazySet.

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

(resolveContext.fileDependencies).addAll(source.fileDependencies);

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

(resolveContext.contextDependencies).addAll(source.contextDependencies);

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

(resolveContext.missingDependencies).addAll(source.missingDependencies);

};

/**

* Returns ident.

* @param {LoaderItem} data data

* @returns {string} ident

*/

const loaderToIdent = (data) => {

if (!data.options) {

return data.loader;

}

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

return `${data.loader}?${data.options}`;

}

if (typeof data.options !== "object") {

throw new Error("loader options must be string or object");

}

if (data.ident) {

return `${data.loader}??${data.ident}`;

}

return `${data.loader}?${JSON.stringify(data.options)}`;

};

/**

* Stringify loaders and resource.

* @param {LoaderItem[]} loaders loaders

* @param {string} resource resource

* @returns {string} stringified loaders and resource

*/

const stringifyLoadersAndResource = (loaders, resource) => {

let str = "";

for (const loader of loaders) {

str += `${loaderToIdent(loader)}!`;

}

return str + resource;

};

/**

* Checks whether it needs calls.

* @param {number} times times

* @param {(err?: null | Error) => void} callback callback

* @returns {(err?: null | Error) => void} callback

*/

const needCalls = (times, callback) => (err) => {

if (--times === 0) {

return callback(err);

}

if (err && times > 0) {

times = Number.NaN;

return callback(err);

}

};

/**

* Merges global options.

* @template T

* @template O

* @param {T} globalOptions global options

* @param {string} type type

* @param {O} localOptions local options

* @returns {T & O | T | O} result

*/

const mergeGlobalOptions = (globalOptions, type, localOptions) => {

const parts = type.split("/");

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

let result;

let current = "";

for (const part of parts) {

current = current ? `${current}/${part}` : part;

const options =

/** @type {T} */

(globalOptions[/** @type {keyof T} */ (current)]);

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

result =

result === undefined ? options : cachedCleverMerge(result, options);

}

}

if (result === undefined) {

return localOptions;

}

return cachedCleverMerge(result, localOptions);

};

// TODO webpack 6 remove

/**

* Deprecation changed hook message.

* @template {import("tapable").Hook<EXPECTED_ANY, EXPECTED_ANY>} T

* @param {string} name name

* @param {T} hook hook

* @returns {string} result

*/

const deprecationChangedHookMessage = (name, hook) => {

const names = hook.taps.map((tapped) => tapped.name).join(", ");

return (

`NormalModuleFactory.${name} (${names}) is no longer a waterfall hook, but a bailing hook instead. ` +

"Do not return the passed object, but modify it instead. " +

"Returning false will ignore the request and results in no module created."

);

};

const ruleSetCompiler = new RuleSetCompiler([

new BasicMatcherRulePlugin("test", "resource"),

new BasicMatcherRulePlugin("scheme"),

new BasicMatcherRulePlugin("mimetype"),

new BasicMatcherRulePlugin("dependency"),

new BasicMatcherRulePlugin("include", "resource"),

new BasicMatcherRulePlugin("exclude", "resource", true),

new BasicMatcherRulePlugin("resource"),

new BasicMatcherRulePlugin("resourceQuery"),

new BasicMatcherRulePlugin("resourceFragment"),

new BasicMatcherRulePlugin("realResource"),

new BasicMatcherRulePlugin("issuer"),

new BasicMatcherRulePlugin("compiler"),

new BasicMatcherRulePlugin("issuerLayer"),

new BasicMatcherRulePlugin("phase"),

new ObjectMatcherRulePlugin("assert", "attributes", (value) => {

if (value) {

return (

/** @type {ImportAttributes} */ (value)._isLegacyAssert !== undefined

);

}

return false;

}),

new ObjectMatcherRulePlugin("with", "attributes", (value) => {

if (value) {

return !(/** @type {ImportAttributes} */ (value)._isLegacyAssert);

}

return false;

}),

new ObjectMatcherRulePlugin("descriptionData"),

new BasicEffectRulePlugin("type"),

new BasicEffectRulePlugin("sideEffects"),

new BasicEffectRulePlugin("parser"),

new BasicEffectRulePlugin("resolve"),

new BasicEffectRulePlugin("generator"),

new BasicEffectRulePlugin("layer"),

new BasicEffectRulePlugin("extractSourceMap"),

new UseEffectRulePlugin()

]);

/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */

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

/** @typedef {import("./javascript/JavascriptGenerator")} JavascriptGenerator */

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

/** @typedef {import("./json/JsonParser")} JsonParser */

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

/** @typedef {import("./json/JsonGenerator")} JsonGenerator */

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

/** @typedef {import("./asset/AssetParser")} AssetParser */

/** @typedef {import("./asset/AssetSourceParser")} AssetSourceParser */

/** @typedef {import("./asset/AssetBytesParser")} AssetBytesParser */

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

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

/** @typedef {import("./asset/AssetGenerator")} AssetGenerator */

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

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

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

/** @typedef {import("./asset/AssetSourceGenerator")} AssetSourceGenerator */

/** @typedef {import("./asset/AssetBytesGenerator")} AssetBytesGenerator */

/** @typedef {import("./wasm-async/AsyncWebAssemblyParser")} AsyncWebAssemblyParser */

/** @typedef {import("./wasm-sync/WebAssemblyParser")} WebAssemblyParser */

/** @typedef {import("./css/CssParser")} CssParser */

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

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

/** @typedef {import("./css/CssGenerator")} CssGenerator */

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

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

/** @typedef {import("./html/HtmlParser")} HtmlParser */

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

/** @typedef {import("./html/HtmlGenerator")} HtmlGenerator */

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

/* eslint-disable jsdoc/type-formatting */

/**

* Defines the shared type used by this module.

* @typedef {[

* [JAVASCRIPT_MODULE_TYPE_AUTO, JavascriptParser, JavascriptParserOptions, JavascriptGenerator, EmptyGeneratorOptions],

* [JAVASCRIPT_MODULE_TYPE_DYNAMIC, JavascriptParser, JavascriptParserOptions, JavascriptGenerator, EmptyGeneratorOptions],

* [JAVASCRIPT_MODULE_TYPE_ESM, JavascriptParser, JavascriptParserOptions, JavascriptGenerator, EmptyGeneratorOptions],

* [JSON_MODULE_TYPE, JsonParser, JsonParserOptions, JsonGenerator, JsonGeneratorOptions],

* [ASSET_MODULE_TYPE, AssetParser, AssetParserOptions, AssetGenerator, AssetGeneratorOptions],

* [ASSET_MODULE_TYPE_INLINE, AssetParser, EmptyParserOptions, AssetGenerator, AssetGeneratorOptions],

* [ASSET_MODULE_TYPE_RESOURCE, AssetParser, EmptyParserOptions, AssetGenerator, AssetGeneratorOptions],

* [ASSET_MODULE_TYPE_SOURCE, AssetSourceParser, EmptyParserOptions, AssetSourceGenerator, EmptyGeneratorOptions],

* [ASSET_MODULE_TYPE_BYTES, AssetBytesParser, EmptyParserOptions, AssetBytesGenerator, EmptyGeneratorOptions],

* [WEBASSEMBLY_MODULE_TYPE_ASYNC, AsyncWebAssemblyParser, EmptyParserOptions, Generator, EmptyGeneratorOptions],

* [WEBASSEMBLY_MODULE_TYPE_SYNC, WebAssemblyParser, EmptyParserOptions, Generator, EmptyGeneratorOptions],

* [CSS_MODULE_TYPE, CssParser, CssParserOptions, CssGenerator, CssGeneratorOptions],

* [CSS_MODULE_TYPE_AUTO, CssParser, CssModuleParserOptions, CssGenerator, CssModuleGeneratorOptions],

* [CSS_MODULE_TYPE_MODULE, CssParser, CssModuleParserOptions, CssGenerator, CssModuleGeneratorOptions],

* [CSS_MODULE_TYPE_GLOBAL, CssParser, CssModuleParserOptions, CssGenerator, CssModuleGeneratorOptions],

* [HTML_MODULE_TYPE, HtmlParser, HtmlParserOptions, HtmlGenerator, HtmlGeneratorOptions],

* [string, Parser, ParserOptions, Generator, GeneratorOptions],

* ]} ParsersAndGeneratorsByTypes

*/

/* eslint-enable jsdoc/type-formatting */

/**

* Defines the extract tuple elements type used by this module.

* @template {unknown[]} T

* @template {number[]} I

* @typedef {{ [K in keyof I]: K extends keyof I ? I[K] extends keyof T ? T[I[K]] : never : never }} ExtractTupleElements

*/

/**

* Represents the normal module factory runtime component.

* @template {unknown[]} T

* @template {number[]} A

* @template [R=void]

* @typedef {T extends [infer Head extends [string, ...unknown[]], ...infer Tail extends [string, ...unknown[]][]] ? Record<Head[0], SyncBailHook<ExtractTupleElements<Head, A>, R extends number ? Head[R] : R>> & RecordFactoryFromTuple<Tail, A, R> : unknown } RecordFactoryFromTuple

*/

/**

* Maps each tuple in `T` to a record from its `[0]` key to its `[I]` value.

* @template {unknown[]} T

* @template {number} I

* @typedef {T extends [infer Head extends [string, ...unknown[]], ...infer Tail extends [string, ...unknown[]][]] ? Record<Head[0], I extends keyof Head ? Head[I] : never> & TupleToTypeMap<Tail, I> : unknown } TupleToTypeMap

*/

/** @typedef {TupleToTypeMap<ParsersAndGeneratorsByTypes, 1>} ParserByType */

/** @typedef {TupleToTypeMap<ParsersAndGeneratorsByTypes, 2>} ParserOptionsByType */

/** @typedef {TupleToTypeMap<ParsersAndGeneratorsByTypes, 3>} GeneratorByType */

/** @typedef {TupleToTypeMap<ParsersAndGeneratorsByTypes, 4>} GeneratorOptionsByType */

class NormalModuleFactory extends ModuleFactory {

/**

* Creates an instance of NormalModuleFactory.

* @param {object} param params

* @param {string=} param.context context

* @param {InputFileSystem} param.fs file system

* @param {ResolverFactory} param.resolverFactory resolverFactory

* @param {ModuleOptions} param.options options

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

*/

constructor({

context,

fs,

resolverFactory,

options,

associatedObjectForCache

}) {

super();

this.hooks = Object.freeze({

/** @type {AsyncSeriesBailHook<[ResolveData], Module | false | void>} */

resolve: new AsyncSeriesBailHook(["resolveData"]),

/** @type {HookMap<AsyncSeriesBailHook<[ResourceDataWithData, ResolveData], true | void>>} */

resolveForScheme: new HookMap(

() => new AsyncSeriesBailHook(["resourceData", "resolveData"])

),

/** @type {HookMap<AsyncSeriesBailHook<[ResourceDataWithData, ResolveData], true | void>>} */

resolveInScheme: new HookMap(

() => new AsyncSeriesBailHook(["resourceData", "resolveData"])

),

/** @type {AsyncSeriesBailHook<[ResolveData], Module | undefined>} */

factorize: new AsyncSeriesBailHook(["resolveData"]),

/** @type {AsyncSeriesBailHook<[ResolveData], false | void>} */

beforeResolve: new AsyncSeriesBailHook(["resolveData"]),

/** @type {AsyncSeriesBailHook<[ResolveData], false | void>} */

afterResolve: new AsyncSeriesBailHook(["resolveData"]),

/** @type {AsyncSeriesBailHook<[CreateData, ResolveData], Module | void>} */

createModule: new AsyncSeriesBailHook(["createData", "resolveData"]),

/** @type {SyncWaterfallHook<[Module, CreateData, ResolveData]>} */

module: new SyncWaterfallHook(["module", "createData", "resolveData"]),

/** @type {import("tapable").TypedHookMap<RecordFactoryFromTuple<ParsersAndGeneratorsByTypes, [2], 1>>} */

createParser: new HookMap(() => new SyncBailHook(["parserOptions"])),

/** @type {import("tapable").TypedHookMap<RecordFactoryFromTuple<ParsersAndGeneratorsByTypes, [1, 2]>>} */

parser: new HookMap(() => new SyncHook(["parser", "parserOptions"])),

/** @type {import("tapable").TypedHookMap<RecordFactoryFromTuple<ParsersAndGeneratorsByTypes, [4], 3>>} */

createGenerator: new HookMap(

() => new SyncBailHook(["generatorOptions"])

),

/** @type {import("tapable").TypedHookMap<RecordFactoryFromTuple<ParsersAndGeneratorsByTypes, [3, 4]>>} */

generator: new HookMap(

() => new SyncHook(["generator", "generatorOptions"])

),

/** @type {HookMap<SyncBailHook<[CreateData, ResolveData], Module | void>>} */

createModuleClass: new HookMap(

() => new SyncBailHook(["createData", "resolveData"])

)

});

/** @type {ResolverFactory} */

this.resolverFactory = resolverFactory;

/** @type {RuleSet} */

this.ruleSet = ruleSetCompiler.compile([

{

rules: /** @type {RuleSetRules} */ (options.defaultRules)

},

{

rules: /** @type {RuleSetRules} */ (options.rules)

}

]);

/** @type {string} */

this.context = context || "";

/** @type {InputFileSystem} */

this.fs = fs;

this._globalParserOptions = options.parser;

this._globalGeneratorOptions = options.generator;

/** @type {Map<string, WeakMap<ParserOptions, Parser>>} */

this.parserCache = new Map();

/** @type {Map<string, WeakMap<GeneratorOptions, Generator>>} */

this.generatorCache = new Map();

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

this._restoredUnsafeCacheEntries = new Set();

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

this._loaderResolveCache = new Map();

/** @type {(resource: string) => import("./util/identifier").ParsedResource} */

const cacheParseResource = parseResource.bindCache(

associatedObjectForCache

);

const cachedParseResourceWithoutFragment =

parseResourceWithoutFragment.bindCache(associatedObjectForCache);

this._parseResourceWithoutFragment = cachedParseResourceWithoutFragment;

this.hooks.factorize.tapAsync(

{

name: "NormalModuleFactory",

stage: 100

},

(resolveData, callback) => {

this.hooks.resolve.callAsync(resolveData, (err, result) => {

if (err) return callback(err);

// Ignored

if (result === false) return callback();

// direct module

if (result instanceof Module) return callback(null, result);

if (typeof result === "object") {

throw new Error(

`${deprecationChangedHookMessage(

"resolve",

this.hooks.resolve

)} Returning a Module object will result in this module used as result.`

);

}

this.hooks.afterResolve.callAsync(resolveData, (err, result) => {

if (err) return callback(err);

if (typeof result === "object") {

throw new Error(

deprecationChangedHookMessage(

"afterResolve",

this.hooks.afterResolve

)

);

}

// Ignored

if (result === false) return callback();

const createData =

/** @type {CreateData} */

(resolveData.createData);

this.hooks.createModule.callAsync(

createData,

resolveData,

(err, createdModule) => {

if (!createdModule) {

if (!resolveData.request) {

return callback(new Error("Empty dependency (no request)"));

}

// TODO webpack 6 make it required and move javascript/wasm/asset properties to own module

createdModule = this.hooks.createModuleClass

.for(createData.settings.type)

.call(createData, resolveData);

if (!createdModule) {

createdModule = /** @type {Module} */ (

new NormalModule(createData)

);

}

}

createdModule = this.hooks.module.call(

createdModule,

createData,

resolveData

);

return callback(null, createdModule);

}

);

});

});

}

);

this.hooks.resolve.tapAsync(

{

name: "NormalModuleFactory",

stage: 100

},

(data, callback) => {

const {

contextInfo,

context,

dependencies,

dependencyType,

request,

phase,

attributes,

resolveOptions,

fileDependencies,

missingDependencies,

contextDependencies

} = data;

const loaderResolver = this.getResolver("loader");

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

let matchResourceData;

/** @type {string} */

let unresolvedResource;

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

let elements;

let noPreAutoLoaders = false;

let noAutoLoaders = false;

let noPrePostAutoLoaders = false;

const contextScheme = getScheme(context);

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

let scheme = getScheme(request);

if (!scheme) {

/** @type {string} */

let requestWithoutMatchResource = request;

const matchResourceMatch = MATCH_RESOURCE_REGEX.exec(request);

if (matchResourceMatch) {

let matchResource = matchResourceMatch[1];

// Check if matchResource starts with ./ or ../

if (matchResource.charCodeAt(0) === 46) {

// 46 is "."

const secondChar = matchResource.charCodeAt(1);

if (

secondChar === 47 || // 47 is "/"

(secondChar === 46 && matchResource.charCodeAt(2) === 47) // "../"

) {

// Resolve relative path against context

matchResource = join(this.fs, context, matchResource);

}

}

matchResourceData = {

...cacheParseResource(matchResource),

resource: matchResource

};

requestWithoutMatchResource = request.slice(

matchResourceMatch[0].length

);

}

scheme = getScheme(requestWithoutMatchResource);

if (!scheme && !contextScheme) {

const firstChar = requestWithoutMatchResource.charCodeAt(0);

const secondChar = requestWithoutMatchResource.charCodeAt(1);

noPreAutoLoaders = firstChar === 45 && secondChar === 33; // startsWith "-!"

noAutoLoaders = noPreAutoLoaders || firstChar === 33; // startsWith "!"

noPrePostAutoLoaders = firstChar === 33 && secondChar === 33; // startsWith "!!";

const rawElements = requestWithoutMatchResource

.slice(

noPreAutoLoaders || noPrePostAutoLoaders

? 2

: noAutoLoaders

? 1

: 0

)

.split(/!+/);

unresolvedResource = /** @type {string} */ (rawElements.pop());

elements = rawElements.map((el) => {

const { path, query } = cachedParseResourceWithoutFragment(el);

return {

loader: path,

options: query ? query.slice(1) : undefined

};

});

scheme = getScheme(unresolvedResource);

} else {

unresolvedResource = requestWithoutMatchResource;

elements = EMPTY_ELEMENTS;

}

} else {

unresolvedResource = request;

elements = EMPTY_ELEMENTS;

}

/** @type {ResolveContext} */

const resolveContext = {

fileDependencies,

missingDependencies,

contextDependencies

};

/** @type {ResourceDataWithData} */

let resourceData;

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

let loaders;

const continueCallback = needCalls(2, (err) => {

if (err) return callback(err);

// translate option idents

try {

for (const item of /** @type {LoaderItem[]} */ (loaders)) {

if (typeof item.options === "string" && item.options[0] === "?") {

const ident = item.options.slice(1);

if (ident === "[[missing ident]]") {

throw new Error(

"No ident is provided by referenced loader. " +

"When using a function for Rule.use in config you need to " +

"provide an 'ident' property for referenced loader options."

);

}

item.options = this.ruleSet.references.get(ident);

if (item.options === undefined) {

throw new Error(

"Invalid ident is provided by referenced loader"

);

}

item.ident = ident;

}

}

} catch (identErr) {

return callback(/** @type {Error} */ (identErr));

}

if (!resourceData) {

// ignored

return callback(null, dependencies[0].createIgnoredModule(context));

}

const userRequest =

(matchResourceData !== undefined

? `${matchResourceData.resource}!=!`

: "") +

stringifyLoadersAndResource(

/** @type {LoaderItem[]} */ (loaders),

resourceData.resource

);

/** @type {ModuleSettings} */

const settings = {};

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

const useLoadersPost = [];

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

const useLoaders = [];

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

const useLoadersPre = [];

// handle .webpack[] suffix

/** @type {string} */

let resource;

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

let match;

if (

matchResourceData &&

typeof (resource = matchResourceData.resource) === "string" &&

(match = /\.webpack\[([^\]]+)\]$/.exec(resource))

) {

settings.type = match[1];

matchResourceData.resource = matchResourceData.resource.slice(

0,

-settings.type.length - 10

);

} else {

settings.type = JAVASCRIPT_MODULE_TYPE_AUTO;

const resourceDataForRules = matchResourceData || resourceData;

const result = this.ruleSet.exec({

resource: resourceDataForRules.path,

realResource: resourceData.path,

resourceQuery: resourceDataForRules.query,

resourceFragment: resourceDataForRules.fragment,

scheme,

phase,

attributes,

mimetype: matchResourceData

? ""

: resourceData.data.mimetype || "",

dependency: dependencyType,

descriptionData: matchResourceData

? undefined

: resourceData.data.descriptionFileData,

issuer: contextInfo.issuer,

compiler: contextInfo.compiler,

issuerLayer: contextInfo.issuerLayer || ""

});

for (const r of result) {

// https://github.com/webpack/webpack/issues/16466

// if a request exists PrePostAutoLoaders, should disable modifying Rule.type

if (r.type === "type" && noPrePostAutoLoaders) {

continue;

}

if (r.type === "use") {

if (!noAutoLoaders && !noPrePostAutoLoaders) {

useLoaders.push(r.value);

}

} else if (r.type === "use-post") {

if (!noPrePostAutoLoaders) {

useLoadersPost.push(r.value);

}

} else if (r.type === "use-pre") {

if (!noPreAutoLoaders && !noPrePostAutoLoaders) {

useLoadersPre.push(r.value);

}

} else if (

typeof r.value === "object" &&

r.value !== null &&

typeof settings[

/** @type {keyof ModuleSettings} */

(r.type)

] === "object" &&

settings[/** @type {keyof ModuleSettings} */ (r.type)] !== null

) {

const type = /** @type {keyof ModuleSettings} */ (r.type);

settings[type] = cachedCleverMerge(settings[type], r.value);

} else {

const type = /** @type {keyof ModuleSettings} */ (r.type);

settings[type] = r.value;

}

}

}

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

let postLoaders;

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

let normalLoaders;

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

let preLoaders;

const continueCallback = needCalls(3, (err) => {

if (err) {

return callback(err);

}

const allLoaders = /** @type {LoaderItem[]} */ (postLoaders);

if (matchResourceData === undefined) {

for (const loader of /** @type {LoaderItem[]} */ (loaders)) {

allLoaders.push(loader);

}

for (const loader of /** @type {LoaderItem[]} */ (

normalLoaders

)) {

allLoaders.push(loader);

}

} else {

for (const loader of /** @type {LoaderItem[]} */ (

normalLoaders

)) {

allLoaders.push(loader);

}

for (const loader of /** @type {LoaderItem[]} */ (loaders)) {

allLoaders.push(loader);

}

}

for (const loader of /** @type {LoaderItem[]} */ (preLoaders)) {

allLoaders.push(loader);

}

const type = /** @type {NormalModuleTypes} */ (settings.type);

const resolveOptions = settings.resolve;

const layer = settings.layer;

try {

Object.assign(data.createData, {

layer:

layer === undefined ? contextInfo.issuerLayer || null : layer,

request: stringifyLoadersAndResource(

allLoaders,

resourceData.resource

),

userRequest,

rawRequest: request,

loaders: allLoaders,

resource: resourceData.resource,

context:

resourceData.context || getContext(resourceData.resource),

matchResource: matchResourceData

? matchResourceData.resource

: undefined,

resourceResolveData: resourceData.data,

settings,

type,

parser: this.getParser(type, settings.parser),

parserOptions: settings.parser,

generator: this.getGenerator(type, settings.generator),

generatorOptions: settings.generator,

resolveOptions,

extractSourceMap: settings.extractSourceMap || false

});

} catch (createDataErr) {

return callback(/** @type {Error} */ (createDataErr));

}

callback();

});

this.resolveRequestArray(

contextInfo,

this.context,

useLoadersPost,

loaderResolver,

resolveContext,

(err, result) => {

postLoaders = result;

continueCallback(err);

}

);

this.resolveRequestArray(

contextInfo,

this.context,

useLoaders,

loaderResolver,

resolveContext,

(err, result) => {

normalLoaders = result;

continueCallback(err);

}

);

this.resolveRequestArray(

contextInfo,

this.context,

useLoadersPre,

loaderResolver,

resolveContext,

(err, result) => {

preLoaders = result;

continueCallback(err);

}

);

});

this.resolveRequestArray(

contextInfo,

contextScheme ? this.context : context,

/** @type {LoaderItem[]} */ (elements),

loaderResolver,

resolveContext,

(err, result) => {

if (err) return continueCallback(err);

loaders = result;

continueCallback();

}

);

/**

* Processes the provided string.

* @param {string} context context

*/

const defaultResolve = (context) => {

if (/^(?:$|\?)/.test(unresolvedResource)) {

resourceData = {

...cacheParseResource(unresolvedResource),

resource: unresolvedResource,

data: {}

};

continueCallback();

}

// resource without scheme and with path

else {

const normalResolver = this.getResolver(

"normal",

dependencyType

? cachedSetProperty(

resolveOptions || EMPTY_RESOLVE_OPTIONS,

"dependencyType",

dependencyType

)

: resolveOptions

);

this.resolveResource(

contextInfo,

context,

escapeHashInPathRequest(unresolvedResource),

normalResolver,

resolveContext,

(err, _resolvedResource, resolvedResourceResolveData) => {

if (err) return continueCallback(err);

if (_resolvedResource !== false) {

const resolvedResource =

/** @type {string} */

(_resolvedResource);

resourceData = {

...cacheParseResource(resolvedResource),

resource: resolvedResource,

data:

/** @type {ResolveRequest} */

(resolvedResourceResolveData)

};

}

continueCallback();

}

);

}

};

// resource with scheme

if (scheme) {

resourceData = {

resource: unresolvedResource,

data: {},

path: undefined,

query: undefined,

fragment: undefined,

context: undefined

};

this.hooks.resolveForScheme

.for(scheme)

.callAsync(resourceData, data, (err) => {

if (err) return continueCallback(err);

continueCallback();