/*

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

Author Tobias Koppers @sokra

*/

"use strict";

const util = require("util");

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

const {

AsyncParallelHook,

AsyncSeriesBailHook,

AsyncSeriesHook,

HookMap,

SyncBailHook,

SyncHook,

SyncWaterfallHook

} = require("tapable");

const { CachedSource } = require("webpack-sources");

const { MultiItemCache } = require("./CacheFacade");

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

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

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

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

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

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

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

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

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

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

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

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

const {

connectChunkGroupAndChunk,

connectChunkGroupParentAndChild,

connectEntrypointAndDependOn

} = require("./GraphHelpers");

const {

makeWebpackError,

tryRunOrWebpackError

} = require("./HookWebpackError");

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

const { LogType, Logger } = require("./logging/Logger");

const StatsFactory = require("./stats/StatsFactory");

const StatsPrinter = require("./stats/StatsPrinter");

const { equals: arrayEquals } = require("./util/ArrayHelpers");

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

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

const { getOrInsert } = require("./util/MapHelpers");

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

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

const {

compareIds,

compareLocations,

compareModulesByIdentifier,

compareSelect,

compareStringsNumeric,

concatComparators

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

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

const {

arrayToSetDeprecation,

createFakeHook,

soonFrozenObjectDeprecation

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

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

const { getRuntimeKey } = require("./util/runtime");

const { isSourceEqual } = require("./util/source");

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

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

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

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

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

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

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

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

/** @typedef {import("./config/defaults").OutputNormalizedWithDefaults} OutputOptionsWithDefaults */

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

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

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

/** @typedef {import("./Chunk").ChunkName} ChunkName */

/** @typedef {import("./Chunk").ChunkId} ChunkId */

/** @typedef {import("./ChunkGroup").ChunkGroupOptions} ChunkGroupOptions */

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

/** @typedef {import("./Compiler").CompilationParams} CompilationParams */

/** @typedef {import("./Compiler").MemCache} MemCache */

/** @typedef {import("./Compiler").WeakReferences} WeakReferences */

/** @typedef {import("./Compiler").ModuleMemCachesItem} ModuleMemCachesItem */

/** @typedef {import("./Compiler").Records} Records */

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

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

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

/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */

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

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

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

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

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

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

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

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

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

/** @typedef {import("./ChunkGraph").ModuleId} ModuleId */

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

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

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

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

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

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

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

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

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

/** @typedef {import("./Template").RenderManifestEntry} RenderManifestEntry */

/** @typedef {import("./Template").RenderManifestOptions} RenderManifestOptions */

/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsAsset} StatsAsset */

/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsError} StatsError */

/** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModule} StatsModule */

/** @typedef {import("./TemplatedPathPlugin").TemplatePath} TemplatePath */

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

/**

* @template T

* @typedef {import("tapable").AsArray<T>} AsArray<T>

*/

/**

* @template T

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

*/

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

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

/**

* @callback Callback

* @param {(WebpackError | null)=} err

* @returns {void}

*/

/**

* @callback ModuleCallback

* @param {WebpackError | null=} err

* @param {Module | null=} result

* @returns {void}

*/

/**

* @callback ModuleFactoryResultCallback

* @param {WebpackError | null=} err

* @param {ModuleFactoryResult | null=} result

* @returns {void}

*/

/**

* @callback ModuleOrModuleFactoryResultCallback

* @param {WebpackError | null=} err

* @param {Module | ModuleFactoryResult | null=} result

* @returns {void}

*/

/**

* @callback ExecuteModuleCallback

* @param {WebpackError | null=} err

* @param {ExecuteModuleResult | null=} result

* @returns {void}

*/

/** @typedef {new (...args: EXPECTED_ANY[]) => Dependency} DependencyConstructor */

/** @typedef {Record<string, Source>} CompilationAssets */

/**

* @typedef {object} AvailableModulesChunkGroupMapping

* @property {ChunkGroup} chunkGroup

* @property {Set<Module>} availableModules

* @property {boolean} needCopy

*/

/**

* @typedef {object} DependenciesBlockLike

* @property {Dependency[]} dependencies

* @property {AsyncDependenciesBlock[]} blocks

*/

/** @typedef {Set<Chunk>} Chunks */

/**

* @typedef {object} ChunkPathData

* @property {string | number} id

* @property {string=} name

* @property {string} hash

* @property {HashWithLengthFunction=} hashWithLength

* @property {(Record<string, string>)=} contentHash

* @property {(Record<string, HashWithLengthFunction>)=} contentHashWithLength

*/

/**

* @typedef {object} ChunkHashContext

* @property {CodeGenerationResults} codeGenerationResults results of code generation

* @property {RuntimeTemplate} runtimeTemplate the runtime template

* @property {ModuleGraph} moduleGraph the module graph

* @property {ChunkGraph} chunkGraph the chunk graph

*/

/**

* @typedef {object} RuntimeRequirementsContext

* @property {ChunkGraph} chunkGraph the chunk graph

* @property {CodeGenerationResults} codeGenerationResults the code generation results

*/

/**

* @typedef {object} ExecuteModuleOptions

* @property {EntryOptions=} entryOptions

*/

/** @typedef {LazySet<string>} FileSystemDependencies */

/** @typedef {EXPECTED_ANY} ExecuteModuleExports */

/**

* @typedef {object} ExecuteModuleResult

* @property {ExecuteModuleExports} exports

* @property {boolean} cacheable

* @property {ExecuteModuleAssets} assets

* @property {FileSystemDependencies} fileDependencies

* @property {FileSystemDependencies} contextDependencies

* @property {FileSystemDependencies} missingDependencies

* @property {FileSystemDependencies} buildDependencies

*/

/**

* @typedef {object} ExecuteModuleObject

* @property {string=} id module id

* @property {ExecuteModuleExports} exports exports

* @property {boolean} loaded is loaded

* @property {Error=} error error

*/

/**

* @typedef {object} ExecuteModuleArgument

* @property {Module} module

* @property {ExecuteModuleObject=} moduleObject

* @property {CodeGenerationResult} codeGenerationResult

*/

/** @typedef {((id: string) => ExecuteModuleExports) & { i?: ((options: ExecuteOptions) => void)[], c?: Record<string, ExecuteModuleObject> }} WebpackRequire */

/**

* @typedef {object} ExecuteOptions

* @property {string=} id module id

* @property {ExecuteModuleObject} module module

* @property {WebpackRequire} require require function

*/

/** @typedef {Map<string, { source: Source, info: AssetInfo | undefined }>} ExecuteModuleAssets */

/**

* @typedef {object} ExecuteModuleContext

* @property {ExecuteModuleAssets} assets

* @property {Chunk} chunk

* @property {ChunkGraph} chunkGraph

* @property {WebpackRequire=} __webpack_require__

*/

/**

* @typedef {object} EntryData

* @property {Dependency[]} dependencies dependencies of the entrypoint that should be evaluated at startup

* @property {Dependency[]} includeDependencies dependencies of the entrypoint that should be included but not evaluated

* @property {EntryOptions} options options of the entrypoint

*/

/**

* @typedef {object} LogEntry

* @property {keyof LogType} type

* @property {EXPECTED_ANY[]=} args

* @property {number} time

* @property {string[]=} trace

*/

/**

* @typedef {object} KnownAssetInfo

* @property {boolean=} immutable true, if the asset can be long term cached forever (contains a hash)

* @property {boolean=} minimized whether the asset is minimized

* @property {string | string[]=} fullhash the value(s) of the full hash used for this asset

* @property {string | string[]=} chunkhash the value(s) of the chunk hash used for this asset

* @property {string | string[]=} modulehash the value(s) of the module hash used for this asset

* @property {string | string[]=} contenthash the value(s) of the content hash used for this asset

* @property {string=} sourceFilename when asset was created from a source file (potentially transformed), the original filename relative to compilation context

* @property {number=} size size in bytes, only set after asset has been emitted

* @property {boolean=} development true, when asset is only used for development and doesn't count towards user-facing assets

* @property {boolean=} hotModuleReplacement true, when asset ships data for updating an existing application (HMR)

* @property {boolean=} javascriptModule true, when asset is javascript and an ESM

* @property {boolean=} manifest true, when file is a manifest

* @property {Record<string, null | string | string[]>=} related object of pointers to other assets, keyed by type of relation (only points from parent to child)

*/

/** @typedef {KnownAssetInfo & Record<string, EXPECTED_ANY>} AssetInfo */

/** @typedef {{ path: string, info: AssetInfo }} InterpolatedPathAndAssetInfo */

/**

* @typedef {object} Asset

* @property {string} name the filename of the asset

* @property {Source} source source of the asset

* @property {AssetInfo} info info about the asset

*/

/** @typedef {(length: number) => string} HashWithLengthFunction */

/**

* @typedef {object} ModulePathData

* @property {string | number} id

* @property {string} hash

* @property {HashWithLengthFunction=} hashWithLength

*/

/** @typedef {(id: string | number) => string | number} PrepareIdFunction */

/**

* @typedef {object} PathData

* @property {ChunkGraph=} chunkGraph

* @property {string=} hash

* @property {HashWithLengthFunction=} hashWithLength

* @property {(Chunk | ChunkPathData)=} chunk

* @property {(Module | ModulePathData)=} module

* @property {RuntimeSpec=} runtime

* @property {string=} filename

* @property {string=} basename

* @property {string=} query

* @property {string=} contentHashType

* @property {string=} contentHash

* @property {HashWithLengthFunction=} contentHashWithLength

* @property {boolean=} noChunkHash

* @property {string=} url

* @property {PrepareIdFunction=} prepareId

*/

/** @typedef {"module" | "chunk" | "root-of-chunk" | "nested"} ExcludeModulesType */

/**

* @typedef {object} KnownNormalizedStatsOptions

* @property {string} context

* @property {RequestShortener} requestShortener

* @property {string | false} chunksSort

* @property {string | false} modulesSort

* @property {string | false} chunkModulesSort

* @property {string | false} nestedModulesSort

* @property {string | false} assetsSort

* @property {boolean} ids

* @property {boolean} cachedAssets

* @property {boolean} groupAssetsByEmitStatus

* @property {boolean} groupAssetsByPath

* @property {boolean} groupAssetsByExtension

* @property {number} assetsSpace

* @property {((value: string, asset: StatsAsset) => boolean)[]} excludeAssets

* @property {((name: string, module: StatsModule, type: ExcludeModulesType) => boolean)[]} excludeModules

* @property {((warning: StatsError, textValue: string) => boolean)[]} warningsFilter

* @property {boolean} cachedModules

* @property {boolean} orphanModules

* @property {boolean} dependentModules

* @property {boolean} runtimeModules

* @property {boolean} groupModulesByCacheStatus

* @property {boolean} groupModulesByLayer

* @property {boolean} groupModulesByAttributes

* @property {boolean} groupModulesByPath

* @property {boolean} groupModulesByExtension

* @property {boolean} groupModulesByType

* @property {boolean | "auto"} entrypoints

* @property {boolean} chunkGroups

* @property {boolean} chunkGroupAuxiliary

* @property {boolean} chunkGroupChildren

* @property {number} chunkGroupMaxAssets

* @property {number} modulesSpace

* @property {number} chunkModulesSpace

* @property {number} nestedModulesSpace

* @property {false | "none" | "error" | "warn" | "info" | "log" | "verbose"} logging

* @property {((value: string) => boolean)[]} loggingDebug

* @property {boolean} loggingTrace

* @property {EXPECTED_ANY} _env

*/

/** @typedef {KnownNormalizedStatsOptions & Omit<StatsOptions, keyof KnownNormalizedStatsOptions> & Record<string, EXPECTED_ANY>} NormalizedStatsOptions */

/**

* @typedef {object} KnownCreateStatsOptionsContext

* @property {boolean=} forToString

*/

/** @typedef {KnownCreateStatsOptionsContext & Record<string, EXPECTED_ANY>} CreateStatsOptionsContext */

/** @typedef {{ module: Module, hash: string, runtime: RuntimeSpec, runtimes: RuntimeSpec[] }} CodeGenerationJob */

/** @typedef {CodeGenerationJob[]} CodeGenerationJobs */

/** @typedef {{ javascript: ModuleTemplate }} ModuleTemplates */

/** @typedef {Set<Module>} NotCodeGeneratedModules */

/** @type {AssetInfo} */

const EMPTY_ASSET_INFO = Object.freeze({});

const esmDependencyCategory = "esm";

// TODO webpack 6: remove

const deprecatedNormalModuleLoaderHook = util.deprecate(

/**

* @param {Compilation} compilation compilation

* @returns {NormalModuleCompilationHooks["loader"]} hooks

*/

(compilation) =>

require("./NormalModule").getCompilationHooks(compilation).loader,

"Compilation.hooks.normalModuleLoader was moved to NormalModule.getCompilationHooks(compilation).loader",

"DEP_WEBPACK_COMPILATION_NORMAL_MODULE_LOADER_HOOK"

);

// TODO webpack 6: remove

/**

* @param {ModuleTemplates | undefined} moduleTemplates module templates

*/

const defineRemovedModuleTemplates = (moduleTemplates) => {

Object.defineProperties(moduleTemplates, {

asset: {

enumerable: false,

configurable: false,

get: () => {

throw new WebpackError(

"Compilation.moduleTemplates.asset has been removed"

);

}

},

webassembly: {

enumerable: false,

configurable: false,

get: () => {

throw new WebpackError(

"Compilation.moduleTemplates.webassembly has been removed"

);

}

}

});

moduleTemplates = undefined;

};

const byId = compareSelect((c) => c.id, compareIds);

const byNameOrHash = concatComparators(

compareSelect((c) => c.name, compareIds),

compareSelect((c) => c.fullHash, compareIds)

);

const byMessage = compareSelect(

(err) => `${err.message}`,

compareStringsNumeric

);

const byModule = compareSelect(

(err) => (err.module && err.module.identifier()) || "",

compareStringsNumeric

);

const byLocation = compareSelect((err) => err.loc, compareLocations);

const compareErrors = concatComparators(byModule, byLocation, byMessage);

/**

* @typedef {object} KnownUnsafeCacheData

* @property {FactoryMeta=} factoryMeta factory meta

* @property {ResolveOptions=} resolveOptions resolve options

* @property {ParserOptions=} parserOptions

* @property {GeneratorOptions=} generatorOptions

*/

/** @typedef {KnownUnsafeCacheData & Record<string, EXPECTED_ANY>} UnsafeCacheData */

/**

* @typedef {Module & { restoreFromUnsafeCache?: (unsafeCacheData: UnsafeCacheData, moduleFactory: ModuleFactory, compilationParams: CompilationParams) => void }} ModuleWithRestoreFromUnsafeCache

*/

/** @typedef {(module: Module) => boolean} UnsafeCachePredicate */

/** @type {WeakMap<Dependency, ModuleWithRestoreFromUnsafeCache | null>} */

const unsafeCacheDependencies = new WeakMap();

/** @type {WeakMap<ModuleWithRestoreFromUnsafeCache, UnsafeCacheData>} */

const unsafeCacheData = new WeakMap();

/** @typedef {{ id: ModuleId, modules?: Map<Module, ModuleId>, blocks?: (ChunkId | null)[] }} References */

/** @typedef {Map<Module, WeakTupleMap<EXPECTED_ANY[], EXPECTED_ANY>>} ModuleMemCaches */

class Compilation {

/**

* Creates an instance of Compilation.

* @param {Compiler} compiler the compiler which created the compilation

* @param {CompilationParams} params the compilation parameters

*/

constructor(compiler, params) {

this._backCompat = compiler._backCompat;

const getNormalModuleLoader = () => deprecatedNormalModuleLoaderHook(this);

/** @typedef {{ additionalAssets?: boolean | ((assets: CompilationAssets) => void) }} ProcessAssetsAdditionalOptions */

/** @type {AsyncSeriesHook<[CompilationAssets], ProcessAssetsAdditionalOptions>} */

const processAssetsHook = new AsyncSeriesHook(["assets"]);

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

let savedAssets = new Set();

/**

* @param {CompilationAssets} assets assets

* @returns {CompilationAssets} new assets

*/

const popNewAssets = (assets) => {

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

let newAssets;

for (const file of Object.keys(assets)) {

if (savedAssets.has(file)) continue;

if (newAssets === undefined) {

newAssets = Object.create(null);

}

/** @type {CompilationAssets} */

(newAssets)[file] = assets[file];

savedAssets.add(file);

}

return /** @type {CompilationAssets} */ (newAssets);

};

processAssetsHook.intercept({

name: "Compilation",

call: () => {

savedAssets = new Set(Object.keys(this.assets));

},

register: (tap) => {

const { type, name } = tap;

const { fn, additionalAssets, ...remainingTap } = tap;

const additionalAssetsFn =

additionalAssets === true ? fn : additionalAssets;

/** @typedef {WeakSet<CompilationAssets>} ProcessedAssets */

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

const processedAssets = additionalAssetsFn ? new WeakSet() : undefined;

/**

* @param {CompilationAssets} assets to be processed by additionalAssetsFn

* @returns {CompilationAssets} available assets

*/

const getAvailableAssets = (assets) => {

/** @type {CompilationAssets} */

const availableAssets = {};

for (const file of Object.keys(assets)) {

// https://github.com/webpack-contrib/compression-webpack-plugin/issues/390

if (this.assets[file]) {

availableAssets[file] = assets[file];

}

}

return availableAssets;

};

switch (type) {

case "sync":

if (additionalAssetsFn) {

this.hooks.processAdditionalAssets.tap(name, (assets) => {

if (

/** @type {ProcessedAssets} */

(processedAssets).has(this.assets)

) {

additionalAssetsFn(getAvailableAssets(assets));

}

});

}

return {

...remainingTap,

type: "async",

/**

* @param {CompilationAssets} assets assets

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

* @returns {void}

*/

fn: (assets, callback) => {

try {

fn(assets);

} catch (err) {

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

}

if (processedAssets !== undefined) {

processedAssets.add(this.assets);

}

const newAssets = popNewAssets(assets);

if (newAssets !== undefined) {

this.hooks.processAdditionalAssets.callAsync(

newAssets,

callback

);

return;

}

callback();

}

};

case "async":

if (additionalAssetsFn) {

this.hooks.processAdditionalAssets.tapAsync(

name,

(assets, callback) => {

if (

/** @type {ProcessedAssets} */

(processedAssets).has(this.assets)

) {

return additionalAssetsFn(

getAvailableAssets(assets),

callback

);

}

callback();

}

);

}

return {

...remainingTap,

/**

* @param {CompilationAssets} assets assets

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

* @returns {void}

*/

fn: (assets, callback) => {

fn(

assets,

/**

* @param {Error} err err

* @returns {void}

*/

(err) => {

if (err) return callback(err);

if (processedAssets !== undefined) {

processedAssets.add(this.assets);

}

const newAssets = popNewAssets(assets);

if (newAssets !== undefined) {

this.hooks.processAdditionalAssets.callAsync(

newAssets,

callback

);

return;

}

callback();

}

);

}

};

case "promise":

if (additionalAssetsFn) {

this.hooks.processAdditionalAssets.tapPromise(name, (assets) => {

if (

/** @type {ProcessedAssets} */

(processedAssets).has(this.assets)

) {

return additionalAssetsFn(getAvailableAssets(assets));

}

return Promise.resolve();

});

}

return {

...remainingTap,

/**

* @param {CompilationAssets} assets assets

* @returns {Promise<CompilationAssets>} result

*/

fn: (assets) => {

const p = fn(assets);

if (!p || !p.then) return p;

return p.then(() => {

if (processedAssets !== undefined) {

processedAssets.add(this.assets);

}

const newAssets = popNewAssets(assets);

if (newAssets !== undefined) {

return this.hooks.processAdditionalAssets.promise(

newAssets

);

}

});

}

};

}

}

});

/** @type {SyncHook<[CompilationAssets]>} */

const afterProcessAssetsHook = new SyncHook(["assets"]);

/**

* @template T

* @param {string} name name of the hook

* @param {number} stage new stage

* @param {() => AsArray<T>} getArgs get old hook function args

* @param {string=} code deprecation code (not deprecated when unset)

* @returns {FakeHook<Pick<AsyncSeriesHook<T>, "tap" | "tapAsync" | "tapPromise" | "name">> | undefined} fake hook which redirects

*/

const createProcessAssetsHook = (name, stage, getArgs, code) => {

if (!this._backCompat && code) return;

/**

* @param {string} reason reason

* @returns {string} error message

*/

const errorMessage = (

reason

) => `Can't automatically convert plugin using Compilation.hooks.${name} to Compilation.hooks.processAssets because ${reason}.

BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a single Compilation.hooks.processAssets hook.`;

/**

* @param {string | (import("tapable").TapOptions & { name: string } & ProcessAssetsAdditionalOptions)} options hook options

* @returns {import("tapable").TapOptions & { name: string } & ProcessAssetsAdditionalOptions} modified options

*/

const getOptions = (options) => {

if (typeof options === "string") options = { name: options };

if (options.stage) {

throw new Error(errorMessage("it's using the 'stage' option"));

}

return { ...options, stage };

};

return createFakeHook(

{

name,

/** @type {AsyncSeriesHook<T>["intercept"]} */

intercept(_interceptor) {

throw new Error(errorMessage("it's using 'intercept'"));

},

/** @type {AsyncSeriesHook<T>["tap"]} */

tap: (options, fn) => {

processAssetsHook.tap(getOptions(options), () => fn(...getArgs()));

},

/** @type {AsyncSeriesHook<T>["tapAsync"]} */

tapAsync: (options, fn) => {

processAssetsHook.tapAsync(

getOptions(options),

(assets, callback) =>

/** @type {EXPECTED_ANY} */ (fn)(...getArgs(), callback)

);

},

/** @type {AsyncSeriesHook<T>["tapPromise"]} */

tapPromise: (options, fn) => {

processAssetsHook.tapPromise(getOptions(options), () =>

fn(...getArgs())

);

}

},

`${name} is deprecated (use Compilation.hooks.processAssets instead and use one of Compilation.PROCESS_ASSETS_STAGE_* as stage option)`,

code

);

};

this.hooks = Object.freeze({

/** @type {SyncHook<[Module]>} */

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

/** @type {SyncHook<[Module]>} */

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

/** @type {SyncHook<[Module, WebpackError]>} */

failedModule: new SyncHook(["module", "error"]),

/** @type {SyncHook<[Module]>} */

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

/** @type {SyncHook<[Module]>} */

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

/** @type {SyncHook<[Dependency, EntryOptions]>} */

addEntry: new SyncHook(["entry", "options"]),

/** @type {SyncHook<[Dependency, EntryOptions, Error]>} */

failedEntry: new SyncHook(["entry", "options", "error"]),

/** @type {SyncHook<[Dependency, EntryOptions, Module]>} */

succeedEntry: new SyncHook(["entry", "options", "module"]),

/** @type {SyncWaterfallHook<[ReferencedExports, Dependency, RuntimeSpec]>} */

dependencyReferencedExports: new SyncWaterfallHook([

"referencedExports",

"dependency",

"runtime"

]),

/** @type {SyncHook<[ExecuteModuleArgument, ExecuteModuleContext]>} */

executeModule: new SyncHook(["options", "context"]),

/** @type {AsyncParallelHook<[ExecuteModuleArgument, ExecuteModuleContext]>} */

prepareModuleExecution: new AsyncParallelHook(["options", "context"]),

/** @type {AsyncSeriesHook<[Iterable<Module>]>} */

finishModules: new AsyncSeriesHook(["modules"]),

/** @type {AsyncSeriesHook<[Module]>} */

finishRebuildingModule: new AsyncSeriesHook(["module"]),

/** @type {SyncHook<[]>} */

unseal: new SyncHook([]),

/** @type {SyncHook<[]>} */

seal: new SyncHook([]),

/** @type {SyncHook<[]>} */

beforeChunks: new SyncHook([]),

/**

* The `afterChunks` hook is called directly after the chunks and module graph have

* been created and before the chunks and modules have been optimized. This hook is useful to

* inspect, analyze, and/or modify the chunk graph.

* @type {SyncHook<[Iterable<Chunk>]>}

*/

afterChunks: new SyncHook(["chunks"]),

/** @type {SyncBailHook<[Iterable<Module>], boolean | void>} */

optimizeDependencies: new SyncBailHook(["modules"]),

/** @type {SyncHook<[Iterable<Module>]>} */

afterOptimizeDependencies: new SyncHook(["modules"]),

/** @type {SyncHook<[]>} */

optimize: new SyncHook([]),

/** @type {SyncBailHook<[Iterable<Module>], boolean | void>} */

optimizeModules: new SyncBailHook(["modules"]),

/** @type {SyncHook<[Iterable<Module>]>} */

afterOptimizeModules: new SyncHook(["modules"]),

/** @type {SyncBailHook<[Iterable<Chunk>, ChunkGroup[]], boolean | void>} */

optimizeChunks: new SyncBailHook(["chunks", "chunkGroups"]),

/** @type {SyncHook<[Iterable<Chunk>, ChunkGroup[]]>} */

afterOptimizeChunks: new SyncHook(["chunks", "chunkGroups"]),

/** @type {AsyncSeriesHook<[Iterable<Chunk>, Iterable<Module>]>} */

optimizeTree: new AsyncSeriesHook(["chunks", "modules"]),

/** @type {SyncHook<[Iterable<Chunk>, Iterable<Module>]>} */

afterOptimizeTree: new SyncHook(["chunks", "modules"]),

/** @type {AsyncSeriesBailHook<[Iterable<Chunk>, Iterable<Module>], void>} */

optimizeChunkModules: new AsyncSeriesBailHook(["chunks", "modules"]),

/** @type {SyncHook<[Iterable<Chunk>, Iterable<Module>]>} */

afterOptimizeChunkModules: new SyncHook(["chunks", "modules"]),

/** @type {SyncBailHook<[], boolean | void>} */

shouldRecord: new SyncBailHook([]),

/** @type {SyncHook<[Chunk, RuntimeRequirements, RuntimeRequirementsContext]>} */

additionalChunkRuntimeRequirements: new SyncHook([

"chunk",

"runtimeRequirements",

"context"

]),

/** @type {HookMap<SyncBailHook<[Chunk, RuntimeRequirements, RuntimeRequirementsContext], void>>} */

runtimeRequirementInChunk: new HookMap(

() => new SyncBailHook(["chunk", "runtimeRequirements", "context"])

),

/** @type {SyncHook<[Module, RuntimeRequirements, RuntimeRequirementsContext]>} */

additionalModuleRuntimeRequirements: new SyncHook([

"module",

"runtimeRequirements",

"context"

]),

/** @type {HookMap<SyncBailHook<[Module, RuntimeRequirements, RuntimeRequirementsContext], void>>} */

runtimeRequirementInModule: new HookMap(

() => new SyncBailHook(["module", "runtimeRequirements", "context"])

),

/** @type {SyncHook<[Chunk, RuntimeRequirements, RuntimeRequirementsContext]>} */

additionalTreeRuntimeRequirements: new SyncHook([

"chunk",

"runtimeRequirements",

"context"

]),

/** @type {HookMap<SyncBailHook<[Chunk, RuntimeRequirements, RuntimeRequirementsContext], void>>} */

runtimeRequirementInTree: new HookMap(

() => new SyncBailHook(["chunk", "runtimeRequirements", "context"])

),

/** @type {SyncHook<[RuntimeModule, Chunk]>} */

runtimeModule: new SyncHook(["module", "chunk"]),

/** @type {SyncHook<[Iterable<Module>, Records]>} */

reviveModules: new SyncHook(["modules", "records"]),

/** @type {SyncHook<[Iterable<Module>]>} */

beforeModuleIds: new SyncHook(["modules"]),

/** @type {SyncHook<[Iterable<Module>]>} */

moduleIds: new SyncHook(["modules"]),

/** @type {SyncHook<[Iterable<Module>]>} */

optimizeModuleIds: new SyncHook(["modules"]),

/** @type {SyncHook<[Iterable<Module>]>} */

afterOptimizeModuleIds: new SyncHook(["modules"]),

/** @type {SyncHook<[Iterable<Chunk>, Records]>} */

reviveChunks: new SyncHook(["chunks", "records"]),

/** @type {SyncHook<[Iterable<Chunk>]>} */

beforeChunkIds: new SyncHook(["chunks"]),

/** @type {SyncHook<[Iterable<Chunk>]>} */

chunkIds: new SyncHook(["chunks"]),

/** @type {SyncHook<[Iterable<Chunk>]>} */

optimizeChunkIds: new SyncHook(["chunks"]),

/** @type {SyncHook<[Iterable<Chunk>]>} */

afterOptimizeChunkIds: new SyncHook(["chunks"]),

/** @type {SyncHook<[Iterable<Module>, Records]>} */

recordModules: new SyncHook(["modules", "records"]),

/** @type {SyncHook<[Iterable<Chunk>, Records]>} */

recordChunks: new SyncHook(["chunks", "records"]),

/** @type {SyncHook<[Iterable<Module>]>} */

optimizeCodeGeneration: new SyncHook(["modules"]),

/** @type {SyncHook<[]>} */

beforeModuleHash: new SyncHook([]),

/** @type {SyncHook<[]>} */

afterModuleHash: new SyncHook([]),

/** @type {SyncHook<[]>} */

beforeCodeGeneration: new SyncHook([]),

/** @type {SyncHook<[]>} */

afterCodeGeneration: new SyncHook([]),

/** @type {SyncHook<[]>} */

beforeRuntimeRequirements: new SyncHook([]),

/** @type {SyncHook<[]>} */

afterRuntimeRequirements: new SyncHook([]),

/** @type {SyncHook<[]>} */

beforeHash: new SyncHook([]),

/** @type {SyncHook<[Chunk]>} */

contentHash: new SyncHook(["chunk"]),

/** @type {SyncHook<[]>} */

afterHash: new SyncHook([]),

/** @type {SyncHook<[Records]>} */

recordHash: new SyncHook(["records"]),

/** @type {SyncHook<[Compilation, Records]>} */

record: new SyncHook(["compilation", "records"]),

/** @type {SyncHook<[]>} */

beforeModuleAssets: new SyncHook([]),

/** @type {SyncBailHook<[], boolean | void>} */

shouldGenerateChunkAssets: new SyncBailHook([]),

/** @type {SyncHook<[]>} */

beforeChunkAssets: new SyncHook([]),

// TODO webpack 6 remove

/** @deprecated */

additionalChunkAssets:

/** @type {FakeHook<Pick<AsyncSeriesHook<[Chunks]>, "tap" | "tapAsync" | "tapPromise" | "name">>} */

(

createProcessAssetsHook(

"additionalChunkAssets",

Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL,

() => [this.chunks],

"DEP_WEBPACK_COMPILATION_ADDITIONAL_CHUNK_ASSETS"

)

),

// TODO webpack 6 deprecate

/** @deprecated */

additionalAssets:

/** @type {FakeHook<Pick<AsyncSeriesHook<[]>, "tap" | "tapAsync" | "tapPromise" | "name">>} */

(

createProcessAssetsHook(

"additionalAssets",

Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL,

() => []

)

),

// TODO webpack 6 remove

/** @deprecated */

optimizeChunkAssets:

/** @type {FakeHook<Pick<AsyncSeriesHook<[Chunks]>, "tap" | "tapAsync" | "tapPromise" | "name">>} */

(

createProcessAssetsHook(

"optimizeChunkAssets",

Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE,

() => [this.chunks],

"DEP_WEBPACK_COMPILATION_OPTIMIZE_CHUNK_ASSETS"

)

),

// TODO webpack 6 remove

/** @deprecated */

afterOptimizeChunkAssets:

/** @type {FakeHook<Pick<AsyncSeriesHook<[Chunks]>, "tap" | "tapAsync" | "tapPromise" | "name">>} */

(

createProcessAssetsHook(

"afterOptimizeChunkAssets",

Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE + 1,

() => [this.chunks],

"DEP_WEBPACK_COMPILATION_AFTER_OPTIMIZE_CHUNK_ASSETS"

)

),

// TODO webpack 6 deprecate

/** @deprecated */

optimizeAssets: processAssetsHook,

// TODO webpack 6 deprecate

/** @deprecated */

afterOptimizeAssets: afterProcessAssetsHook,

processAssets: processAssetsHook,

afterProcessAssets: afterProcessAssetsHook,

/** @type {AsyncSeriesHook<[CompilationAssets]>} */

processAdditionalAssets: new AsyncSeriesHook(["assets"]),

/** @type {SyncBailHook<[], boolean | void>} */

needAdditionalSeal: new SyncBailHook([]),

/** @type {AsyncSeriesHook<[]>} */

afterSeal: new AsyncSeriesHook([]),

/** @type {SyncWaterfallHook<[RenderManifestEntry[], RenderManifestOptions]>} */