summaryrefslogtreecommitdiff
path: root/node_modules/webpack/lib/Compilation.js
diff options
context:
space:
mode:
authorlittleblack111 <littleblack11111@gmail.com>2023-11-05 17:16:09 +0800
committerlittleblack111 <littleblack11111@gmail.com>2023-11-05 17:16:09 +0800
commitd1d9f00b1bd660842addf5e6b1d1b64c852a9eea (patch)
tree60fb37ae73a1109d95301de5ec9b61b5726a4b61 /node_modules/webpack/lib/Compilation.js
parent7c85166c4cbdd862fc4252007d2df5befcbc2a58 (diff)
added hover prefixer
Diffstat (limited to 'node_modules/webpack/lib/Compilation.js')
-rw-r--r--node_modules/webpack/lib/Compilation.js5310
1 files changed, 5310 insertions, 0 deletions
diff --git a/node_modules/webpack/lib/Compilation.js b/node_modules/webpack/lib/Compilation.js
new file mode 100644
index 00000000..a8801957
--- /dev/null
+++ b/node_modules/webpack/lib/Compilation.js
@@ -0,0 +1,5310 @@
+/*
+ MIT License http://www.opensource.org/licenses/mit-license.php
+ Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const asyncLib = require("neo-async");
+const {
+ HookMap,
+ SyncHook,
+ SyncBailHook,
+ SyncWaterfallHook,
+ AsyncSeriesHook,
+ AsyncSeriesBailHook,
+ AsyncParallelHook
+} = require("tapable");
+const util = require("util");
+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
+} = 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 { Logger, LogType } = 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 {
+ compareLocations,
+ concatComparators,
+ compareSelect,
+ compareIds,
+ compareStringsNumeric,
+ compareModulesByIdentifier
+} = require("./util/comparators");
+const createHash = require("./util/createHash");
+const {
+ arrayToSetDeprecation,
+ soonFrozenObjectDeprecation,
+ createFakeHook
+} = require("./util/deprecation");
+const processAsyncTree = require("./util/processAsyncTree");
+const { getRuntimeKey } = require("./util/runtime");
+const { isSourceEqual } = require("./util/source");
+
+/** @template T @typedef {import("tapable").AsArray<T>} AsArray<T> */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescription */
+/** @typedef {import("../declarations/WebpackOptions").OutputNormalized} OutputOptions */
+/** @typedef {import("../declarations/WebpackOptions").StatsOptions} StatsOptions */
+/** @typedef {import("../declarations/WebpackOptions").WebpackPluginFunction} WebpackPluginFunction */
+/** @typedef {import("../declarations/WebpackOptions").WebpackPluginInstance} WebpackPluginInstance */
+/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
+/** @typedef {import("./Cache")} Cache */
+/** @typedef {import("./CacheFacade")} CacheFacade */
+/** @typedef {import("./ChunkGroup").ChunkGroupOptions} ChunkGroupOptions */
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Compiler").CompilationParams} CompilationParams */
+/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("./Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("./DependencyTemplate")} DependencyTemplate */
+/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
+/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("./ModuleFactory")} ModuleFactory */
+/** @typedef {import("./ModuleFactory").ModuleFactoryCreateDataContextInfo} ModuleFactoryCreateDataContextInfo */
+/** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
+/** @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("./util/Hash")} Hash */
+/** @template T @typedef {import("./util/deprecation").FakeHook<T>} FakeHook<T> */
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+
+/**
+ * @callback Callback
+ * @param {(WebpackError | null)=} err
+ * @returns {void}
+ */
+
+/**
+ * @callback ModuleCallback
+ * @param {(WebpackError | null)=} err
+ * @param {Module=} result
+ * @returns {void}
+ */
+
+/**
+ * @callback ModuleFactoryResultCallback
+ * @param {(WebpackError | null)=} err
+ * @param {ModuleFactoryResult=} result
+ * @returns {void}
+ */
+
+/**
+ * @callback ModuleOrFactoryResultCallback
+ * @param {(WebpackError | null)=} err
+ * @param {Module | ModuleFactoryResult=} result
+ * @returns {void}
+ */
+
+/**
+ * @callback ExecuteModuleCallback
+ * @param {(WebpackError | null)=} err
+ * @param {ExecuteModuleResult=} result
+ * @returns {void}
+ */
+
+/**
+ * @callback DepBlockVarDependenciesCallback
+ * @param {Dependency} dependency
+ * @returns {any}
+ */
+
+/** @typedef {new (...args: any[]) => Dependency} DepConstructor */
+/** @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 {Object} ChunkPathData
+ * @property {string|number} id
+ * @property {string=} name
+ * @property {string} hash
+ * @property {function(number): string=} hashWithLength
+ * @property {(Record<string, string>)=} contentHash
+ * @property {(Record<string, (length: number) => string>)=} 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 {Object} ExecuteModuleResult
+ * @property {any} exports
+ * @property {boolean} cacheable
+ * @property {Map<string, { source: Source, info: AssetInfo }>} assets
+ * @property {LazySet<string>} fileDependencies
+ * @property {LazySet<string>} contextDependencies
+ * @property {LazySet<string>} missingDependencies
+ * @property {LazySet<string>} buildDependencies
+ */
+
+/**
+ * @typedef {Object} ExecuteModuleArgument
+ * @property {Module} module
+ * @property {{ id: string, exports: any, loaded: boolean }=} moduleObject
+ * @property {any} preparedInfo
+ * @property {CodeGenerationResult} codeGenerationResult
+ */
+
+/**
+ * @typedef {Object} ExecuteModuleContext
+ * @property {Map<string, { source: Source, info: AssetInfo }>} assets
+ * @property {Chunk} chunk
+ * @property {ChunkGraph} chunkGraph
+ * @property {function(string): any=} __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 {string} type
+ * @property {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 {Record<string, string | string[]>=} related object of pointers to other assets, keyed by type of relation (only points from parent to child)
+ */
+
+/** @typedef {KnownAssetInfo & Record<string, any>} AssetInfo */
+
+/**
+ * @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 {Object} ModulePathData
+ * @property {string|number} id
+ * @property {string} hash
+ * @property {function(number): string=} hashWithLength
+ */
+
+/**
+ * @typedef {Object} PathData
+ * @property {ChunkGraph=} chunkGraph
+ * @property {string=} hash
+ * @property {function(number): string=} 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 {function(number): string=} contentHashWithLength
+ * @property {boolean=} noChunkHash
+ * @property {string=} url
+ */
+
+/**
+ * @typedef {Object} KnownNormalizedStatsOptions
+ * @property {string} context
+ * @property {RequestShortener} requestShortener
+ * @property {string} chunksSort
+ * @property {string} modulesSort
+ * @property {string} chunkModulesSort
+ * @property {string} nestedModulesSort
+ * @property {string} 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: "module" | "chunk" | "root-of-chunk" | "nested") => 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 {any} _env
+ */
+
+/** @typedef {KnownNormalizedStatsOptions & Omit<StatsOptions, keyof KnownNormalizedStatsOptions> & Record<string, any>} NormalizedStatsOptions */
+
+/**
+ * @typedef {Object} KnownCreateStatsOptionsContext
+ * @property {boolean=} forToString
+ */
+
+/** @typedef {KnownCreateStatsOptionsContext & Record<string, any>} CreateStatsOptionsContext */
+
+/** @type {AssetInfo} */
+const EMPTY_ASSET_INFO = Object.freeze({});
+
+const esmDependencyCategory = "esm";
+// TODO webpack 6: remove
+const deprecatedNormalModuleLoaderHook = util.deprecate(
+ compilation => {
+ return 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
+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(
+ /**
+ * @param {Chunk} c chunk
+ * @returns {number | string} id
+ */ c => c.id,
+ compareIds
+);
+
+const byNameOrHash = concatComparators(
+ compareSelect(
+ /**
+ * @param {Compilation} c compilation
+ * @returns {string} name
+ */
+ c => c.name,
+ compareIds
+ ),
+ compareSelect(
+ /**
+ * @param {Compilation} c compilation
+ * @returns {string} hash
+ */ 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);
+
+/** @type {WeakMap<Dependency, Module & { restoreFromUnsafeCache: Function } | null>} */
+const unsafeCacheDependencies = new WeakMap();
+
+/** @type {WeakMap<Module & { restoreFromUnsafeCache: Function }, object>} */
+const unsafeCacheData = new WeakMap();
+
+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?: true | Function }} ProcessAssetsAdditionalOptions */
+ /** @type {AsyncSeriesHook<[CompilationAssets], ProcessAssetsAdditionalOptions>} */
+ const processAssetsHook = new AsyncSeriesHook(["assets"]);
+
+ let savedAssets = new Set();
+ const popNewAssets = assets => {
+ let newAssets = undefined;
+ for (const file of Object.keys(assets)) {
+ if (savedAssets.has(file)) continue;
+ if (newAssets === undefined) {
+ newAssets = Object.create(null);
+ }
+ newAssets[file] = assets[file];
+ savedAssets.add(file);
+ }
+ return 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;
+ const processedAssets = additionalAssetsFn ? new WeakSet() : undefined;
+ switch (type) {
+ case "sync":
+ if (additionalAssetsFn) {
+ this.hooks.processAdditionalAssets.tap(name, assets => {
+ if (processedAssets.has(this.assets))
+ additionalAssetsFn(assets);
+ });
+ }
+ return {
+ ...remainingTap,
+ type: "async",
+ fn: (assets, callback) => {
+ try {
+ fn(assets);
+ } catch (e) {
+ return callback(e);
+ }
+ 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 (processedAssets.has(this.assets))
+ return additionalAssetsFn(assets, callback);
+ callback();
+ }
+ );
+ }
+ return {
+ ...remainingTap,
+ fn: (assets, callback) => {
+ fn(assets, 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 (processedAssets.has(this.assets))
+ return additionalAssetsFn(assets);
+ return Promise.resolve();
+ });
+ }
+ return {
+ ...remainingTap,
+ 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 {function(): 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">>} fake hook which redirects
+ */
+ const createProcessAssetsHook = (name, stage, getArgs, code) => {
+ if (!this._backCompat && code) return undefined;
+ 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.`;
+ 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: 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 {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<[(string[] | ReferencedExport)[], 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>]>} */
+ optimizeDependencies: new SyncBailHook(["modules"]),
+ /** @type {SyncHook<[Iterable<Module>]>} */
+ afterOptimizeDependencies: new SyncHook(["modules"]),
+
+ /** @type {SyncHook<[]>} */
+ optimize: new SyncHook([]),
+ /** @type {SyncBailHook<[Iterable<Module>]>} */
+ optimizeModules: new SyncBailHook(["modules"]),
+ /** @type {SyncHook<[Iterable<Module>]>} */
+ afterOptimizeModules: new SyncHook(["modules"]),
+
+ /** @type {SyncBailHook<[Iterable<Chunk>, ChunkGroup[]]>} */
+ 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>]>} */
+ optimizeChunkModules: new AsyncSeriesBailHook(["chunks", "modules"]),
+ /** @type {SyncHook<[Iterable<Chunk>, Iterable<Module>]>} */
+ afterOptimizeChunkModules: new SyncHook(["chunks", "modules"]),
+ /** @type {SyncBailHook<[], boolean | undefined>} */
+ shouldRecord: new SyncBailHook([]),
+
+ /** @type {SyncHook<[Chunk, Set<string>, RuntimeRequirementsContext]>} */
+ additionalChunkRuntimeRequirements: new SyncHook([
+ "chunk",
+ "runtimeRequirements",
+ "context"
+ ]),
+ /** @type {HookMap<SyncBailHook<[Chunk, Set<string>, RuntimeRequirementsContext]>>} */
+ runtimeRequirementInChunk: new HookMap(
+ () => new SyncBailHook(["chunk", "runtimeRequirements", "context"])
+ ),
+ /** @type {SyncHook<[Module, Set<string>, RuntimeRequirementsContext]>} */
+ additionalModuleRuntimeRequirements: new SyncHook([
+ "module",
+ "runtimeRequirements",
+ "context"
+ ]),
+ /** @type {HookMap<SyncBailHook<[Module, Set<string>, RuntimeRequirementsContext]>>} */
+ runtimeRequirementInModule: new HookMap(
+ () => new SyncBailHook(["module", "runtimeRequirements", "context"])
+ ),
+ /** @type {SyncHook<[Chunk, Set<string>, RuntimeRequirementsContext]>} */
+ additionalTreeRuntimeRequirements: new SyncHook([
+ "chunk",
+ "runtimeRequirements",
+ "context"
+ ]),
+ /** @type {HookMap<SyncBailHook<[Chunk, Set<string>, RuntimeRequirementsContext]>>} */
+ runtimeRequirementInTree: new HookMap(
+ () => new SyncBailHook(["chunk", "runtimeRequirements", "context"])
+ ),
+
+ /** @type {SyncHook<[RuntimeModule, Chunk]>} */
+ runtimeModule: new SyncHook(["module", "chunk"]),
+
+ /** @type {SyncHook<[Iterable<Module>, any]>} */
+ 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>, any]>} */
+ 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>, any]>} */
+ recordModules: new SyncHook(["modules", "records"]),
+ /** @type {SyncHook<[Iterable<Chunk>, any]>} */
+ 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<[any]>} */
+ recordHash: new SyncHook(["records"]),
+ /** @type {SyncHook<[Compilation, any]>} */
+ record: new SyncHook(["compilation", "records"]),
+
+ /** @type {SyncHook<[]>} */
+ beforeModuleAssets: new SyncHook([]),
+ /** @type {SyncBailHook<[], boolean>} */
+ shouldGenerateChunkAssets: new SyncBailHook([]),
+ /** @type {SyncHook<[]>} */
+ beforeChunkAssets: new SyncHook([]),
+ // TODO webpack 6 remove
+ /** @deprecated */
+ additionalChunkAssets: createProcessAssetsHook(
+ "additionalChunkAssets",
+ Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL,
+ () => [this.chunks],
+ "DEP_WEBPACK_COMPILATION_ADDITIONAL_CHUNK_ASSETS"
+ ),
+
+ // TODO webpack 6 deprecate
+ /** @deprecated */
+ additionalAssets: createProcessAssetsHook(
+ "additionalAssets",
+ Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL,
+ () => []
+ ),
+ // TODO webpack 6 remove
+ /** @deprecated */
+ optimizeChunkAssets: createProcessAssetsHook(
+ "optimizeChunkAssets",
+ Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE,
+ () => [this.chunks],
+ "DEP_WEBPACK_COMPILATION_OPTIMIZE_CHUNK_ASSETS"
+ ),
+ // TODO webpack 6 remove
+ /** @deprecated */
+ afterOptimizeChunkAssets: 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>} */
+ needAdditionalSeal: new SyncBailHook([]),
+ /** @type {AsyncSeriesHook<[]>} */
+ afterSeal: new AsyncSeriesHook([]),
+
+ /** @type {SyncWaterfallHook<[RenderManifestEntry[], RenderManifestOptions]>} */
+ renderManifest: new SyncWaterfallHook(["result", "options"]),
+
+ /** @type {SyncHook<[Hash]>} */
+ fullHash: new SyncHook(["hash"]),
+ /** @type {SyncHook<[Chunk, Hash, ChunkHashContext]>} */
+ chunkHash: new SyncHook(["chunk", "chunkHash", "ChunkHashContext"]),
+
+ /** @type {SyncHook<[Module, string]>} */
+ moduleAsset: new SyncHook(["module", "filename"]),
+ /** @type {SyncHook<[Chunk, string]>} */
+ chunkAsset: new SyncHook(["chunk", "filename"]),
+
+ /** @type {SyncWaterfallHook<[string, object, AssetInfo]>} */
+ assetPath: new SyncWaterfallHook(["path", "options", "assetInfo"]),
+
+ /** @type {SyncBailHook<[], boolean>} */
+ needAdditionalPass: new SyncBailHook([]),
+
+ /** @type {SyncHook<[Compiler, string, number]>} */
+ childCompiler: new SyncHook([
+ "childCompiler",
+ "compilerName",
+ "compilerIndex"
+ ]),
+
+ /** @type {SyncBailHook<[string, LogEntry], true>} */
+ log: new SyncBailHook(["origin", "logEntry"]),
+
+ /** @type {SyncWaterfallHook<[WebpackError[]]>} */
+ processWarnings: new SyncWaterfallHook(["warnings"]),
+ /** @type {SyncWaterfallHook<[WebpackError[]]>} */
+ processErrors: new SyncWaterfallHook(["errors"]),
+
+ /** @type {HookMap<SyncHook<[Partial<NormalizedStatsOptions>, CreateStatsOptionsContext]>>} */
+ statsPreset: new HookMap(() => new SyncHook(["options", "context"])),
+ /** @type {SyncHook<[Partial<NormalizedStatsOptions>, CreateStatsOptionsContext]>} */
+ statsNormalize: new SyncHook(["options", "context"]),
+ /** @type {SyncHook<[StatsFactory, NormalizedStatsOptions]>} */
+ statsFactory: new SyncHook(["statsFactory", "options"]),
+ /** @type {SyncHook<[StatsPrinter, NormalizedStatsOptions]>} */
+ statsPrinter: new SyncHook(["statsPrinter", "options"]),
+
+ get normalModuleLoader() {
+ return getNormalModuleLoader();
+ }
+ });
+ /** @type {string=} */
+ this.name = undefined;
+ this.startTime = undefined;
+ this.endTime = undefined;
+ /** @type {Compiler} */
+ this.compiler = compiler;
+ this.resolverFactory = compiler.resolverFactory;
+ this.inputFileSystem = compiler.inputFileSystem;
+ this.fileSystemInfo = new FileSystemInfo(this.inputFileSystem, {
+ managedPaths: compiler.managedPaths,
+ immutablePaths: compiler.immutablePaths,
+ logger: this.getLogger("webpack.FileSystemInfo"),
+ hashFunction: compiler.options.output.hashFunction
+ });
+ if (compiler.fileTimestamps) {
+ this.fileSystemInfo.addFileTimestamps(compiler.fileTimestamps, true);
+ }
+ if (compiler.contextTimestamps) {
+ this.fileSystemInfo.addContextTimestamps(
+ compiler.contextTimestamps,
+ true
+ );
+ }
+ /** @type {Map<string, string | Set<string>>} */
+ this.valueCacheVersions = new Map();
+ this.requestShortener = compiler.requestShortener;
+ this.compilerPath = compiler.compilerPath;
+
+ this.logger = this.getLogger("webpack.Compilation");
+
+ const options = compiler.options;
+ this.options = options;
+ this.outputOptions = options && options.output;
+ /** @type {boolean} */
+ this.bail = (options && options.bail) || false;
+ /** @type {boolean} */
+ this.profile = (options && options.profile) || false;
+
+ this.params = params;
+ this.mainTemplate = new MainTemplate(this.outputOptions, this);
+ this.chunkTemplate = new ChunkTemplate(this.outputOptions, this);
+ this.runtimeTemplate = new RuntimeTemplate(
+ this,
+ this.outputOptions,
+ this.requestShortener
+ );
+ /** @type {{javascript: ModuleTemplate}} */
+ this.moduleTemplates = {
+ javascript: new ModuleTemplate(this.runtimeTemplate, this)
+ };
+ defineRemovedModuleTemplates(this.moduleTemplates);
+
+ /** @type {Map<Module, WeakTupleMap<any, any>> | undefined} */
+ this.moduleMemCaches = undefined;
+ /** @type {Map<Module, WeakTupleMap<any, any>> | undefined} */
+ this.moduleMemCaches2 = undefined;
+ this.moduleGraph = new ModuleGraph();
+ /** @type {ChunkGraph} */
+ this.chunkGraph = undefined;
+ /** @type {CodeGenerationResults} */
+ this.codeGenerationResults = undefined;
+
+ /** @type {AsyncQueue<Module, Module, Module>} */
+ this.processDependenciesQueue = new AsyncQueue({
+ name: "processDependencies",
+ parallelism: options.parallelism || 100,
+ processor: this._processModuleDependencies.bind(this)
+ });
+ /** @type {AsyncQueue<Module, string, Module>} */
+ this.addModuleQueue = new AsyncQueue({
+ name: "addModule",
+ parent: this.processDependenciesQueue,
+ getKey: module => module.identifier(),
+ processor: this._addModule.bind(this)
+ });
+ /** @type {AsyncQueue<FactorizeModuleOptions, string, Module | ModuleFactoryResult>} */
+ this.factorizeQueue = new AsyncQueue({
+ name: "factorize",
+ parent: this.addModuleQueue,
+ processor: this._factorizeModule.bind(this)
+ });
+ /** @type {AsyncQueue<Module, Module, Module>} */
+ this.buildQueue = new AsyncQueue({
+ name: "build",
+ parent: this.factorizeQueue,
+ processor: this._buildModule.bind(this)
+ });
+ /** @type {AsyncQueue<Module, Module, Module>} */
+ this.rebuildQueue = new AsyncQueue({
+ name: "rebuild",
+ parallelism: options.parallelism || 100,
+ processor: this._rebuildModule.bind(this)
+ });
+
+ /**
+ * Modules in value are building during the build of Module in key.
+ * Means value blocking key from finishing.
+ * Needed to detect build cycles.
+ * @type {WeakMap<Module, Set<Module>>}
+ */
+ this.creatingModuleDuringBuild = new WeakMap();
+
+ /** @type {Map<string, EntryData>} */
+ this.entries = new Map();
+ /** @type {EntryData} */
+ this.globalEntry = {
+ dependencies: [],
+ includeDependencies: [],
+ options: {
+ name: undefined
+ }
+ };
+ /** @type {Map<string, Entrypoint>} */
+ this.entrypoints = new Map();
+ /** @type {Entrypoint[]} */
+ this.asyncEntrypoints = [];
+ /** @type {Set<Chunk>} */
+ this.chunks = new Set();
+ /** @type {ChunkGroup[]} */
+ this.chunkGroups = [];
+ /** @type {Map<string, ChunkGroup>} */
+ this.namedChunkGroups = new Map();
+ /** @type {Map<string, Chunk>} */
+ this.namedChunks = new Map();
+ /** @type {Set<Module>} */
+ this.modules = new Set();
+ if (this._backCompat) {
+ arrayToSetDeprecation(this.chunks, "Compilation.chunks");
+ arrayToSetDeprecation(this.modules, "Compilation.modules");
+ }
+ /** @private @type {Map<string, Module>} */
+ this._modules = new Map();
+ this.records = null;
+ /** @type {string[]} */
+ this.additionalChunkAssets = [];
+ /** @type {CompilationAssets} */
+ this.assets = {};
+ /** @type {Map<string, AssetInfo>} */
+ this.assetsInfo = new Map();
+ /** @type {Map<string, Map<string, Set<string>>>} */
+ this._assetsRelatedIn = new Map();
+ /** @type {WebpackError[]} */
+ this.errors = [];
+ /** @type {WebpackError[]} */
+ this.warnings = [];
+ /** @type {Compilation[]} */
+ this.children = [];
+ /** @type {Map<string, LogEntry[]>} */
+ this.logging = new Map();
+ /** @type {Map<DepConstructor, ModuleFactory>} */
+ this.dependencyFactories = new Map();
+ /** @type {DependencyTemplates} */
+ this.dependencyTemplates = new DependencyTemplates(
+ this.outputOptions.hashFunction
+ );
+ this.childrenCounters = {};
+ /** @type {Set<number|string>} */
+ this.usedChunkIds = null;
+ /** @type {Set<number>} */
+ this.usedModuleIds = null;
+ /** @type {boolean} */
+ this.needAdditionalPass = false;
+ /** @type {Set<Module & { restoreFromUnsafeCache: Function }>} */
+ this._restoredUnsafeCacheModuleEntries = new Set();
+ /** @type {Map<string, Module & { restoreFromUnsafeCache: Function }>} */
+ this._restoredUnsafeCacheEntries = new Map();
+ /** @type {WeakSet<Module>} */
+ this.builtModules = new WeakSet();
+ /** @type {WeakSet<Module>} */
+ this.codeGeneratedModules = new WeakSet();
+ /** @type {WeakSet<Module>} */
+ this.buildTimeExecutedModules = new WeakSet();
+ /** @private @type {Map<Module, Callback[]>} */
+ this._rebuildingModules = new Map();
+ /** @type {Set<string>} */
+ this.emittedAssets = new Set();
+ /** @type {Set<string>} */
+ this.comparedForEmitAssets = new Set();
+ /** @type {LazySet<string>} */
+ this.fileDependencies = new LazySet();
+ /** @type {LazySet<string>} */
+ this.contextDependencies = new LazySet();
+ /** @type {LazySet<string>} */
+ this.missingDependencies = new LazySet();
+ /** @type {LazySet<string>} */
+ this.buildDependencies = new LazySet();
+ // TODO webpack 6 remove
+ this.compilationDependencies = {
+ add: util.deprecate(
+ item => this.fileDependencies.add(item),
+ "Compilation.compilationDependencies is deprecated (used Compilation.fileDependencies instead)",
+ "DEP_WEBPACK_COMPILATION_COMPILATION_DEPENDENCIES"
+ )
+ };
+
+ this._modulesCache = this.getCache("Compilation/modules");
+ this._assetsCache = this.getCache("Compilation/assets");
+ this._codeGenerationCache = this.getCache("Compilation/codeGeneration");
+
+ const unsafeCache = options.module.unsafeCache;
+ this._unsafeCache = !!unsafeCache;
+ this._unsafeCachePredicate =
+ typeof unsafeCache === "function" ? unsafeCache : () => true;
+ }
+
+ getStats() {
+ return new Stats(this);
+ }
+
+ /**
+ * @param {StatsOptions | string} optionsOrPreset stats option value
+ * @param {CreateStatsOptionsContext} context context
+ * @returns {NormalizedStatsOptions} normalized options
+ */
+ createStatsOptions(optionsOrPreset, context = {}) {
+ if (
+ typeof optionsOrPreset === "boolean" ||
+ typeof optionsOrPreset === "string"
+ ) {
+ optionsOrPreset = { preset: optionsOrPreset };
+ }
+ if (typeof optionsOrPreset === "object" && optionsOrPreset !== null) {
+ // We use this method of shallow cloning this object to include
+ // properties in the prototype chain
+ /** @type {Partial<NormalizedStatsOptions>} */
+ const options = {};
+ for (const key in optionsOrPreset) {
+ options[key] = optionsOrPreset[key];
+ }
+ if (options.preset !== undefined) {
+ this.hooks.statsPreset.for(options.preset).call(options, context);
+ }
+ this.hooks.statsNormalize.call(options, context);
+ return /** @type {NormalizedStatsOptions} */ (options);
+ } else {
+ /** @type {Partial<NormalizedStatsOptions>} */
+ const options = {};
+ this.hooks.statsNormalize.call(options, context);
+ return /** @type {NormalizedStatsOptions} */ (options);
+ }
+ }
+
+ createStatsFactory(options) {
+ const statsFactory = new StatsFactory();
+ this.hooks.statsFactory.call(statsFactory, options);
+ return statsFactory;
+ }
+
+ createStatsPrinter(options) {
+ const statsPrinter = new StatsPrinter();
+ this.hooks.statsPrinter.call(statsPrinter, options);
+ return statsPrinter;
+ }
+
+ /**
+ * @param {string} name cache name
+ * @returns {CacheFacade} the cache facade instance
+ */
+ getCache(name) {
+ return this.compiler.getCache(name);
+ }
+
+ /**
+ * @param {string | (function(): string)} name name of the logger, or function called once to get the logger name
+ * @returns {Logger} a logger with that name
+ */
+ getLogger(name) {
+ if (!name) {
+ throw new TypeError("Compilation.getLogger(name) called without a name");
+ }
+ /** @type {LogEntry[] | undefined} */
+ let logEntries;
+ return new Logger(
+ (type, args) => {
+ if (typeof name === "function") {
+ name = name();
+ if (!name) {
+ throw new TypeError(
+ "Compilation.getLogger(name) called with a function not returning a name"
+ );
+ }
+ }
+ let trace;
+ switch (type) {
+ case LogType.warn:
+ case LogType.error:
+ case LogType.trace:
+ trace = ErrorHelpers.cutOffLoaderExecution(new Error("Trace").stack)
+ .split("\n")
+ .slice(3);
+ break;
+ }
+ /** @type {LogEntry} */
+ const logEntry = {
+ time: Date.now(),
+ type,
+ args,
+ trace
+ };
+ if (this.hooks.log.call(name, logEntry) === undefined) {
+ if (logEntry.type === LogType.profileEnd) {
+ // eslint-disable-next-line node/no-unsupported-features/node-builtins
+ if (typeof console.profileEnd === "function") {
+ // eslint-disable-next-line node/no-unsupported-features/node-builtins
+ console.profileEnd(`[${name}] ${logEntry.args[0]}`);
+ }
+ }
+ if (logEntries === undefined) {
+ logEntries = this.logging.get(name);
+ if (logEntries === undefined) {
+ logEntries = [];
+ this.logging.set(name, logEntries);
+ }
+ }
+ logEntries.push(logEntry);
+ if (logEntry.type === LogType.profile) {
+ // eslint-disable-next-line node/no-unsupported-features/node-builtins
+ if (typeof console.profile === "function") {
+ // eslint-disable-next-line node/no-unsupported-features/node-builtins
+ console.profile(`[${name}] ${logEntry.args[0]}`);
+ }
+ }
+ }
+ },
+ childName => {
+ if (typeof name === "function") {
+ if (typeof childName === "function") {
+ return this.getLogger(() => {
+ if (typeof name === "function") {
+ name = name();
+ if (!name) {
+ throw new TypeError(
+ "Compilation.getLogger(name) called with a function not returning a name"
+ );
+ }
+ }
+ if (typeof childName === "function") {
+ childName = childName();
+ if (!childName) {
+ throw new TypeError(
+ "Logger.getChildLogger(name) called with a function not returning a name"
+ );
+ }
+ }
+ return `${name}/${childName}`;
+ });
+ } else {
+ return this.getLogger(() => {
+ if (typeof name === "function") {
+ name = name();
+ if (!name) {
+ throw new TypeError(
+ "Compilation.getLogger(name) called with a function not returning a name"
+ );
+ }
+ }
+ return `${name}/${childName}`;
+ });
+ }
+ } else {
+ if (typeof childName === "function") {
+ return this.getLogger(() => {
+ if (typeof childName === "function") {
+ childName = childName();
+ if (!childName) {
+ throw new TypeError(
+ "Logger.getChildLogger(name) called with a function not returning a name"
+ );
+ }
+ }
+ return `${name}/${childName}`;
+ });
+ } else {
+ return this.getLogger(`${name}/${childName}`);
+ }
+ }
+ }
+ );
+ }
+
+ /**
+ * @param {Module} module module to be added that was created
+ * @param {ModuleCallback} callback returns the module in the compilation,
+ * it could be the passed one (if new), or an already existing in the compilation
+ * @returns {void}
+ */
+ addModule(module, callback) {
+ this.addModuleQueue.add(module, callback);
+ }
+
+ /**
+ * @param {Module} module module to be added that was created
+ * @param {ModuleCallback} callback returns the module in the compilation,
+ * it could be the passed one (if new), or an already existing in the compilation
+ * @returns {void}
+ */
+ _addModule(module, callback) {
+ const identifier = module.identifier();
+ const alreadyAddedModule = this._modules.get(identifier);
+ if (alreadyAddedModule) {
+ return callback(null, alreadyAddedModule);
+ }
+
+ const currentProfile = this.profile
+ ? this.moduleGraph.getProfile(module)
+ : undefined;
+ if (currentProfile !== undefined) {
+ currentProfile.markRestoringStart();
+ }
+
+ this._modulesCache.get(identifier, null, (err, cacheModule) => {
+ if (err) return callback(new ModuleRestoreError(module, err));
+
+ if (currentProfile !== undefined) {
+ currentProfile.markRestoringEnd();
+ currentProfile.markIntegrationStart();
+ }
+
+ if (cacheModule) {
+ cacheModule.updateCacheModule(module);
+
+ module = cacheModule;
+ }
+ this._modules.set(identifier, module);
+ this.modules.add(module);
+ if (this._backCompat)
+ ModuleGraph.setModuleGraphForModule(module, this.moduleGraph);
+ if (currentProfile !== undefined) {
+ currentProfile.markIntegrationEnd();
+ }
+ callback(null, module);
+ });
+ }
+
+ /**
+ * Fetches a module from a compilation by its identifier
+ * @param {Module} module the module provided
+ * @returns {Module} the module requested
+ */
+ getModule(module) {
+ const identifier = module.identifier();
+ return this._modules.get(identifier);
+ }
+
+ /**
+ * Attempts to search for a module by its identifier
+ * @param {string} identifier identifier (usually path) for module
+ * @returns {Module|undefined} attempt to search for module and return it, else undefined
+ */
+ findModule(identifier) {
+ return this._modules.get(identifier);
+ }
+
+ /**
+ * Schedules a build of the module object
+ *
+ * @param {Module} module module to be built
+ * @param {ModuleCallback} callback the callback
+ * @returns {void}
+ */
+ buildModule(module, callback) {
+ this.buildQueue.add(module, callback);
+ }
+
+ /**
+ * Builds the module object
+ *
+ * @param {Module} module module to be built
+ * @param {ModuleCallback} callback the callback
+ * @returns {void}
+ */
+ _buildModule(module, callback) {
+ const currentProfile = this.profile
+ ? this.moduleGraph.getProfile(module)
+ : undefined;
+ if (currentProfile !== undefined) {
+ currentProfile.markBuildingStart();
+ }
+
+ module.needBuild(
+ {
+ compilation: this,
+ fileSystemInfo: this.fileSystemInfo,
+ valueCacheVersions: this.valueCacheVersions
+ },
+ (err, needBuild) => {
+ if (err) return callback(err);
+
+ if (!needBuild) {
+ if (currentProfile !== undefined) {
+ currentProfile.markBuildingEnd();
+ }
+ this.hooks.stillValidModule.call(module);
+ return callback();
+ }
+
+ this.hooks.buildModule.call(module);
+ this.builtModules.add(module);
+ module.build(
+ this.options,
+ this,
+ this.resolverFactory.get("normal", module.resolveOptions),
+ this.inputFileSystem,
+ err => {
+ if (currentProfile !== undefined) {
+ currentProfile.markBuildingEnd();
+ }
+ if (err) {
+ this.hooks.failedModule.call(module, err);
+ return callback(err);
+ }
+ if (currentProfile !== undefined) {
+ currentProfile.markStoringStart();
+ }
+ this._modulesCache.store(module.identifier(), null, module, err => {
+ if (currentProfile !== undefined) {
+ currentProfile.markStoringEnd();
+ }
+ if (err) {
+ this.hooks.failedModule.call(module, err);
+ return callback(new ModuleStoreError(module, err));
+ }
+ this.hooks.succeedModule.call(module);
+ return callback();
+ });
+ }
+ );
+ }
+ );
+ }
+
+ /**
+ * @param {Module} module to be processed for deps
+ * @param {ModuleCallback} callback callback to be triggered
+ * @returns {void}
+ */
+ processModuleDependencies(module, callback) {
+ this.processDependenciesQueue.add(module, callback);
+ }
+
+ /**
+ * @param {Module} module to be processed for deps
+ * @returns {void}
+ */
+ processModuleDependenciesNonRecursive(module) {
+ const processDependenciesBlock = block => {
+ if (block.dependencies) {
+ let i = 0;
+ for (const dep of block.dependencies) {
+ this.moduleGraph.setParents(dep, block, module, i++);
+ }
+ }
+ if (block.blocks) {
+ for (const b of block.blocks) processDependenciesBlock(b);
+ }
+ };
+
+ processDependenciesBlock(module);
+ }
+
+ /**
+ * @param {Module} module to be processed for deps
+ * @param {ModuleCallback} callback callback to be triggered
+ * @returns {void}
+ */
+ _processModuleDependencies(module, callback) {
+ /** @type {Array<{factory: ModuleFactory, dependencies: Dependency[], context: string|undefined, originModule: Module|null}>} */
+ const sortedDependencies = [];
+
+ /** @type {DependenciesBlock} */
+ let currentBlock;
+
+ /** @type {Map<ModuleFactory, Map<string, Dependency[]>>} */
+ let dependencies;
+ /** @type {DepConstructor} */
+ let factoryCacheKey;
+ /** @type {ModuleFactory} */
+ let factoryCacheKey2;
+ /** @type {Map<string, Dependency[]>} */
+ let factoryCacheValue;
+ /** @type {string} */
+ let listCacheKey1;
+ /** @type {string} */
+ let listCacheKey2;
+ /** @type {Dependency[]} */
+ let listCacheValue;
+
+ let inProgressSorting = 1;
+ let inProgressTransitive = 1;
+
+ const onDependenciesSorted = err => {
+ if (err) return callback(err);
+
+ // early exit without changing parallelism back and forth
+ if (sortedDependencies.length === 0 && inProgressTransitive === 1) {
+ return callback();
+ }
+
+ // This is nested so we need to allow one additional task
+ this.processDependenciesQueue.increaseParallelism();
+
+ for (const item of sortedDependencies) {
+ inProgressTransitive++;
+ this.handleModuleCreation(item, err => {
+ // In V8, the Error objects keep a reference to the functions on the stack. These warnings &
+ // errors are created inside closures that keep a reference to the Compilation, so errors are
+ // leaking the Compilation object.
+ if (err && this.bail) {
+ if (inProgressTransitive <= 0) return;
+ inProgressTransitive = -1;
+ // eslint-disable-next-line no-self-assign
+ err.stack = err.stack;
+ onTransitiveTasksFinished(err);
+ return;
+ }
+ if (--inProgressTransitive === 0) onTransitiveTasksFinished();
+ });
+ }
+ if (--inProgressTransitive === 0) onTransitiveTasksFinished();
+ };
+
+ const onTransitiveTasksFinished = err => {
+ if (err) return callback(err);
+ this.processDependenciesQueue.decreaseParallelism();
+
+ return callback();
+ };
+
+ /**
+ * @param {Dependency} dep dependency
+ * @param {number} index index in block
+ * @returns {void}
+ */
+ const processDependency = (dep, index) => {
+ this.moduleGraph.setParents(dep, currentBlock, module, index);
+ if (this._unsafeCache) {
+ try {
+ const unsafeCachedModule = unsafeCacheDependencies.get(dep);
+ if (unsafeCachedModule === null) return;
+ if (unsafeCachedModule !== undefined) {
+ if (
+ this._restoredUnsafeCacheModuleEntries.has(unsafeCachedModule)
+ ) {
+ this._handleExistingModuleFromUnsafeCache(
+ module,
+ dep,
+ unsafeCachedModule
+ );
+ return;
+ }
+ const identifier = unsafeCachedModule.identifier();
+ const cachedModule =
+ this._restoredUnsafeCacheEntries.get(identifier);
+ if (cachedModule !== undefined) {
+ // update unsafe cache to new module
+ unsafeCacheDependencies.set(dep, cachedModule);
+ this._handleExistingModuleFromUnsafeCache(
+ module,
+ dep,
+ cachedModule
+ );
+ return;
+ }
+ inProgressSorting++;
+ this._modulesCache.get(identifier, null, (err, cachedModule) => {
+ if (err) {
+ if (inProgressSorting <= 0) return;
+ inProgressSorting = -1;
+ onDependenciesSorted(err);
+ return;
+ }
+ try {
+ if (!this._restoredUnsafeCacheEntries.has(identifier)) {
+ const data = unsafeCacheData.get(cachedModule);
+ if (data === undefined) {
+ processDependencyForResolving(dep);
+ if (--inProgressSorting === 0) onDependenciesSorted();
+ return;
+ }
+ if (cachedModule !== unsafeCachedModule) {
+ unsafeCacheDependencies.set(dep, cachedModule);
+ }
+ cachedModule.restoreFromUnsafeCache(
+ data,
+ this.params.normalModuleFactory,
+ this.params
+ );
+ this._restoredUnsafeCacheEntries.set(
+ identifier,
+ cachedModule
+ );
+ this._restoredUnsafeCacheModuleEntries.add(cachedModule);
+ if (!this.modules.has(cachedModule)) {
+ inProgressTransitive++;
+ this._handleNewModuleFromUnsafeCache(
+ module,
+ dep,
+ cachedModule,
+ err => {
+ if (err) {
+ if (inProgressTransitive <= 0) return;
+ inProgressTransitive = -1;
+ onTransitiveTasksFinished(err);
+ }
+ if (--inProgressTransitive === 0)
+ return onTransitiveTasksFinished();
+ }
+ );
+ if (--inProgressSorting === 0) onDependenciesSorted();
+ return;
+ }
+ }
+ if (unsafeCachedModule !== cachedModule) {
+ unsafeCacheDependencies.set(dep, cachedModule);
+ }
+ this._handleExistingModuleFromUnsafeCache(
+ module,
+ dep,
+ cachedModule
+ ); // a3
+ } catch (err) {
+ if (inProgressSorting <= 0) return;
+ inProgressSorting = -1;
+ onDependenciesSorted(err);
+ return;
+ }
+ if (--inProgressSorting === 0) onDependenciesSorted();
+ });
+ return;
+ }
+ } catch (e) {
+ console.error(e);
+ }
+ }
+ processDependencyForResolving(dep);
+ };
+
+ /**
+ * @param {Dependency} dep dependency
+ * @returns {void}
+ */
+ const processDependencyForResolving = dep => {
+ const resourceIdent = dep.getResourceIdentifier();
+ if (resourceIdent !== undefined && resourceIdent !== null) {
+ const category = dep.category;
+ const constructor = /** @type {DepConstructor} */ (dep.constructor);
+ if (factoryCacheKey === constructor) {
+ // Fast path 1: same constructor as prev item
+ if (listCacheKey1 === category && listCacheKey2 === resourceIdent) {
+ // Super fast path 1: also same resource
+ listCacheValue.push(dep);
+ return;
+ }
+ } else {
+ const factory = this.dependencyFactories.get(constructor);
+ if (factory === undefined) {
+ throw new Error(
+ `No module factory available for dependency type: ${constructor.name}`
+ );
+ }
+ if (factoryCacheKey2 === factory) {
+ // Fast path 2: same factory as prev item
+ factoryCacheKey = constructor;
+ if (listCacheKey1 === category && listCacheKey2 === resourceIdent) {
+ // Super fast path 2: also same resource
+ listCacheValue.push(dep);
+ return;
+ }
+ } else {
+ // Slow path
+ if (factoryCacheKey2 !== undefined) {
+ // Archive last cache entry
+ if (dependencies === undefined) dependencies = new Map();
+ dependencies.set(factoryCacheKey2, factoryCacheValue);
+ factoryCacheValue = dependencies.get(factory);
+ if (factoryCacheValue === undefined) {
+ factoryCacheValue = new Map();
+ }
+ } else {
+ factoryCacheValue = new Map();
+ }
+ factoryCacheKey = constructor;
+ factoryCacheKey2 = factory;
+ }
+ }
+ // Here webpack is using heuristic that assumes
+ // mostly esm dependencies would be used
+ // so we don't allocate extra string for them
+ const cacheKey =
+ category === esmDependencyCategory
+ ? resourceIdent
+ : `${category}${resourceIdent}`;
+ let list = factoryCacheValue.get(cacheKey);
+ if (list === undefined) {
+ factoryCacheValue.set(cacheKey, (list = []));
+ sortedDependencies.push({
+ factory: factoryCacheKey2,
+ dependencies: list,
+ context: dep.getContext(),
+ originModule: module
+ });
+ }
+ list.push(dep);
+ listCacheKey1 = category;
+ listCacheKey2 = resourceIdent;
+ listCacheValue = list;
+ }
+ };
+
+ try {
+ /** @type {DependenciesBlock[]} */
+ const queue = [module];
+ do {
+ const block = queue.pop();
+ if (block.dependencies) {
+ currentBlock = block;
+ let i = 0;
+ for (const dep of block.dependencies) processDependency(dep, i++);
+ }
+ if (block.blocks) {
+ for (const b of block.blocks) queue.push(b);
+ }
+ } while (queue.length !== 0);
+ } catch (e) {
+ return callback(e);
+ }
+
+ if (--inProgressSorting === 0) onDependenciesSorted();
+ }
+
+ _handleNewModuleFromUnsafeCache(originModule, dependency, module, callback) {
+ const moduleGraph = this.moduleGraph;
+
+ moduleGraph.setResolvedModule(originModule, dependency, module);
+
+ moduleGraph.setIssuerIfUnset(
+ module,
+ originModule !== undefined ? originModule : null
+ );
+
+ this._modules.set(module.identifier(), module);
+ this.modules.add(module);
+ if (this._backCompat)
+ ModuleGraph.setModuleGraphForModule(module, this.moduleGraph);
+
+ this._handleModuleBuildAndDependencies(
+ originModule,
+ module,
+ true,
+ callback
+ );
+ }
+
+ _handleExistingModuleFromUnsafeCache(originModule, dependency, module) {
+ const moduleGraph = this.moduleGraph;
+
+ moduleGraph.setResolvedModule(originModule, dependency, module);
+ }
+
+ /**
+ * @typedef {Object} HandleModuleCreationOptions
+ * @property {ModuleFactory} factory
+ * @property {Dependency[]} dependencies
+ * @property {Module | null} originModule
+ * @property {Partial<ModuleFactoryCreateDataContextInfo>=} contextInfo
+ * @property {string=} context
+ * @property {boolean=} recursive recurse into dependencies of the created module
+ * @property {boolean=} connectOrigin connect the resolved module with the origin module
+ */
+
+ /**
+ * @param {HandleModuleCreationOptions} options options object
+ * @param {ModuleCallback} callback callback
+ * @returns {void}
+ */
+ handleModuleCreation(
+ {
+ factory,
+ dependencies,
+ originModule,
+ contextInfo,
+ context,
+ recursive = true,
+ connectOrigin = recursive
+ },
+ callback
+ ) {
+ const moduleGraph = this.moduleGraph;
+
+ const currentProfile = this.profile ? new ModuleProfile() : undefined;
+
+ this.factorizeModule(
+ {
+ currentProfile,
+ factory,
+ dependencies,
+ factoryResult: true,
+ originModule,
+ contextInfo,
+ context
+ },
+ (err, factoryResult) => {
+ const applyFactoryResultDependencies = () => {
+ const { fileDependencies, contextDependencies, missingDependencies } =
+ factoryResult;
+ if (fileDependencies) {
+ this.fileDependencies.addAll(fileDependencies);
+ }
+ if (contextDependencies) {
+ this.contextDependencies.addAll(contextDependencies);
+ }
+ if (missingDependencies) {
+ this.missingDependencies.addAll(missingDependencies);
+ }
+ };
+ if (err) {
+ if (factoryResult) applyFactoryResultDependencies();
+ if (dependencies.every(d => d.optional)) {
+ this.warnings.push(err);
+ return callback();
+ } else {
+ this.errors.push(err);
+ return callback(err);
+ }
+ }
+
+ const newModule = factoryResult.module;
+
+ if (!newModule) {
+ applyFactoryResultDependencies();
+ return callback();
+ }
+
+ if (currentProfile !== undefined) {
+ moduleGraph.setProfile(newModule, currentProfile);
+ }
+
+ this.addModule(newModule, (err, module) => {
+ if (err) {
+ applyFactoryResultDependencies();
+ if (!err.module) {
+ err.module = module;
+ }
+ this.errors.push(err);
+
+ return callback(err);
+ }
+
+ if (
+ this._unsafeCache &&
+ factoryResult.cacheable !== false &&
+ /** @type {any} */ (module).restoreFromUnsafeCache &&
+ this._unsafeCachePredicate(module)
+ ) {
+ const unsafeCacheableModule =
+ /** @type {Module & { restoreFromUnsafeCache: Function }} */ (
+ module
+ );
+ for (let i = 0; i < dependencies.length; i++) {
+ const dependency = dependencies[i];
+ moduleGraph.setResolvedModule(
+ connectOrigin ? originModule : null,
+ dependency,
+ unsafeCacheableModule
+ );
+ unsafeCacheDependencies.set(dependency, unsafeCacheableModule);
+ }
+ if (!unsafeCacheData.has(unsafeCacheableModule)) {
+ unsafeCacheData.set(
+ unsafeCacheableModule,
+ unsafeCacheableModule.getUnsafeCacheData()
+ );
+ }
+ } else {
+ applyFactoryResultDependencies();
+ for (let i = 0; i < dependencies.length; i++) {
+ const dependency = dependencies[i];
+ moduleGraph.setResolvedModule(
+ connectOrigin ? originModule : null,
+ dependency,
+ module
+ );
+ }
+ }
+
+ moduleGraph.setIssuerIfUnset(
+ module,
+ originModule !== undefined ? originModule : null
+ );
+ if (module !== newModule) {
+ if (currentProfile !== undefined) {
+ const otherProfile = moduleGraph.getProfile(module);
+ if (otherProfile !== undefined) {
+ currentProfile.mergeInto(otherProfile);
+ } else {
+ moduleGraph.setProfile(module, currentProfile);
+ }
+ }
+ }
+
+ this._handleModuleBuildAndDependencies(
+ originModule,
+ module,
+ recursive,
+ callback
+ );
+ });
+ }
+ );
+ }
+
+ _handleModuleBuildAndDependencies(originModule, module, recursive, callback) {
+ // Check for cycles when build is trigger inside another build
+ let creatingModuleDuringBuildSet = undefined;
+ if (!recursive && this.buildQueue.isProcessing(originModule)) {
+ // Track build dependency
+ creatingModuleDuringBuildSet =
+ this.creatingModuleDuringBuild.get(originModule);
+ if (creatingModuleDuringBuildSet === undefined) {
+ creatingModuleDuringBuildSet = new Set();
+ this.creatingModuleDuringBuild.set(
+ originModule,
+ creatingModuleDuringBuildSet
+ );
+ }
+ creatingModuleDuringBuildSet.add(module);
+
+ // When building is blocked by another module
+ // search for a cycle, cancel the cycle by throwing
+ // an error (otherwise this would deadlock)
+ const blockReasons = this.creatingModuleDuringBuild.get(module);
+ if (blockReasons !== undefined) {
+ const set = new Set(blockReasons);
+ for (const item of set) {
+ const blockReasons = this.creatingModuleDuringBuild.get(item);
+ if (blockReasons !== undefined) {
+ for (const m of blockReasons) {
+ if (m === module) {
+ return callback(new BuildCycleError(module));
+ }
+ set.add(m);
+ }
+ }
+ }
+ }
+ }
+
+ this.buildModule(module, err => {
+ if (creatingModuleDuringBuildSet !== undefined) {
+ creatingModuleDuringBuildSet.delete(module);
+ }
+ if (err) {
+ if (!err.module) {
+ err.module = module;
+ }
+ this.errors.push(err);
+
+ return callback(err);
+ }
+
+ if (!recursive) {
+ this.processModuleDependenciesNonRecursive(module);
+ callback(null, module);
+ return;
+ }
+
+ // This avoids deadlocks for circular dependencies
+ if (this.processDependenciesQueue.isProcessing(module)) {
+ return callback(null, module);
+ }
+
+ this.processModuleDependencies(module, err => {
+ if (err) {
+ return callback(err);
+ }
+ callback(null, module);
+ });
+ });
+ }
+
+ /**
+ * @param {FactorizeModuleOptions} options options object
+ * @param {ModuleOrFactoryResultCallback} callback callback
+ * @returns {void}
+ */
+ _factorizeModule(
+ {
+ currentProfile,
+ factory,
+ dependencies,
+ originModule,
+ factoryResult,
+ contextInfo,
+ context
+ },
+ callback
+ ) {
+ if (currentProfile !== undefined) {
+ currentProfile.markFactoryStart();
+ }
+ factory.create(
+ {
+ contextInfo: {
+ issuer: originModule ? originModule.nameForCondition() : "",
+ issuerLayer: originModule ? originModule.layer : null,
+ compiler: this.compiler.name,
+ ...contextInfo
+ },
+ resolveOptions: originModule ? originModule.resolveOptions : undefined,
+ context: context
+ ? context
+ : originModule
+ ? originModule.context
+ : this.compiler.context,
+ dependencies: dependencies
+ },
+ (err, result) => {
+ if (result) {
+ // TODO webpack 6: remove
+ // For backward-compat
+ if (result.module === undefined && result instanceof Module) {
+ result = {
+ module: result
+ };
+ }
+ if (!factoryResult) {
+ const {
+ fileDependencies,
+ contextDependencies,
+ missingDependencies
+ } = result;
+ if (fileDependencies) {
+ this.fileDependencies.addAll(fileDependencies);
+ }
+ if (contextDependencies) {
+ this.contextDependencies.addAll(contextDependencies);
+ }
+ if (missingDependencies) {
+ this.missingDependencies.addAll(missingDependencies);
+ }
+ }
+ }
+ if (err) {
+ const notFoundError = new ModuleNotFoundError(
+ originModule,
+ err,
+ dependencies.map(d => d.loc).filter(Boolean)[0]
+ );
+ return callback(notFoundError, factoryResult ? result : undefined);
+ }
+ if (!result) {
+ return callback();
+ }
+
+ if (currentProfile !== undefined) {
+ currentProfile.markFactoryEnd();
+ }
+
+ callback(null, factoryResult ? result : result.module);
+ }
+ );
+ }
+
+ /**
+ * @param {string} context context string path
+ * @param {Dependency} dependency dependency used to create Module chain
+ * @param {ModuleCallback} callback callback for when module chain is complete
+ * @returns {void} will throw if dependency instance is not a valid Dependency
+ */
+ addModuleChain(context, dependency, callback) {
+ return this.addModuleTree({ context, dependency }, callback);
+ }
+
+ /**
+ * @param {Object} options options
+ * @param {string} options.context context string path
+ * @param {Dependency} options.dependency dependency used to create Module chain
+ * @param {Partial<ModuleFactoryCreateDataContextInfo>=} options.contextInfo additional context info for the root module
+ * @param {ModuleCallback} callback callback for when module chain is complete
+ * @returns {void} will throw if dependency instance is not a valid Dependency
+ */
+ addModuleTree({ context, dependency, contextInfo }, callback) {
+ if (
+ typeof dependency !== "object" ||
+ dependency === null ||
+ !dependency.constructor
+ ) {
+ return callback(
+ new WebpackError("Parameter 'dependency' must be a Dependency")
+ );
+ }
+ const Dep = /** @type {DepConstructor} */ (dependency.constructor);
+ const moduleFactory = this.dependencyFactories.get(Dep);
+ if (!moduleFactory) {
+ return callback(
+ new WebpackError(
+ `No dependency factory available for this dependency type: ${dependency.constructor.name}`
+ )
+ );
+ }
+
+ this.handleModuleCreation(
+ {
+ factory: moduleFactory,
+ dependencies: [dependency],
+ originModule: null,
+ contextInfo,
+ context
+ },
+ (err, result) => {
+ if (err && this.bail) {
+ callback(err);
+ this.buildQueue.stop();
+ this.rebuildQueue.stop();
+ this.processDependenciesQueue.stop();
+ this.factorizeQueue.stop();
+ } else if (!err && result) {
+ callback(null, result);
+ } else {
+ callback();
+ }
+ }
+ );
+ }
+
+ /**
+ * @param {string} context context path for entry
+ * @param {Dependency} entry entry dependency that should be followed
+ * @param {string | EntryOptions} optionsOrName options or deprecated name of entry
+ * @param {ModuleCallback} callback callback function
+ * @returns {void} returns
+ */
+ addEntry(context, entry, optionsOrName, callback) {
+ // TODO webpack 6 remove
+ const options =
+ typeof optionsOrName === "object"
+ ? optionsOrName
+ : { name: optionsOrName };
+
+ this._addEntryItem(context, entry, "dependencies", options, callback);
+ }
+
+ /**
+ * @param {string} context context path for entry
+ * @param {Dependency} dependency dependency that should be followed
+ * @param {EntryOptions} options options
+ * @param {ModuleCallback} callback callback function
+ * @returns {void} returns
+ */
+ addInclude(context, dependency, options, callback) {
+ this._addEntryItem(
+ context,
+ dependency,
+ "includeDependencies",
+ options,
+ callback
+ );
+ }
+
+ /**
+ * @param {string} context context path for entry
+ * @param {Dependency} entry entry dependency that should be followed
+ * @param {"dependencies" | "includeDependencies"} target type of entry
+ * @param {EntryOptions} options options
+ * @param {ModuleCallback} callback callback function
+ * @returns {void} returns
+ */
+ _addEntryItem(context, entry, target, options, callback) {
+ const { name } = options;
+ let entryData =
+ name !== undefined ? this.entries.get(name) : this.globalEntry;
+ if (entryData === undefined) {
+ entryData = {
+ dependencies: [],
+ includeDependencies: [],
+ options: {
+ name: undefined,
+ ...options
+ }
+ };
+ entryData[target].push(entry);
+ this.entries.set(name, entryData);
+ } else {
+ entryData[target].push(entry);
+ for (const key of Object.keys(options)) {
+ if (options[key] === undefined) continue;
+ if (entryData.options[key] === options[key]) continue;
+ if (
+ Array.isArray(entryData.options[key]) &&
+ Array.isArray(options[key]) &&
+ arrayEquals(entryData.options[key], options[key])
+ ) {
+ continue;
+ }
+ if (entryData.options[key] === undefined) {
+ entryData.options[key] = options[key];
+ } else {
+ return callback(
+ new WebpackError(
+ `Conflicting entry option ${key} = ${entryData.options[key]} vs ${options[key]}`
+ )
+ );
+ }
+ }
+ }
+
+ this.hooks.addEntry.call(entry, options);
+
+ this.addModuleTree(
+ {
+ context,
+ dependency: entry,
+ contextInfo: entryData.options.layer
+ ? { issuerLayer: entryData.options.layer }
+ : undefined
+ },
+ (err, module) => {
+ if (err) {
+ this.hooks.failedEntry.call(entry, options, err);
+ return callback(err);
+ }
+ this.hooks.succeedEntry.call(entry, options, module);
+ return callback(null, module);
+ }
+ );
+ }
+
+ /**
+ * @param {Module} module module to be rebuilt
+ * @param {ModuleCallback} callback callback when module finishes rebuilding
+ * @returns {void}
+ */
+ rebuildModule(module, callback) {
+ this.rebuildQueue.add(module, callback);
+ }
+
+ /**
+ * @param {Module} module module to be rebuilt
+ * @param {ModuleCallback} callback callback when module finishes rebuilding
+ * @returns {void}
+ */
+ _rebuildModule(module, callback) {
+ this.hooks.rebuildModule.call(module);
+ const oldDependencies = module.dependencies.slice();
+ const oldBlocks = module.blocks.slice();
+ module.invalidateBuild();
+ this.buildQueue.invalidate(module);
+ this.buildModule(module, err => {
+ if (err) {
+ return this.hooks.finishRebuildingModule.callAsync(module, err2 => {
+ if (err2) {
+ callback(
+ makeWebpackError(err2, "Compilation.hooks.finishRebuildingModule")
+ );
+ return;
+ }
+ callback(err);
+ });
+ }
+
+ this.processDependenciesQueue.invalidate(module);
+ this.moduleGraph.unfreeze();
+ this.processModuleDependencies(module, err => {
+ if (err) return callback(err);
+ this.removeReasonsOfDependencyBlock(module, {
+ dependencies: oldDependencies,
+ blocks: oldBlocks
+ });
+ this.hooks.finishRebuildingModule.callAsync(module, err2 => {
+ if (err2) {
+ callback(
+ makeWebpackError(err2, "Compilation.hooks.finishRebuildingModule")
+ );
+ return;
+ }
+ callback(null, module);
+ });
+ });
+ });
+ }
+
+ _computeAffectedModules(modules) {
+ const moduleMemCacheCache = this.compiler.moduleMemCaches;
+ if (!moduleMemCacheCache) return;
+ if (!this.moduleMemCaches) {
+ this.moduleMemCaches = new Map();
+ this.moduleGraph.setModuleMemCaches(this.moduleMemCaches);
+ }
+ const { moduleGraph, moduleMemCaches } = this;
+ const affectedModules = new Set();
+ const infectedModules = new Set();
+ let statNew = 0;
+ let statChanged = 0;
+ let statUnchanged = 0;
+ let statReferencesChanged = 0;
+ let statWithoutBuild = 0;
+
+ const computeReferences = module => {
+ /** @type {WeakMap<Dependency, Module>} */
+ let references = undefined;
+ for (const connection of moduleGraph.getOutgoingConnections(module)) {
+ const d = connection.dependency;
+ const m = connection.module;
+ if (!d || !m || unsafeCacheDependencies.has(d)) continue;
+ if (references === undefined) references = new WeakMap();
+ references.set(d, m);
+ }
+ return references;
+ };
+
+ /**
+ * @param {Module} module the module
+ * @param {WeakMap<Dependency, Module>} references references
+ * @returns {boolean} true, when the references differ
+ */
+ const compareReferences = (module, references) => {
+ if (references === undefined) return true;
+ for (const connection of moduleGraph.getOutgoingConnections(module)) {
+ const d = connection.dependency;
+ if (!d) continue;
+ const entry = references.get(d);
+ if (entry === undefined) continue;
+ if (entry !== connection.module) return false;
+ }
+ return true;
+ };
+
+ const modulesWithoutCache = new Set(modules);
+ for (const [module, cachedMemCache] of moduleMemCacheCache) {
+ if (modulesWithoutCache.has(module)) {
+ const buildInfo = module.buildInfo;
+ if (buildInfo) {
+ if (cachedMemCache.buildInfo !== buildInfo) {
+ // use a new one
+ const memCache = new WeakTupleMap();
+ moduleMemCaches.set(module, memCache);
+ affectedModules.add(module);
+ cachedMemCache.buildInfo = buildInfo;
+ cachedMemCache.references = computeReferences(module);
+ cachedMemCache.memCache = memCache;
+ statChanged++;
+ } else if (!compareReferences(module, cachedMemCache.references)) {
+ // use a new one
+ const memCache = new WeakTupleMap();
+ moduleMemCaches.set(module, memCache);
+ affectedModules.add(module);
+ cachedMemCache.references = computeReferences(module);
+ cachedMemCache.memCache = memCache;
+ statReferencesChanged++;
+ } else {
+ // keep the old mem cache
+ moduleMemCaches.set(module, cachedMemCache.memCache);
+ statUnchanged++;
+ }
+ } else {
+ infectedModules.add(module);
+ moduleMemCacheCache.delete(module);
+ statWithoutBuild++;
+ }
+ modulesWithoutCache.delete(module);
+ } else {
+ moduleMemCacheCache.delete(module);
+ }
+ }
+
+ for (const module of modulesWithoutCache) {
+ const buildInfo = module.buildInfo;
+ if (buildInfo) {
+ // create a new entry
+ const memCache = new WeakTupleMap();
+ moduleMemCacheCache.set(module, {
+ buildInfo,
+ references: computeReferences(module),
+ memCache
+ });
+ moduleMemCaches.set(module, memCache);
+ affectedModules.add(module);
+ statNew++;
+ } else {
+ infectedModules.add(module);
+ statWithoutBuild++;
+ }
+ }
+
+ const reduceAffectType = connections => {
+ let affected = false;
+ for (const { dependency } of connections) {
+ if (!dependency) continue;
+ const type = dependency.couldAffectReferencingModule();
+ if (type === Dependency.TRANSITIVE) return Dependency.TRANSITIVE;
+ if (type === false) continue;
+ affected = true;
+ }
+ return affected;
+ };
+ const directOnlyInfectedModules = new Set();
+ for (const module of infectedModules) {
+ for (const [
+ referencingModule,
+ connections
+ ] of moduleGraph.getIncomingConnectionsByOriginModule(module)) {
+ if (!referencingModule) continue;
+ if (infectedModules.has(referencingModule)) continue;
+ const type = reduceAffectType(connections);
+ if (!type) continue;
+ if (type === true) {
+ directOnlyInfectedModules.add(referencingModule);
+ } else {
+ infectedModules.add(referencingModule);
+ }
+ }
+ }
+ for (const module of directOnlyInfectedModules) infectedModules.add(module);
+ const directOnlyAffectModules = new Set();
+ for (const module of affectedModules) {
+ for (const [
+ referencingModule,
+ connections
+ ] of moduleGraph.getIncomingConnectionsByOriginModule(module)) {
+ if (!referencingModule) continue;
+ if (infectedModules.has(referencingModule)) continue;
+ if (affectedModules.has(referencingModule)) continue;
+ const type = reduceAffectType(connections);
+ if (!type) continue;
+ if (type === true) {
+ directOnlyAffectModules.add(referencingModule);
+ } else {
+ affectedModules.add(referencingModule);
+ }
+ const memCache = new WeakTupleMap();
+ const cache = moduleMemCacheCache.get(referencingModule);
+ cache.memCache = memCache;
+ moduleMemCaches.set(referencingModule, memCache);
+ }
+ }
+ for (const module of directOnlyAffectModules) affectedModules.add(module);
+ this.logger.log(
+ `${Math.round(
+ (100 * (affectedModules.size + infectedModules.size)) /
+ this.modules.size
+ )}% (${affectedModules.size} affected + ${
+ infectedModules.size
+ } infected of ${
+ this.modules.size
+ }) modules flagged as affected (${statNew} new modules, ${statChanged} changed, ${statReferencesChanged} references changed, ${statUnchanged} unchanged, ${statWithoutBuild} were not built)`
+ );
+ }
+
+ _computeAffectedModulesWithChunkGraph() {
+ const { moduleMemCaches } = this;
+ if (!moduleMemCaches) return;
+ const moduleMemCaches2 = (this.moduleMemCaches2 = new Map());
+ const { moduleGraph, chunkGraph } = this;
+ const key = "memCache2";
+ let statUnchanged = 0;
+ let statChanged = 0;
+ let statNew = 0;
+ /**
+ * @param {Module} module module
+ * @returns {{ id: string | number, modules?: Map<Module, string | number | undefined>, blocks?: (string | number)[] }} references
+ */
+ const computeReferences = module => {
+ const id = chunkGraph.getModuleId(module);
+ /** @type {Map<Module, string | number | undefined>} */
+ let modules = undefined;
+ /** @type {(string | number)[] | undefined} */
+ let blocks = undefined;
+ const outgoing = moduleGraph.getOutgoingConnectionsByModule(module);
+ if (outgoing !== undefined) {
+ for (const m of outgoing.keys()) {
+ if (!m) continue;
+ if (modules === undefined) modules = new Map();
+ modules.set(m, chunkGraph.getModuleId(m));
+ }
+ }
+ if (module.blocks.length > 0) {
+ blocks = [];
+ const queue = Array.from(module.blocks);
+ for (const block of queue) {
+ const chunkGroup = chunkGraph.getBlockChunkGroup(block);
+ if (chunkGroup) {
+ for (const chunk of chunkGroup.chunks) {
+ blocks.push(chunk.id);
+ }
+ } else {
+ blocks.push(null);
+ }
+ queue.push.apply(queue, block.blocks);
+ }
+ }
+ return { id, modules, blocks };
+ };
+ /**
+ * @param {Module} module module
+ * @param {Object} references references
+ * @param {string | number} references.id id
+ * @param {Map<Module, string | number>=} references.modules modules
+ * @param {(string | number)[]=} references.blocks blocks
+ * @returns {boolean} ok?
+ */
+ const compareReferences = (module, { id, modules, blocks }) => {
+ if (id !== chunkGraph.getModuleId(module)) return false;
+ if (modules !== undefined) {
+ for (const [module, id] of modules) {
+ if (chunkGraph.getModuleId(module) !== id) return false;
+ }
+ }
+ if (blocks !== undefined) {
+ const queue = Array.from(module.blocks);
+ let i = 0;
+ for (const block of queue) {
+ const chunkGroup = chunkGraph.getBlockChunkGroup(block);
+ if (chunkGroup) {
+ for (const chunk of chunkGroup.chunks) {
+ if (i >= blocks.length || blocks[i++] !== chunk.id) return false;
+ }
+ } else {
+ if (i >= blocks.length || blocks[i++] !== null) return false;
+ }
+ queue.push.apply(queue, block.blocks);
+ }
+ if (i !== blocks.length) return false;
+ }
+ return true;
+ };
+
+ for (const [module, memCache] of moduleMemCaches) {
+ /** @type {{ references: { id: string | number, modules?: Map<Module, string | number | undefined>, blocks?: (string | number)[]}, memCache: WeakTupleMap<any[], any> }} */
+ const cache = memCache.get(key);
+ if (cache === undefined) {
+ const memCache2 = new WeakTupleMap();
+ memCache.set(key, {
+ references: computeReferences(module),
+ memCache: memCache2
+ });
+ moduleMemCaches2.set(module, memCache2);
+ statNew++;
+ } else if (!compareReferences(module, cache.references)) {
+ const memCache = new WeakTupleMap();
+ cache.references = computeReferences(module);
+ cache.memCache = memCache;
+ moduleMemCaches2.set(module, memCache);
+ statChanged++;
+ } else {
+ moduleMemCaches2.set(module, cache.memCache);
+ statUnchanged++;
+ }
+ }
+
+ this.logger.log(
+ `${Math.round(
+ (100 * statChanged) / (statNew + statChanged + statUnchanged)
+ )}% modules flagged as affected by chunk graph (${statNew} new modules, ${statChanged} changed, ${statUnchanged} unchanged)`
+ );
+ }
+
+ finish(callback) {
+ this.factorizeQueue.clear();
+ if (this.profile) {
+ this.logger.time("finish module profiles");
+ const ParallelismFactorCalculator = require("./util/ParallelismFactorCalculator");
+ const p = new ParallelismFactorCalculator();
+ const moduleGraph = this.moduleGraph;
+ const modulesWithProfiles = new Map();
+ for (const module of this.modules) {
+ const profile = moduleGraph.getProfile(module);
+ if (!profile) continue;
+ modulesWithProfiles.set(module, profile);
+ p.range(
+ profile.buildingStartTime,
+ profile.buildingEndTime,
+ f => (profile.buildingParallelismFactor = f)
+ );
+ p.range(
+ profile.factoryStartTime,
+ profile.factoryEndTime,
+ f => (profile.factoryParallelismFactor = f)
+ );
+ p.range(
+ profile.integrationStartTime,
+ profile.integrationEndTime,
+ f => (profile.integrationParallelismFactor = f)
+ );
+ p.range(
+ profile.storingStartTime,
+ profile.storingEndTime,
+ f => (profile.storingParallelismFactor = f)
+ );
+ p.range(
+ profile.restoringStartTime,
+ profile.restoringEndTime,
+ f => (profile.restoringParallelismFactor = f)
+ );
+ if (profile.additionalFactoryTimes) {
+ for (const { start, end } of profile.additionalFactoryTimes) {
+ const influence = (end - start) / profile.additionalFactories;
+ p.range(
+ start,
+ end,
+ f =>
+ (profile.additionalFactoriesParallelismFactor += f * influence)
+ );
+ }
+ }
+ }
+ p.calculate();
+
+ const logger = this.getLogger("webpack.Compilation.ModuleProfile");
+ // Avoid coverage problems due indirect changes
+ /* istanbul ignore next */
+ const logByValue = (value, msg) => {
+ if (value > 1000) {
+ logger.error(msg);
+ } else if (value > 500) {
+ logger.warn(msg);
+ } else if (value > 200) {
+ logger.info(msg);
+ } else if (value > 30) {
+ logger.log(msg);
+ } else {
+ logger.debug(msg);
+ }
+ };
+ const logNormalSummary = (category, getDuration, getParallelism) => {
+ let sum = 0;
+ let max = 0;
+ for (const [module, profile] of modulesWithProfiles) {
+ const p = getParallelism(profile);
+ const d = getDuration(profile);
+ if (d === 0 || p === 0) continue;
+ const t = d / p;
+ sum += t;
+ if (t <= 10) continue;
+ logByValue(
+ t,
+ ` | ${Math.round(t)} ms${
+ p >= 1.1 ? ` (parallelism ${Math.round(p * 10) / 10})` : ""
+ } ${category} > ${module.readableIdentifier(this.requestShortener)}`
+ );
+ max = Math.max(max, t);
+ }
+ if (sum <= 10) return;
+ logByValue(
+ Math.max(sum / 10, max),
+ `${Math.round(sum)} ms ${category}`
+ );
+ };
+ const logByLoadersSummary = (category, getDuration, getParallelism) => {
+ const map = new Map();
+ for (const [module, profile] of modulesWithProfiles) {
+ const list = getOrInsert(
+ map,
+ module.type + "!" + module.identifier().replace(/(!|^)[^!]*$/, ""),
+ () => []
+ );
+ list.push({ module, profile });
+ }
+
+ let sum = 0;
+ let max = 0;
+ for (const [key, modules] of map) {
+ let innerSum = 0;
+ let innerMax = 0;
+ for (const { module, profile } of modules) {
+ const p = getParallelism(profile);
+ const d = getDuration(profile);
+ if (d === 0 || p === 0) continue;
+ const t = d / p;
+ innerSum += t;
+ if (t <= 10) continue;
+ logByValue(
+ t,
+ ` | | ${Math.round(t)} ms${
+ p >= 1.1 ? ` (parallelism ${Math.round(p * 10) / 10})` : ""
+ } ${category} > ${module.readableIdentifier(
+ this.requestShortener
+ )}`
+ );
+ innerMax = Math.max(innerMax, t);
+ }
+ sum += innerSum;
+ if (innerSum <= 10) continue;
+ const idx = key.indexOf("!");
+ const loaders = key.slice(idx + 1);
+ const moduleType = key.slice(0, idx);
+ const t = Math.max(innerSum / 10, innerMax);
+ logByValue(
+ t,
+ ` | ${Math.round(innerSum)} ms ${category} > ${
+ loaders
+ ? `${
+ modules.length
+ } x ${moduleType} with ${this.requestShortener.shorten(
+ loaders
+ )}`
+ : `${modules.length} x ${moduleType}`
+ }`
+ );
+ max = Math.max(max, t);
+ }
+ if (sum <= 10) return;
+ logByValue(
+ Math.max(sum / 10, max),
+ `${Math.round(sum)} ms ${category}`
+ );
+ };
+ logNormalSummary(
+ "resolve to new modules",
+ p => p.factory,
+ p => p.factoryParallelismFactor
+ );
+ logNormalSummary(
+ "resolve to existing modules",
+ p => p.additionalFactories,
+ p => p.additionalFactoriesParallelismFactor
+ );
+ logNormalSummary(
+ "integrate modules",
+ p => p.restoring,
+ p => p.restoringParallelismFactor
+ );
+ logByLoadersSummary(
+ "build modules",
+ p => p.building,
+ p => p.buildingParallelismFactor
+ );
+ logNormalSummary(
+ "store modules",
+ p => p.storing,
+ p => p.storingParallelismFactor
+ );
+ logNormalSummary(
+ "restore modules",
+ p => p.restoring,
+ p => p.restoringParallelismFactor
+ );
+ this.logger.timeEnd("finish module profiles");
+ }
+ this.logger.time("compute affected modules");
+ this._computeAffectedModules(this.modules);
+ this.logger.timeEnd("compute affected modules");
+ this.logger.time("finish modules");
+ const { modules, moduleMemCaches } = this;
+ this.hooks.finishModules.callAsync(modules, err => {
+ this.logger.timeEnd("finish modules");
+ if (err) return callback(err);
+
+ // extract warnings and errors from modules
+ this.moduleGraph.freeze("dependency errors");
+ // TODO keep a cacheToken (= {}) for each module in the graph
+ // create a new one per compilation and flag all updated files
+ // and parents with it
+ this.logger.time("report dependency errors and warnings");
+ for (const module of modules) {
+ // TODO only run for modules with changed cacheToken
+ // global WeakMap<CacheToken, WeakSet<Module>> to keep modules without errors/warnings
+ const memCache = moduleMemCaches && moduleMemCaches.get(module);
+ if (memCache && memCache.get("noWarningsOrErrors")) continue;
+ let hasProblems = this.reportDependencyErrorsAndWarnings(module, [
+ module
+ ]);
+ const errors = module.getErrors();
+ if (errors !== undefined) {
+ for (const error of errors) {
+ if (!error.module) {
+ error.module = module;
+ }
+ this.errors.push(error);
+ hasProblems = true;
+ }
+ }
+ const warnings = module.getWarnings();
+ if (warnings !== undefined) {
+ for (const warning of warnings) {
+ if (!warning.module) {
+ warning.module = module;
+ }
+ this.warnings.push(warning);
+ hasProblems = true;
+ }
+ }
+ if (!hasProblems && memCache) memCache.set("noWarningsOrErrors", true);
+ }
+ this.moduleGraph.unfreeze();
+ this.logger.timeEnd("report dependency errors and warnings");
+
+ callback();
+ });
+ }
+
+ unseal() {
+ this.hooks.unseal.call();
+ this.chunks.clear();
+ this.chunkGroups.length = 0;
+ this.namedChunks.clear();
+ this.namedChunkGroups.clear();
+ this.entrypoints.clear();
+ this.additionalChunkAssets.length = 0;
+ this.assets = {};
+ this.assetsInfo.clear();
+ this.moduleGraph.removeAllModuleAttributes();
+ this.moduleGraph.unfreeze();
+ this.moduleMemCaches2 = undefined;
+ }
+
+ /**
+ * @param {Callback} callback signals when the call finishes
+ * @returns {void}
+ */
+ seal(callback) {
+ const finalCallback = err => {
+ this.factorizeQueue.clear();
+ this.buildQueue.clear();
+ this.rebuildQueue.clear();
+ this.processDependenciesQueue.clear();
+ this.addModuleQueue.clear();
+ return callback(err);
+ };
+ const chunkGraph = new ChunkGraph(
+ this.moduleGraph,
+ this.outputOptions.hashFunction
+ );
+ this.chunkGraph = chunkGraph;
+
+ if (this._backCompat) {
+ for (const module of this.modules) {
+ ChunkGraph.setChunkGraphForModule(module, chunkGraph);
+ }
+ }
+
+ this.hooks.seal.call();
+
+ this.logger.time("optimize dependencies");
+ while (this.hooks.optimizeDependencies.call(this.modules)) {
+ /* empty */
+ }
+ this.hooks.afterOptimizeDependencies.call(this.modules);
+ this.logger.timeEnd("optimize dependencies");
+
+ this.logger.time("create chunks");
+ this.hooks.beforeChunks.call();
+ this.moduleGraph.freeze("seal");
+ /** @type {Map<Entrypoint, Module[]>} */
+ const chunkGraphInit = new Map();
+ for (const [name, { dependencies, includeDependencies, options }] of this
+ .entries) {
+ const chunk = this.addChunk(name);
+ if (options.filename) {
+ chunk.filenameTemplate = options.filename;
+ }
+ const entrypoint = new Entrypoint(options);
+ if (!options.dependOn && !options.runtime) {
+ entrypoint.setRuntimeChunk(chunk);
+ }
+ entrypoint.setEntrypointChunk(chunk);
+ this.namedChunkGroups.set(name, entrypoint);
+ this.entrypoints.set(name, entrypoint);
+ this.chunkGroups.push(entrypoint);
+ connectChunkGroupAndChunk(entrypoint, chunk);
+
+ const entryModules = new Set();
+ for (const dep of [...this.globalEntry.dependencies, ...dependencies]) {
+ entrypoint.addOrigin(null, { name }, /** @type {any} */ (dep).request);
+
+ const module = this.moduleGraph.getModule(dep);
+ if (module) {
+ chunkGraph.connectChunkAndEntryModule(chunk, module, entrypoint);
+ entryModules.add(module);
+ const modulesList = chunkGraphInit.get(entrypoint);
+ if (modulesList === undefined) {
+ chunkGraphInit.set(entrypoint, [module]);
+ } else {
+ modulesList.push(module);
+ }
+ }
+ }
+
+ this.assignDepths(entryModules);
+
+ const mapAndSort = deps =>
+ deps
+ .map(dep => this.moduleGraph.getModule(dep))
+ .filter(Boolean)
+ .sort(compareModulesByIdentifier);
+ const includedModules = [
+ ...mapAndSort(this.globalEntry.includeDependencies),
+ ...mapAndSort(includeDependencies)
+ ];
+
+ let modulesList = chunkGraphInit.get(entrypoint);
+ if (modulesList === undefined) {
+ chunkGraphInit.set(entrypoint, (modulesList = []));
+ }
+ for (const module of includedModules) {
+ this.assignDepth(module);
+ modulesList.push(module);
+ }
+ }
+ const runtimeChunks = new Set();
+ outer: for (const [
+ name,
+ {
+ options: { dependOn, runtime }
+ }
+ ] of this.entries) {
+ if (dependOn && runtime) {
+ const err =
+ new WebpackError(`Entrypoint '${name}' has 'dependOn' and 'runtime' specified. This is not valid.
+Entrypoints that depend on other entrypoints do not have their own runtime.
+They will use the runtime(s) from referenced entrypoints instead.
+Remove the 'runtime' option from the entrypoint.`);
+ const entry = this.entrypoints.get(name);
+ err.chunk = entry.getEntrypointChunk();
+ this.errors.push(err);
+ }
+ if (dependOn) {
+ const entry = this.entrypoints.get(name);
+ const referencedChunks = entry
+ .getEntrypointChunk()
+ .getAllReferencedChunks();
+ const dependOnEntries = [];
+ for (const dep of dependOn) {
+ const dependency = this.entrypoints.get(dep);
+ if (!dependency) {
+ throw new Error(
+ `Entry ${name} depends on ${dep}, but this entry was not found`
+ );
+ }
+ if (referencedChunks.has(dependency.getEntrypointChunk())) {
+ const err = new WebpackError(
+ `Entrypoints '${name}' and '${dep}' use 'dependOn' to depend on each other in a circular way.`
+ );
+ const entryChunk = entry.getEntrypointChunk();
+ err.chunk = entryChunk;
+ this.errors.push(err);
+ entry.setRuntimeChunk(entryChunk);
+ continue outer;
+ }
+ dependOnEntries.push(dependency);
+ }
+ for (const dependency of dependOnEntries) {
+ connectChunkGroupParentAndChild(dependency, entry);
+ }
+ } else if (runtime) {
+ const entry = this.entrypoints.get(name);
+ let chunk = this.namedChunks.get(runtime);
+ if (chunk) {
+ if (!runtimeChunks.has(chunk)) {
+ const err =
+ new WebpackError(`Entrypoint '${name}' has a 'runtime' option which points to another entrypoint named '${runtime}'.
+It's not valid to use other entrypoints as runtime chunk.
+Did you mean to use 'dependOn: ${JSON.stringify(
+ runtime
+ )}' instead to allow using entrypoint '${name}' within the runtime of entrypoint '${runtime}'? For this '${runtime}' must always be loaded when '${name}' is used.
+Or do you want to use the entrypoints '${name}' and '${runtime}' independently on the same page with a shared runtime? In this case give them both the same value for the 'runtime' option. It must be a name not already used by an entrypoint.`);
+ const entryChunk = entry.getEntrypointChunk();
+ err.chunk = entryChunk;
+ this.errors.push(err);
+ entry.setRuntimeChunk(entryChunk);
+ continue;
+ }
+ } else {
+ chunk = this.addChunk(runtime);
+ chunk.preventIntegration = true;
+ runtimeChunks.add(chunk);
+ }
+ entry.unshiftChunk(chunk);
+ chunk.addGroup(entry);
+ entry.setRuntimeChunk(chunk);
+ }
+ }
+ buildChunkGraph(this, chunkGraphInit);
+ this.hooks.afterChunks.call(this.chunks);
+ this.logger.timeEnd("create chunks");
+
+ this.logger.time("optimize");
+ this.hooks.optimize.call();
+
+ while (this.hooks.optimizeModules.call(this.modules)) {
+ /* empty */
+ }
+ this.hooks.afterOptimizeModules.call(this.modules);
+
+ while (this.hooks.optimizeChunks.call(this.chunks, this.chunkGroups)) {
+ /* empty */
+ }
+ this.hooks.afterOptimizeChunks.call(this.chunks, this.chunkGroups);
+
+ this.hooks.optimizeTree.callAsync(this.chunks, this.modules, err => {
+ if (err) {
+ return finalCallback(
+ makeWebpackError(err, "Compilation.hooks.optimizeTree")
+ );
+ }
+
+ this.hooks.afterOptimizeTree.call(this.chunks, this.modules);
+
+ this.hooks.optimizeChunkModules.callAsync(
+ this.chunks,
+ this.modules,
+ err => {
+ if (err) {
+ return finalCallback(
+ makeWebpackError(err, "Compilation.hooks.optimizeChunkModules")
+ );
+ }
+
+ this.hooks.afterOptimizeChunkModules.call(this.chunks, this.modules);
+
+ const shouldRecord = this.hooks.shouldRecord.call() !== false;
+
+ this.hooks.reviveModules.call(this.modules, this.records);
+ this.hooks.beforeModuleIds.call(this.modules);
+ this.hooks.moduleIds.call(this.modules);
+ this.hooks.optimizeModuleIds.call(this.modules);
+ this.hooks.afterOptimizeModuleIds.call(this.modules);
+
+ this.hooks.reviveChunks.call(this.chunks, this.records);
+ this.hooks.beforeChunkIds.call(this.chunks);
+ this.hooks.chunkIds.call(this.chunks);
+ this.hooks.optimizeChunkIds.call(this.chunks);
+ this.hooks.afterOptimizeChunkIds.call(this.chunks);
+
+ this.assignRuntimeIds();
+
+ this.logger.time("compute affected modules with chunk graph");
+ this._computeAffectedModulesWithChunkGraph();
+ this.logger.timeEnd("compute affected modules with chunk graph");
+
+ this.sortItemsWithChunkIds();
+
+ if (shouldRecord) {
+ this.hooks.recordModules.call(this.modules, this.records);
+ this.hooks.recordChunks.call(this.chunks, this.records);
+ }
+
+ this.hooks.optimizeCodeGeneration.call(this.modules);
+ this.logger.timeEnd("optimize");
+
+ this.logger.time("module hashing");
+ this.hooks.beforeModuleHash.call();
+ this.createModuleHashes();
+ this.hooks.afterModuleHash.call();
+ this.logger.timeEnd("module hashing");
+
+ this.logger.time("code generation");
+ this.hooks.beforeCodeGeneration.call();
+ this.codeGeneration(err => {
+ if (err) {
+ return finalCallback(err);
+ }
+ this.hooks.afterCodeGeneration.call();
+ this.logger.timeEnd("code generation");
+
+ this.logger.time("runtime requirements");
+ this.hooks.beforeRuntimeRequirements.call();
+ this.processRuntimeRequirements();
+ this.hooks.afterRuntimeRequirements.call();
+ this.logger.timeEnd("runtime requirements");
+
+ this.logger.time("hashing");
+ this.hooks.beforeHash.call();
+ const codeGenerationJobs = this.createHash();
+ this.hooks.afterHash.call();
+ this.logger.timeEnd("hashing");
+
+ this._runCodeGenerationJobs(codeGenerationJobs, err => {
+ if (err) {
+ return finalCallback(err);
+ }
+
+ if (shouldRecord) {
+ this.logger.time("record hash");
+ this.hooks.recordHash.call(this.records);
+ this.logger.timeEnd("record hash");
+ }
+
+ this.logger.time("module assets");
+ this.clearAssets();
+
+ this.hooks.beforeModuleAssets.call();
+ this.createModuleAssets();
+ this.logger.timeEnd("module assets");
+
+ const cont = () => {
+ this.logger.time("process assets");
+ this.hooks.processAssets.callAsync(this.assets, err => {
+ if (err) {
+ return finalCallback(
+ makeWebpackError(err, "Compilation.hooks.processAssets")
+ );
+ }
+ this.hooks.afterProcessAssets.call(this.assets);
+ this.logger.timeEnd("process assets");
+ this.assets = this._backCompat
+ ? soonFrozenObjectDeprecation(
+ this.assets,
+ "Compilation.assets",
+ "DEP_WEBPACK_COMPILATION_ASSETS",
+ `BREAKING CHANGE: No more changes should happen to Compilation.assets after sealing the Compilation.
+ Do changes to assets earlier, e. g. in Compilation.hooks.processAssets.
+ Make sure to select an appropriate stage from Compilation.PROCESS_ASSETS_STAGE_*.`
+ )
+ : Object.freeze(this.assets);
+
+ this.summarizeDependencies();
+ if (shouldRecord) {
+ this.hooks.record.call(this, this.records);
+ }
+
+ if (this.hooks.needAdditionalSeal.call()) {
+ this.unseal();
+ return this.seal(callback);
+ }
+ return this.hooks.afterSeal.callAsync(err => {
+ if (err) {
+ return finalCallback(
+ makeWebpackError(err, "Compilation.hooks.afterSeal")
+ );
+ }
+ this.fileSystemInfo.logStatistics();
+ finalCallback();
+ });
+ });
+ };
+
+ this.logger.time("create chunk assets");
+ if (this.hooks.shouldGenerateChunkAssets.call() !== false) {
+ this.hooks.beforeChunkAssets.call();
+ this.createChunkAssets(err => {
+ this.logger.timeEnd("create chunk assets");
+ if (err) {
+ return finalCallback(err);
+ }
+ cont();
+ });
+ } else {
+ this.logger.timeEnd("create chunk assets");
+ cont();
+ }
+ });
+ });
+ }
+ );
+ });
+ }
+
+ /**
+ * @param {Module} module module to report from
+ * @param {DependenciesBlock[]} blocks blocks to report from
+ * @returns {boolean} true, when it has warnings or errors
+ */
+ reportDependencyErrorsAndWarnings(module, blocks) {
+ let hasProblems = false;
+ for (let indexBlock = 0; indexBlock < blocks.length; indexBlock++) {
+ const block = blocks[indexBlock];
+ const dependencies = block.dependencies;
+
+ for (let indexDep = 0; indexDep < dependencies.length; indexDep++) {
+ const d = dependencies[indexDep];
+
+ const warnings = d.getWarnings(this.moduleGraph);
+ if (warnings) {
+ for (let indexWar = 0; indexWar < warnings.length; indexWar++) {
+ const w = warnings[indexWar];
+
+ const warning = new ModuleDependencyWarning(module, w, d.loc);
+ this.warnings.push(warning);
+ hasProblems = true;
+ }
+ }
+ const errors = d.getErrors(this.moduleGraph);
+ if (errors) {
+ for (let indexErr = 0; indexErr < errors.length; indexErr++) {
+ const e = errors[indexErr];
+
+ const error = new ModuleDependencyError(module, e, d.loc);
+ this.errors.push(error);
+ hasProblems = true;
+ }
+ }
+ }
+
+ if (this.reportDependencyErrorsAndWarnings(module, block.blocks))
+ hasProblems = true;
+ }
+ return hasProblems;
+ }
+
+ codeGeneration(callback) {
+ const { chunkGraph } = this;
+ this.codeGenerationResults = new CodeGenerationResults(
+ this.outputOptions.hashFunction
+ );
+ /** @type {{module: Module, hash: string, runtime: RuntimeSpec, runtimes: RuntimeSpec[]}[]} */
+ const jobs = [];
+ for (const module of this.modules) {
+ const runtimes = chunkGraph.getModuleRuntimes(module);
+ if (runtimes.size === 1) {
+ for (const runtime of runtimes) {
+ const hash = chunkGraph.getModuleHash(module, runtime);
+ jobs.push({ module, hash, runtime, runtimes: [runtime] });
+ }
+ } else if (runtimes.size > 1) {
+ /** @type {Map<string, { runtimes: RuntimeSpec[] }>} */
+ const map = new Map();
+ for (const runtime of runtimes) {
+ const hash = chunkGraph.getModuleHash(module, runtime);
+ const job = map.get(hash);
+ if (job === undefined) {
+ const newJob = { module, hash, runtime, runtimes: [runtime] };
+ jobs.push(newJob);
+ map.set(hash, newJob);
+ } else {
+ job.runtimes.push(runtime);
+ }
+ }
+ }
+ }
+
+ this._runCodeGenerationJobs(jobs, callback);
+ }
+
+ _runCodeGenerationJobs(jobs, callback) {
+ if (jobs.length === 0) {
+ return callback();
+ }
+ let statModulesFromCache = 0;
+ let statModulesGenerated = 0;
+ const { chunkGraph, moduleGraph, dependencyTemplates, runtimeTemplate } =
+ this;
+ const results = this.codeGenerationResults;
+ /** @type {WebpackError[]} */
+ const errors = [];
+ /** @type {Set<Module> | undefined} */
+ let notCodeGeneratedModules = undefined;
+ const runIteration = () => {
+ let delayedJobs = [];
+ let delayedModules = new Set();
+ asyncLib.eachLimit(
+ jobs,
+ this.options.parallelism,
+ (job, callback) => {
+ const { module } = job;
+ const { codeGenerationDependencies } = module;
+ if (codeGenerationDependencies !== undefined) {
+ if (
+ notCodeGeneratedModules === undefined ||
+ codeGenerationDependencies.some(dep => {
+ const referencedModule = moduleGraph.getModule(dep);
+ return notCodeGeneratedModules.has(referencedModule);
+ })
+ ) {
+ delayedJobs.push(job);
+ delayedModules.add(module);
+ return callback();
+ }
+ }
+ const { hash, runtime, runtimes } = job;
+ this._codeGenerationModule(
+ module,
+ runtime,
+ runtimes,
+ hash,
+ dependencyTemplates,
+ chunkGraph,
+ moduleGraph,
+ runtimeTemplate,
+ errors,
+ results,
+ (err, codeGenerated) => {
+ if (codeGenerated) statModulesGenerated++;
+ else statModulesFromCache++;
+ callback(err);
+ }
+ );
+ },
+ err => {
+ if (err) return callback(err);
+ if (delayedJobs.length > 0) {
+ if (delayedJobs.length === jobs.length) {
+ return callback(
+ new Error(
+ `Unable to make progress during code generation because of circular code generation dependency: ${Array.from(
+ delayedModules,
+ m => m.identifier()
+ ).join(", ")}`
+ )
+ );
+ }
+ jobs = delayedJobs;
+ delayedJobs = [];
+ notCodeGeneratedModules = delayedModules;
+ delayedModules = new Set();
+ return runIteration();
+ }
+ if (errors.length > 0) {
+ errors.sort(
+ compareSelect(err => err.module, compareModulesByIdentifier)
+ );
+ for (const error of errors) {
+ this.errors.push(error);
+ }
+ }
+ this.logger.log(
+ `${Math.round(
+ (100 * statModulesGenerated) /
+ (statModulesGenerated + statModulesFromCache)
+ )}% code generated (${statModulesGenerated} generated, ${statModulesFromCache} from cache)`
+ );
+ callback();
+ }
+ );
+ };
+ runIteration();
+ }
+
+ /**
+ * @param {Module} module module
+ * @param {RuntimeSpec} runtime runtime
+ * @param {RuntimeSpec[]} runtimes runtimes
+ * @param {string} hash hash
+ * @param {DependencyTemplates} dependencyTemplates dependencyTemplates
+ * @param {ChunkGraph} chunkGraph chunkGraph
+ * @param {ModuleGraph} moduleGraph moduleGraph
+ * @param {RuntimeTemplate} runtimeTemplate runtimeTemplate
+ * @param {WebpackError[]} errors errors
+ * @param {CodeGenerationResults} results results
+ * @param {function((WebpackError | null)=, boolean=): void} callback callback
+ */
+ _codeGenerationModule(
+ module,
+ runtime,
+ runtimes,
+ hash,
+ dependencyTemplates,
+ chunkGraph,
+ moduleGraph,
+ runtimeTemplate,
+ errors,
+ results,
+ callback
+ ) {
+ let codeGenerated = false;
+ const cache = new MultiItemCache(
+ runtimes.map(runtime =>
+ this._codeGenerationCache.getItemCache(
+ `${module.identifier()}|${getRuntimeKey(runtime)}`,
+ `${hash}|${dependencyTemplates.getHash()}`
+ )
+ )
+ );
+ cache.get((err, cachedResult) => {
+ if (err) return callback(err);
+ let result;
+ if (!cachedResult) {
+ try {
+ codeGenerated = true;
+ this.codeGeneratedModules.add(module);
+ result = module.codeGeneration({
+ chunkGraph,
+ moduleGraph,
+ dependencyTemplates,
+ runtimeTemplate,
+ runtime,
+ codeGenerationResults: results,
+ compilation: this
+ });
+ } catch (err) {
+ errors.push(new CodeGenerationError(module, err));
+ result = cachedResult = {
+ sources: new Map(),
+ runtimeRequirements: null
+ };
+ }
+ } else {
+ result = cachedResult;
+ }
+ for (const runtime of runtimes) {
+ results.add(module, runtime, result);
+ }
+ if (!cachedResult) {
+ cache.store(result, err => callback(err, codeGenerated));
+ } else {
+ callback(null, codeGenerated);
+ }
+ });
+ }
+
+ _getChunkGraphEntries() {
+ /** @type {Set<Chunk>} */
+ const treeEntries = new Set();
+ for (const ep of this.entrypoints.values()) {
+ const chunk = ep.getRuntimeChunk();
+ if (chunk) treeEntries.add(chunk);
+ }
+ for (const ep of this.asyncEntrypoints) {
+ const chunk = ep.getRuntimeChunk();
+ if (chunk) treeEntries.add(chunk);
+ }
+ return treeEntries;
+ }
+
+ /**
+ * @param {Object} options options
+ * @param {ChunkGraph=} options.chunkGraph the chunk graph
+ * @param {Iterable<Module>=} options.modules modules
+ * @param {Iterable<Chunk>=} options.chunks chunks
+ * @param {CodeGenerationResults=} options.codeGenerationResults codeGenerationResults
+ * @param {Iterable<Chunk>=} options.chunkGraphEntries chunkGraphEntries
+ * @returns {void}
+ */
+ processRuntimeRequirements({
+ chunkGraph = this.chunkGraph,
+ modules = this.modules,
+ chunks = this.chunks,
+ codeGenerationResults = this.codeGenerationResults,
+ chunkGraphEntries = this._getChunkGraphEntries()
+ } = {}) {
+ const context = { chunkGraph, codeGenerationResults };
+ const { moduleMemCaches2 } = this;
+ this.logger.time("runtime requirements.modules");
+ const additionalModuleRuntimeRequirements =
+ this.hooks.additionalModuleRuntimeRequirements;
+ const runtimeRequirementInModule = this.hooks.runtimeRequirementInModule;
+ for (const module of modules) {
+ if (chunkGraph.getNumberOfModuleChunks(module) > 0) {
+ const memCache = moduleMemCaches2 && moduleMemCaches2.get(module);
+ for (const runtime of chunkGraph.getModuleRuntimes(module)) {
+ if (memCache) {
+ const cached = memCache.get(
+ `moduleRuntimeRequirements-${getRuntimeKey(runtime)}`
+ );
+ if (cached !== undefined) {
+ if (cached !== null) {
+ chunkGraph.addModuleRuntimeRequirements(
+ module,
+ runtime,
+ cached,
+ false
+ );
+ }
+ continue;
+ }
+ }
+ let set;
+ const runtimeRequirements =
+ codeGenerationResults.getRuntimeRequirements(module, runtime);
+ if (runtimeRequirements && runtimeRequirements.size > 0) {
+ set = new Set(runtimeRequirements);
+ } else if (additionalModuleRuntimeRequirements.isUsed()) {
+ set = new Set();
+ } else {
+ if (memCache) {
+ memCache.set(
+ `moduleRuntimeRequirements-${getRuntimeKey(runtime)}`,
+ null
+ );
+ }
+ continue;
+ }
+ additionalModuleRuntimeRequirements.call(module, set, context);
+
+ for (const r of set) {
+ const hook = runtimeRequirementInModule.get(r);
+ if (hook !== undefined) hook.call(module, set, context);
+ }
+ if (set.size === 0) {
+ if (memCache) {
+ memCache.set(
+ `moduleRuntimeRequirements-${getRuntimeKey(runtime)}`,
+ null
+ );
+ }
+ } else {
+ if (memCache) {
+ memCache.set(
+ `moduleRuntimeRequirements-${getRuntimeKey(runtime)}`,
+ set
+ );
+ chunkGraph.addModuleRuntimeRequirements(
+ module,
+ runtime,
+ set,
+ false
+ );
+ } else {
+ chunkGraph.addModuleRuntimeRequirements(module, runtime, set);
+ }
+ }
+ }
+ }
+ }
+ this.logger.timeEnd("runtime requirements.modules");
+
+ this.logger.time("runtime requirements.chunks");
+ for (const chunk of chunks) {
+ const set = new Set();
+ for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
+ const runtimeRequirements = chunkGraph.getModuleRuntimeRequirements(
+ module,
+ chunk.runtime
+ );
+ for (const r of runtimeRequirements) set.add(r);
+ }
+ this.hooks.additionalChunkRuntimeRequirements.call(chunk, set, context);
+
+ for (const r of set) {
+ this.hooks.runtimeRequirementInChunk.for(r).call(chunk, set, context);
+ }
+
+ chunkGraph.addChunkRuntimeRequirements(chunk, set);
+ }
+ this.logger.timeEnd("runtime requirements.chunks");
+
+ this.logger.time("runtime requirements.entries");
+ for (const treeEntry of chunkGraphEntries) {
+ const set = new Set();
+ for (const chunk of treeEntry.getAllReferencedChunks()) {
+ const runtimeRequirements =
+ chunkGraph.getChunkRuntimeRequirements(chunk);
+ for (const r of runtimeRequirements) set.add(r);
+ }
+
+ this.hooks.additionalTreeRuntimeRequirements.call(
+ treeEntry,
+ set,
+ context
+ );
+
+ for (const r of set) {
+ this.hooks.runtimeRequirementInTree
+ .for(r)
+ .call(treeEntry, set, context);
+ }
+
+ chunkGraph.addTreeRuntimeRequirements(treeEntry, set);
+ }
+ this.logger.timeEnd("runtime requirements.entries");
+ }
+
+ // TODO webpack 6 make chunkGraph argument non-optional
+ /**
+ * @param {Chunk} chunk target chunk
+ * @param {RuntimeModule} module runtime module
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @returns {void}
+ */
+ addRuntimeModule(chunk, module, chunkGraph = this.chunkGraph) {
+ // Deprecated ModuleGraph association
+ if (this._backCompat)
+ ModuleGraph.setModuleGraphForModule(module, this.moduleGraph);
+
+ // add it to the list
+ this.modules.add(module);
+ this._modules.set(module.identifier(), module);
+
+ // connect to the chunk graph
+ chunkGraph.connectChunkAndModule(chunk, module);
+ chunkGraph.connectChunkAndRuntimeModule(chunk, module);
+ if (module.fullHash) {
+ chunkGraph.addFullHashModuleToChunk(chunk, module);
+ } else if (module.dependentHash) {
+ chunkGraph.addDependentHashModuleToChunk(chunk, module);
+ }
+
+ // attach runtime module
+ module.attach(this, chunk, chunkGraph);
+
+ // Setup internals
+ const exportsInfo = this.moduleGraph.getExportsInfo(module);
+ exportsInfo.setHasProvideInfo();
+ if (typeof chunk.runtime === "string") {
+ exportsInfo.setUsedForSideEffectsOnly(chunk.runtime);
+ } else if (chunk.runtime === undefined) {
+ exportsInfo.setUsedForSideEffectsOnly(undefined);
+ } else {
+ for (const runtime of chunk.runtime) {
+ exportsInfo.setUsedForSideEffectsOnly(runtime);
+ }
+ }
+ chunkGraph.addModuleRuntimeRequirements(
+ module,
+ chunk.runtime,
+ new Set([RuntimeGlobals.requireScope])
+ );
+
+ // runtime modules don't need ids
+ chunkGraph.setModuleId(module, "");
+
+ // Call hook
+ this.hooks.runtimeModule.call(module, chunk);
+ }
+
+ /**
+ * If `module` is passed, `loc` and `request` must also be passed.
+ * @param {string | ChunkGroupOptions} groupOptions options for the chunk group
+ * @param {Module=} module the module the references the chunk group
+ * @param {DependencyLocation=} loc the location from with the chunk group is referenced (inside of module)
+ * @param {string=} request the request from which the the chunk group is referenced
+ * @returns {ChunkGroup} the new or existing chunk group
+ */
+ addChunkInGroup(groupOptions, module, loc, request) {
+ if (typeof groupOptions === "string") {
+ groupOptions = { name: groupOptions };
+ }
+ const name = groupOptions.name;
+
+ if (name) {
+ const chunkGroup = this.namedChunkGroups.get(name);
+ if (chunkGroup !== undefined) {
+ chunkGroup.addOptions(groupOptions);
+ if (module) {
+ chunkGroup.addOrigin(module, loc, request);
+ }
+ return chunkGroup;
+ }
+ }
+ const chunkGroup = new ChunkGroup(groupOptions);
+ if (module) chunkGroup.addOrigin(module, loc, request);
+ const chunk = this.addChunk(name);
+
+ connectChunkGroupAndChunk(chunkGroup, chunk);
+
+ this.chunkGroups.push(chunkGroup);
+ if (name) {
+ this.namedChunkGroups.set(name, chunkGroup);
+ }
+ return chunkGroup;
+ }
+
+ /**
+ * @param {EntryOptions} options options for the entrypoint
+ * @param {Module} module the module the references the chunk group
+ * @param {DependencyLocation} loc the location from with the chunk group is referenced (inside of module)
+ * @param {string} request the request from which the the chunk group is referenced
+ * @returns {Entrypoint} the new or existing entrypoint
+ */
+ addAsyncEntrypoint(options, module, loc, request) {
+ const name = options.name;
+ if (name) {
+ const entrypoint = this.namedChunkGroups.get(name);
+ if (entrypoint instanceof Entrypoint) {
+ if (entrypoint !== undefined) {
+ if (module) {
+ entrypoint.addOrigin(module, loc, request);
+ }
+ return entrypoint;
+ }
+ } else if (entrypoint) {
+ throw new Error(
+ `Cannot add an async entrypoint with the name '${name}', because there is already an chunk group with this name`
+ );
+ }
+ }
+ const chunk = this.addChunk(name);
+ if (options.filename) {
+ chunk.filenameTemplate = options.filename;
+ }
+ const entrypoint = new Entrypoint(options, false);
+ entrypoint.setRuntimeChunk(chunk);
+ entrypoint.setEntrypointChunk(chunk);
+ if (name) {
+ this.namedChunkGroups.set(name, entrypoint);
+ }
+ this.chunkGroups.push(entrypoint);
+ this.asyncEntrypoints.push(entrypoint);
+ connectChunkGroupAndChunk(entrypoint, chunk);
+ if (module) {
+ entrypoint.addOrigin(module, loc, request);
+ }
+ return entrypoint;
+ }
+
+ /**
+ * This method first looks to see if a name is provided for a new chunk,
+ * and first looks to see if any named chunks already exist and reuse that chunk instead.
+ *
+ * @param {string=} name optional chunk name to be provided
+ * @returns {Chunk} create a chunk (invoked during seal event)
+ */
+ addChunk(name) {
+ if (name) {
+ const chunk = this.namedChunks.get(name);
+ if (chunk !== undefined) {
+ return chunk;
+ }
+ }
+ const chunk = new Chunk(name, this._backCompat);
+ this.chunks.add(chunk);
+ if (this._backCompat)
+ ChunkGraph.setChunkGraphForChunk(chunk, this.chunkGraph);
+ if (name) {
+ this.namedChunks.set(name, chunk);
+ }
+ return chunk;
+ }
+
+ /**
+ * @deprecated
+ * @param {Module} module module to assign depth
+ * @returns {void}
+ */
+ assignDepth(module) {
+ const moduleGraph = this.moduleGraph;
+
+ const queue = new Set([module]);
+ let depth;
+
+ moduleGraph.setDepth(module, 0);
+
+ /**
+ * @param {Module} module module for processing
+ * @returns {void}
+ */
+ const processModule = module => {
+ if (!moduleGraph.setDepthIfLower(module, depth)) return;
+ queue.add(module);
+ };
+
+ for (module of queue) {
+ queue.delete(module);
+ depth = moduleGraph.getDepth(module) + 1;
+
+ for (const connection of moduleGraph.getOutgoingConnections(module)) {
+ const refModule = connection.module;
+ if (refModule) {
+ processModule(refModule);
+ }
+ }
+ }
+ }
+
+ /**
+ * @param {Set<Module>} modules module to assign depth
+ * @returns {void}
+ */
+ assignDepths(modules) {
+ const moduleGraph = this.moduleGraph;
+
+ /** @type {Set<Module | number>} */
+ const queue = new Set(modules);
+ queue.add(1);
+ let depth = 0;
+
+ let i = 0;
+ for (const module of queue) {
+ i++;
+ if (typeof module === "number") {
+ depth = module;
+ if (queue.size === i) return;
+ queue.add(depth + 1);
+ } else {
+ moduleGraph.setDepth(module, depth);
+ for (const { module: refModule } of moduleGraph.getOutgoingConnections(
+ module
+ )) {
+ if (refModule) {
+ queue.add(refModule);
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * @param {Dependency} dependency the dependency
+ * @param {RuntimeSpec} runtime the runtime
+ * @returns {(string[] | ReferencedExport)[]} referenced exports
+ */
+ getDependencyReferencedExports(dependency, runtime) {
+ const referencedExports = dependency.getReferencedExports(
+ this.moduleGraph,
+ runtime
+ );
+ return this.hooks.dependencyReferencedExports.call(
+ referencedExports,
+ dependency,
+ runtime
+ );
+ }
+
+ /**
+ *
+ * @param {Module} module module relationship for removal
+ * @param {DependenciesBlockLike} block //TODO: good description
+ * @returns {void}
+ */
+ removeReasonsOfDependencyBlock(module, block) {
+ if (block.blocks) {
+ for (const b of block.blocks) {
+ this.removeReasonsOfDependencyBlock(module, b);
+ }
+ }
+
+ if (block.dependencies) {
+ for (const dep of block.dependencies) {
+ const originalModule = this.moduleGraph.getModule(dep);
+ if (originalModule) {
+ this.moduleGraph.removeConnection(dep);
+
+ if (this.chunkGraph) {
+ for (const chunk of this.chunkGraph.getModuleChunks(
+ originalModule
+ )) {
+ this.patchChunksAfterReasonRemoval(originalModule, chunk);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * @param {Module} module module to patch tie
+ * @param {Chunk} chunk chunk to patch tie
+ * @returns {void}
+ */
+ patchChunksAfterReasonRemoval(module, chunk) {
+ if (!module.hasReasons(this.moduleGraph, chunk.runtime)) {
+ this.removeReasonsOfDependencyBlock(module, module);
+ }
+ if (!module.hasReasonForChunk(chunk, this.moduleGraph, this.chunkGraph)) {
+ if (this.chunkGraph.isModuleInChunk(module, chunk)) {
+ this.chunkGraph.disconnectChunkAndModule(chunk, module);
+ this.removeChunkFromDependencies(module, chunk);
+ }
+ }
+ }
+
+ /**
+ *
+ * @param {DependenciesBlock} block block tie for Chunk
+ * @param {Chunk} chunk chunk to remove from dep
+ * @returns {void}
+ */
+ removeChunkFromDependencies(block, chunk) {
+ /**
+ * @param {Dependency} d dependency to (maybe) patch up
+ */
+ const iteratorDependency = d => {
+ const depModule = this.moduleGraph.getModule(d);
+ if (!depModule) {
+ return;
+ }
+ this.patchChunksAfterReasonRemoval(depModule, chunk);
+ };
+
+ const blocks = block.blocks;
+ for (let indexBlock = 0; indexBlock < blocks.length; indexBlock++) {
+ const asyncBlock = blocks[indexBlock];
+ const chunkGroup = this.chunkGraph.getBlockChunkGroup(asyncBlock);
+ // Grab all chunks from the first Block's AsyncDepBlock
+ const chunks = chunkGroup.chunks;
+ // For each chunk in chunkGroup
+ for (let indexChunk = 0; indexChunk < chunks.length; indexChunk++) {
+ const iteratedChunk = chunks[indexChunk];
+ chunkGroup.removeChunk(iteratedChunk);
+ // Recurse
+ this.removeChunkFromDependencies(block, iteratedChunk);
+ }
+ }
+
+ if (block.dependencies) {
+ for (const dep of block.dependencies) iteratorDependency(dep);
+ }
+ }
+
+ assignRuntimeIds() {
+ const { chunkGraph } = this;
+ const processEntrypoint = ep => {
+ const runtime = ep.options.runtime || ep.name;
+ const chunk = ep.getRuntimeChunk();
+ chunkGraph.setRuntimeId(runtime, chunk.id);
+ };
+ for (const ep of this.entrypoints.values()) {
+ processEntrypoint(ep);
+ }
+ for (const ep of this.asyncEntrypoints) {
+ processEntrypoint(ep);
+ }
+ }
+
+ sortItemsWithChunkIds() {
+ for (const chunkGroup of this.chunkGroups) {
+ chunkGroup.sortItems();
+ }
+
+ this.errors.sort(compareErrors);
+ this.warnings.sort(compareErrors);
+ this.children.sort(byNameOrHash);
+ }
+
+ summarizeDependencies() {
+ for (
+ let indexChildren = 0;
+ indexChildren < this.children.length;
+ indexChildren++
+ ) {
+ const child = this.children[indexChildren];
+
+ this.fileDependencies.addAll(child.fileDependencies);
+ this.contextDependencies.addAll(child.contextDependencies);
+ this.missingDependencies.addAll(child.missingDependencies);
+ this.buildDependencies.addAll(child.buildDependencies);
+ }
+
+ for (const module of this.modules) {
+ module.addCacheDependencies(
+ this.fileDependencies,
+ this.contextDependencies,
+ this.missingDependencies,
+ this.buildDependencies
+ );
+ }
+ }
+
+ createModuleHashes() {
+ let statModulesHashed = 0;
+ let statModulesFromCache = 0;
+ const { chunkGraph, runtimeTemplate, moduleMemCaches2 } = this;
+ const { hashFunction, hashDigest, hashDigestLength } = this.outputOptions;
+ const errors = [];
+ for (const module of this.modules) {
+ const memCache = moduleMemCaches2 && moduleMemCaches2.get(module);
+ for (const runtime of chunkGraph.getModuleRuntimes(module)) {
+ if (memCache) {
+ const digest = memCache.get(`moduleHash-${getRuntimeKey(runtime)}`);
+ if (digest !== undefined) {
+ chunkGraph.setModuleHashes(
+ module,
+ runtime,
+ digest,
+ digest.slice(0, hashDigestLength)
+ );
+ statModulesFromCache++;
+ continue;
+ }
+ }
+ statModulesHashed++;
+ const digest = this._createModuleHash(
+ module,
+ chunkGraph,
+ runtime,
+ hashFunction,
+ runtimeTemplate,
+ hashDigest,
+ hashDigestLength,
+ errors
+ );
+ if (memCache) {
+ memCache.set(`moduleHash-${getRuntimeKey(runtime)}`, digest);
+ }
+ }
+ }
+ if (errors.length > 0) {
+ errors.sort(compareSelect(err => err.module, compareModulesByIdentifier));
+ for (const error of errors) {
+ this.errors.push(error);
+ }
+ }
+ this.logger.log(
+ `${statModulesHashed} modules hashed, ${statModulesFromCache} from cache (${
+ Math.round(
+ (100 * (statModulesHashed + statModulesFromCache)) / this.modules.size
+ ) / 100
+ } variants per module in average)`
+ );
+ }
+
+ _createModuleHash(
+ module,
+ chunkGraph,
+ runtime,
+ hashFunction,
+ runtimeTemplate,
+ hashDigest,
+ hashDigestLength,
+ errors
+ ) {
+ let moduleHashDigest;
+ try {
+ const moduleHash = createHash(hashFunction);
+ module.updateHash(moduleHash, {
+ chunkGraph,
+ runtime,
+ runtimeTemplate
+ });
+ moduleHashDigest = /** @type {string} */ (moduleHash.digest(hashDigest));
+ } catch (err) {
+ errors.push(new ModuleHashingError(module, err));
+ moduleHashDigest = "XXXXXX";
+ }
+ chunkGraph.setModuleHashes(
+ module,
+ runtime,
+ moduleHashDigest,
+ moduleHashDigest.slice(0, hashDigestLength)
+ );
+ return moduleHashDigest;
+ }
+
+ createHash() {
+ this.logger.time("hashing: initialize hash");
+ const chunkGraph = this.chunkGraph;
+ const runtimeTemplate = this.runtimeTemplate;
+ const outputOptions = this.outputOptions;
+ const hashFunction = outputOptions.hashFunction;
+ const hashDigest = outputOptions.hashDigest;
+ const hashDigestLength = outputOptions.hashDigestLength;
+ const hash = createHash(hashFunction);
+ if (outputOptions.hashSalt) {
+ hash.update(outputOptions.hashSalt);
+ }
+ this.logger.timeEnd("hashing: initialize hash");
+ if (this.children.length > 0) {
+ this.logger.time("hashing: hash child compilations");
+ for (const child of this.children) {
+ hash.update(child.hash);
+ }
+ this.logger.timeEnd("hashing: hash child compilations");
+ }
+ if (this.warnings.length > 0) {
+ this.logger.time("hashing: hash warnings");
+ for (const warning of this.warnings) {
+ hash.update(`${warning.message}`);
+ }
+ this.logger.timeEnd("hashing: hash warnings");
+ }
+ if (this.errors.length > 0) {
+ this.logger.time("hashing: hash errors");
+ for (const error of this.errors) {
+ hash.update(`${error.message}`);
+ }
+ this.logger.timeEnd("hashing: hash errors");
+ }
+
+ this.logger.time("hashing: sort chunks");
+ /*
+ * all non-runtime chunks need to be hashes first,
+ * since runtime chunk might use their hashes.
+ * runtime chunks need to be hashed in the correct order
+ * since they may depend on each other (for async entrypoints).
+ * So we put all non-runtime chunks first and hash them in any order.
+ * And order runtime chunks according to referenced between each other.
+ * Chunks need to be in deterministic order since we add hashes to full chunk
+ * during these hashing.
+ */
+ /** @type {Chunk[]} */
+ const unorderedRuntimeChunks = [];
+ /** @type {Chunk[]} */
+ const otherChunks = [];
+ for (const c of this.chunks) {
+ if (c.hasRuntime()) {
+ unorderedRuntimeChunks.push(c);
+ } else {
+ otherChunks.push(c);
+ }
+ }
+ unorderedRuntimeChunks.sort(byId);
+ otherChunks.sort(byId);
+
+ /** @typedef {{ chunk: Chunk, referencedBy: RuntimeChunkInfo[], remaining: number }} RuntimeChunkInfo */
+ /** @type {Map<Chunk, RuntimeChunkInfo>} */
+ const runtimeChunksMap = new Map();
+ for (const chunk of unorderedRuntimeChunks) {
+ runtimeChunksMap.set(chunk, {
+ chunk,
+ referencedBy: [],
+ remaining: 0
+ });
+ }
+ let remaining = 0;
+ for (const info of runtimeChunksMap.values()) {
+ for (const other of new Set(
+ Array.from(info.chunk.getAllReferencedAsyncEntrypoints()).map(
+ e => e.chunks[e.chunks.length - 1]
+ )
+ )) {
+ const otherInfo = runtimeChunksMap.get(other);
+ otherInfo.referencedBy.push(info);
+ info.remaining++;
+ remaining++;
+ }
+ }
+ /** @type {Chunk[]} */
+ const runtimeChunks = [];
+ for (const info of runtimeChunksMap.values()) {
+ if (info.remaining === 0) {
+ runtimeChunks.push(info.chunk);
+ }
+ }
+ // If there are any references between chunks
+ // make sure to follow these chains
+ if (remaining > 0) {
+ const readyChunks = [];
+ for (const chunk of runtimeChunks) {
+ const hasFullHashModules =
+ chunkGraph.getNumberOfChunkFullHashModules(chunk) !== 0;
+ const info = runtimeChunksMap.get(chunk);
+ for (const otherInfo of info.referencedBy) {
+ if (hasFullHashModules) {
+ chunkGraph.upgradeDependentToFullHashModules(otherInfo.chunk);
+ }
+ remaining--;
+ if (--otherInfo.remaining === 0) {
+ readyChunks.push(otherInfo.chunk);
+ }
+ }
+ if (readyChunks.length > 0) {
+ // This ensures deterministic ordering, since referencedBy is non-deterministic
+ readyChunks.sort(byId);
+ for (const c of readyChunks) runtimeChunks.push(c);
+ readyChunks.length = 0;
+ }
+ }
+ }
+ // If there are still remaining references we have cycles and want to create a warning
+ if (remaining > 0) {
+ let circularRuntimeChunkInfo = [];
+ for (const info of runtimeChunksMap.values()) {
+ if (info.remaining !== 0) {
+ circularRuntimeChunkInfo.push(info);
+ }
+ }
+ circularRuntimeChunkInfo.sort(compareSelect(i => i.chunk, byId));
+ const err =
+ new WebpackError(`Circular dependency between chunks with runtime (${Array.from(
+ circularRuntimeChunkInfo,
+ c => c.chunk.name || c.chunk.id
+ ).join(", ")})
+This prevents using hashes of each other and should be avoided.`);
+ err.chunk = circularRuntimeChunkInfo[0].chunk;
+ this.warnings.push(err);
+ for (const i of circularRuntimeChunkInfo) runtimeChunks.push(i.chunk);
+ }
+ this.logger.timeEnd("hashing: sort chunks");
+
+ const fullHashChunks = new Set();
+ /** @type {{module: Module, hash: string, runtime: RuntimeSpec, runtimes: RuntimeSpec[]}[]} */
+ const codeGenerationJobs = [];
+ /** @type {Map<string, Map<Module, {module: Module, hash: string, runtime: RuntimeSpec, runtimes: RuntimeSpec[]}>>} */
+ const codeGenerationJobsMap = new Map();
+ const errors = [];
+
+ const processChunk = chunk => {
+ // Last minute module hash generation for modules that depend on chunk hashes
+ this.logger.time("hashing: hash runtime modules");
+ const runtime = chunk.runtime;
+ for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
+ if (!chunkGraph.hasModuleHashes(module, runtime)) {
+ const hash = this._createModuleHash(
+ module,
+ chunkGraph,
+ runtime,
+ hashFunction,
+ runtimeTemplate,
+ hashDigest,
+ hashDigestLength,
+ errors
+ );
+ let hashMap = codeGenerationJobsMap.get(hash);
+ if (hashMap) {
+ const moduleJob = hashMap.get(module);
+ if (moduleJob) {
+ moduleJob.runtimes.push(runtime);
+ continue;
+ }
+ } else {
+ hashMap = new Map();
+ codeGenerationJobsMap.set(hash, hashMap);
+ }
+ const job = {
+ module,
+ hash,
+ runtime,
+ runtimes: [runtime]
+ };
+ hashMap.set(module, job);
+ codeGenerationJobs.push(job);
+ }
+ }
+ this.logger.timeAggregate("hashing: hash runtime modules");
+ try {
+ this.logger.time("hashing: hash chunks");
+ const chunkHash = createHash(hashFunction);
+ if (outputOptions.hashSalt) {
+ chunkHash.update(outputOptions.hashSalt);
+ }
+ chunk.updateHash(chunkHash, chunkGraph);
+ this.hooks.chunkHash.call(chunk, chunkHash, {
+ chunkGraph,
+ codeGenerationResults: this.codeGenerationResults,
+ moduleGraph: this.moduleGraph,
+ runtimeTemplate: this.runtimeTemplate
+ });
+ const chunkHashDigest = /** @type {string} */ (
+ chunkHash.digest(hashDigest)
+ );
+ hash.update(chunkHashDigest);
+ chunk.hash = chunkHashDigest;
+ chunk.renderedHash = chunk.hash.slice(0, hashDigestLength);
+ const fullHashModules =
+ chunkGraph.getChunkFullHashModulesIterable(chunk);
+ if (fullHashModules) {
+ fullHashChunks.add(chunk);
+ } else {
+ this.hooks.contentHash.call(chunk);
+ }
+ } catch (err) {
+ this.errors.push(new ChunkRenderError(chunk, "", err));
+ }
+ this.logger.timeAggregate("hashing: hash chunks");
+ };
+ otherChunks.forEach(processChunk);
+ for (const chunk of runtimeChunks) processChunk(chunk);
+ if (errors.length > 0) {
+ errors.sort(compareSelect(err => err.module, compareModulesByIdentifier));
+ for (const error of errors) {
+ this.errors.push(error);
+ }
+ }
+
+ this.logger.timeAggregateEnd("hashing: hash runtime modules");
+ this.logger.timeAggregateEnd("hashing: hash chunks");
+ this.logger.time("hashing: hash digest");
+ this.hooks.fullHash.call(hash);
+ this.fullHash = /** @type {string} */ (hash.digest(hashDigest));
+ this.hash = this.fullHash.slice(0, hashDigestLength);
+ this.logger.timeEnd("hashing: hash digest");
+
+ this.logger.time("hashing: process full hash modules");
+ for (const chunk of fullHashChunks) {
+ for (const module of chunkGraph.getChunkFullHashModulesIterable(chunk)) {
+ const moduleHash = createHash(hashFunction);
+ module.updateHash(moduleHash, {
+ chunkGraph,
+ runtime: chunk.runtime,
+ runtimeTemplate
+ });
+ const moduleHashDigest = /** @type {string} */ (
+ moduleHash.digest(hashDigest)
+ );
+ const oldHash = chunkGraph.getModuleHash(module, chunk.runtime);
+ chunkGraph.setModuleHashes(
+ module,
+ chunk.runtime,
+ moduleHashDigest,
+ moduleHashDigest.slice(0, hashDigestLength)
+ );
+ codeGenerationJobsMap.get(oldHash).get(module).hash = moduleHashDigest;
+ }
+ const chunkHash = createHash(hashFunction);
+ chunkHash.update(chunk.hash);
+ chunkHash.update(this.hash);
+ const chunkHashDigest = /** @type {string} */ (
+ chunkHash.digest(hashDigest)
+ );
+ chunk.hash = chunkHashDigest;
+ chunk.renderedHash = chunk.hash.slice(0, hashDigestLength);
+ this.hooks.contentHash.call(chunk);
+ }
+ this.logger.timeEnd("hashing: process full hash modules");
+ return codeGenerationJobs;
+ }
+
+ /**
+ * @param {string} file file name
+ * @param {Source} source asset source
+ * @param {AssetInfo} assetInfo extra asset information
+ * @returns {void}
+ */
+ emitAsset(file, source, assetInfo = {}) {
+ if (this.assets[file]) {
+ if (!isSourceEqual(this.assets[file], source)) {
+ this.errors.push(
+ new WebpackError(
+ `Conflict: Multiple assets emit different content to the same filename ${file}${
+ assetInfo.sourceFilename
+ ? `. Original source ${assetInfo.sourceFilename}`
+ : ""
+ }`
+ )
+ );
+ this.assets[file] = source;
+ this._setAssetInfo(file, assetInfo);
+ return;
+ }
+ const oldInfo = this.assetsInfo.get(file);
+ const newInfo = Object.assign({}, oldInfo, assetInfo);
+ this._setAssetInfo(file, newInfo, oldInfo);
+ return;
+ }
+ this.assets[file] = source;
+ this._setAssetInfo(file, assetInfo, undefined);
+ }
+
+ _setAssetInfo(file, newInfo, oldInfo = this.assetsInfo.get(file)) {
+ if (newInfo === undefined) {
+ this.assetsInfo.delete(file);
+ } else {
+ this.assetsInfo.set(file, newInfo);
+ }
+ const oldRelated = oldInfo && oldInfo.related;
+ const newRelated = newInfo && newInfo.related;
+ if (oldRelated) {
+ for (const key of Object.keys(oldRelated)) {
+ const remove = name => {
+ const relatedIn = this._assetsRelatedIn.get(name);
+ if (relatedIn === undefined) return;
+ const entry = relatedIn.get(key);
+ if (entry === undefined) return;
+ entry.delete(file);
+ if (entry.size !== 0) return;
+ relatedIn.delete(key);
+ if (relatedIn.size === 0) this._assetsRelatedIn.delete(name);
+ };
+ const entry = oldRelated[key];
+ if (Array.isArray(entry)) {
+ entry.forEach(remove);
+ } else if (entry) {
+ remove(entry);
+ }
+ }
+ }
+ if (newRelated) {
+ for (const key of Object.keys(newRelated)) {
+ const add = name => {
+ let relatedIn = this._assetsRelatedIn.get(name);
+ if (relatedIn === undefined) {
+ this._assetsRelatedIn.set(name, (relatedIn = new Map()));
+ }
+ let entry = relatedIn.get(key);
+ if (entry === undefined) {
+ relatedIn.set(key, (entry = new Set()));
+ }
+ entry.add(file);
+ };
+ const entry = newRelated[key];
+ if (Array.isArray(entry)) {
+ entry.forEach(add);
+ } else if (entry) {
+ add(entry);
+ }
+ }
+ }
+ }
+
+ /**
+ * @param {string} file file name
+ * @param {Source | function(Source): Source} newSourceOrFunction new asset source or function converting old to new
+ * @param {AssetInfo | function(AssetInfo | undefined): AssetInfo} assetInfoUpdateOrFunction new asset info or function converting old to new
+ */
+ updateAsset(
+ file,
+ newSourceOrFunction,
+ assetInfoUpdateOrFunction = undefined
+ ) {
+ if (!this.assets[file]) {
+ throw new Error(
+ `Called Compilation.updateAsset for not existing filename ${file}`
+ );
+ }
+ if (typeof newSourceOrFunction === "function") {
+ this.assets[file] = newSourceOrFunction(this.assets[file]);
+ } else {
+ this.assets[file] = newSourceOrFunction;
+ }
+ if (assetInfoUpdateOrFunction !== undefined) {
+ const oldInfo = this.assetsInfo.get(file) || EMPTY_ASSET_INFO;
+ if (typeof assetInfoUpdateOrFunction === "function") {
+ this._setAssetInfo(file, assetInfoUpdateOrFunction(oldInfo), oldInfo);
+ } else {
+ this._setAssetInfo(
+ file,
+ cachedCleverMerge(oldInfo, assetInfoUpdateOrFunction),
+ oldInfo
+ );
+ }
+ }
+ }
+
+ renameAsset(file, newFile) {
+ const source = this.assets[file];
+ if (!source) {
+ throw new Error(
+ `Called Compilation.renameAsset for not existing filename ${file}`
+ );
+ }
+ if (this.assets[newFile]) {
+ if (!isSourceEqual(this.assets[file], source)) {
+ this.errors.push(
+ new WebpackError(
+ `Conflict: Called Compilation.renameAsset for already existing filename ${newFile} with different content`
+ )
+ );
+ }
+ }
+ const assetInfo = this.assetsInfo.get(file);
+ // Update related in all other assets
+ const relatedInInfo = this._assetsRelatedIn.get(file);
+ if (relatedInInfo) {
+ for (const [key, assets] of relatedInInfo) {
+ for (const name of assets) {
+ const info = this.assetsInfo.get(name);
+ if (!info) continue;
+ const related = info.related;
+ if (!related) continue;
+ const entry = related[key];
+ let newEntry;
+ if (Array.isArray(entry)) {
+ newEntry = entry.map(x => (x === file ? newFile : x));
+ } else if (entry === file) {
+ newEntry = newFile;
+ } else continue;
+ this.assetsInfo.set(name, {
+ ...info,
+ related: {
+ ...related,
+ [key]: newEntry
+ }
+ });
+ }
+ }
+ }
+ this._setAssetInfo(file, undefined, assetInfo);
+ this._setAssetInfo(newFile, assetInfo);
+ delete this.assets[file];
+ this.assets[newFile] = source;
+ for (const chunk of this.chunks) {
+ {
+ const size = chunk.files.size;
+ chunk.files.delete(file);
+ if (size !== chunk.files.size) {
+ chunk.files.add(newFile);
+ }
+ }
+ {
+ const size = chunk.auxiliaryFiles.size;
+ chunk.auxiliaryFiles.delete(file);
+ if (size !== chunk.auxiliaryFiles.size) {
+ chunk.auxiliaryFiles.add(newFile);
+ }
+ }
+ }
+ }
+
+ /**
+ * @param {string} file file name
+ */
+ deleteAsset(file) {
+ if (!this.assets[file]) {
+ return;
+ }
+ delete this.assets[file];
+ const assetInfo = this.assetsInfo.get(file);
+ this._setAssetInfo(file, undefined, assetInfo);
+ const related = assetInfo && assetInfo.related;
+ if (related) {
+ for (const key of Object.keys(related)) {
+ const checkUsedAndDelete = file => {
+ if (!this._assetsRelatedIn.has(file)) {
+ this.deleteAsset(file);
+ }
+ };
+ const items = related[key];
+ if (Array.isArray(items)) {
+ items.forEach(checkUsedAndDelete);
+ } else if (items) {
+ checkUsedAndDelete(items);
+ }
+ }
+ }
+ // TODO If this becomes a performance problem
+ // store a reverse mapping from asset to chunk
+ for (const chunk of this.chunks) {
+ chunk.files.delete(file);
+ chunk.auxiliaryFiles.delete(file);
+ }
+ }
+
+ getAssets() {
+ /** @type {Readonly<Asset>[]} */
+ const array = [];
+ for (const assetName of Object.keys(this.assets)) {
+ if (Object.prototype.hasOwnProperty.call(this.assets, assetName)) {
+ array.push({
+ name: assetName,
+ source: this.assets[assetName],
+ info: this.assetsInfo.get(assetName) || EMPTY_ASSET_INFO
+ });
+ }
+ }
+ return array;
+ }
+
+ /**
+ * @param {string} name the name of the asset
+ * @returns {Readonly<Asset> | undefined} the asset or undefined when not found
+ */
+ getAsset(name) {
+ if (!Object.prototype.hasOwnProperty.call(this.assets, name))
+ return undefined;
+ return {
+ name,
+ source: this.assets[name],
+ info: this.assetsInfo.get(name) || EMPTY_ASSET_INFO
+ };
+ }
+
+ clearAssets() {
+ for (const chunk of this.chunks) {
+ chunk.files.clear();
+ chunk.auxiliaryFiles.clear();
+ }
+ }
+
+ createModuleAssets() {
+ const { chunkGraph } = this;
+ for (const module of this.modules) {
+ if (module.buildInfo.assets) {
+ const assetsInfo = module.buildInfo.assetsInfo;
+ for (const assetName of Object.keys(module.buildInfo.assets)) {
+ const fileName = this.getPath(assetName, {
+ chunkGraph: this.chunkGraph,
+ module
+ });
+ for (const chunk of chunkGraph.getModuleChunksIterable(module)) {
+ chunk.auxiliaryFiles.add(fileName);
+ }
+ this.emitAsset(
+ fileName,
+ module.buildInfo.assets[assetName],
+ assetsInfo ? assetsInfo.get(assetName) : undefined
+ );
+ this.hooks.moduleAsset.call(module, fileName);
+ }
+ }
+ }
+ }
+
+ /**
+ * @param {RenderManifestOptions} options options object
+ * @returns {RenderManifestEntry[]} manifest entries
+ */
+ getRenderManifest(options) {
+ return this.hooks.renderManifest.call([], options);
+ }
+
+ /**
+ * @param {Callback} callback signals when the call finishes
+ * @returns {void}
+ */
+ createChunkAssets(callback) {
+ const outputOptions = this.outputOptions;
+ const cachedSourceMap = new WeakMap();
+ /** @type {Map<string, {hash: string, source: Source, chunk: Chunk}>} */
+ const alreadyWrittenFiles = new Map();
+
+ asyncLib.forEachLimit(
+ this.chunks,
+ 15,
+ (chunk, callback) => {
+ /** @type {RenderManifestEntry[]} */
+ let manifest;
+ try {
+ manifest = this.getRenderManifest({
+ chunk,
+ hash: this.hash,
+ fullHash: this.fullHash,
+ outputOptions,
+ codeGenerationResults: this.codeGenerationResults,
+ moduleTemplates: this.moduleTemplates,
+ dependencyTemplates: this.dependencyTemplates,
+ chunkGraph: this.chunkGraph,
+ moduleGraph: this.moduleGraph,
+ runtimeTemplate: this.runtimeTemplate
+ });
+ } catch (err) {
+ this.errors.push(new ChunkRenderError(chunk, "", err));
+ return callback();
+ }
+ asyncLib.forEach(
+ manifest,
+ (fileManifest, callback) => {
+ const ident = fileManifest.identifier;
+ const usedHash = fileManifest.hash;
+
+ const assetCacheItem = this._assetsCache.getItemCache(
+ ident,
+ usedHash
+ );
+
+ assetCacheItem.get((err, sourceFromCache) => {
+ /** @type {string | function(PathData, AssetInfo=): string} */
+ let filenameTemplate;
+ /** @type {string} */
+ let file;
+ /** @type {AssetInfo} */
+ let assetInfo;
+
+ let inTry = true;
+ const errorAndCallback = err => {
+ const filename =
+ file ||
+ (typeof file === "string"
+ ? file
+ : typeof filenameTemplate === "string"
+ ? filenameTemplate
+ : "");
+
+ this.errors.push(new ChunkRenderError(chunk, filename, err));
+ inTry = false;
+ return callback();
+ };
+
+ try {
+ if ("filename" in fileManifest) {
+ file = fileManifest.filename;
+ assetInfo = fileManifest.info;
+ } else {
+ filenameTemplate = fileManifest.filenameTemplate;
+ const pathAndInfo = this.getPathWithInfo(
+ filenameTemplate,
+ fileManifest.pathOptions
+ );
+ file = pathAndInfo.path;
+ assetInfo = fileManifest.info
+ ? {
+ ...pathAndInfo.info,
+ ...fileManifest.info
+ }
+ : pathAndInfo.info;
+ }
+
+ if (err) {
+ return errorAndCallback(err);
+ }
+
+ let source = sourceFromCache;
+
+ // check if the same filename was already written by another chunk
+ const alreadyWritten = alreadyWrittenFiles.get(file);
+ if (alreadyWritten !== undefined) {
+ if (alreadyWritten.hash !== usedHash) {
+ inTry = false;
+ return callback(
+ new WebpackError(
+ `Conflict: Multiple chunks emit assets to the same filename ${file}` +
+ ` (chunks ${alreadyWritten.chunk.id} and ${chunk.id})`
+ )
+ );
+ } else {
+ source = alreadyWritten.source;
+ }
+ } else if (!source) {
+ // render the asset
+ source = fileManifest.render();
+
+ // Ensure that source is a cached source to avoid additional cost because of repeated access
+ if (!(source instanceof CachedSource)) {
+ const cacheEntry = cachedSourceMap.get(source);
+ if (cacheEntry) {
+ source = cacheEntry;
+ } else {
+ const cachedSource = new CachedSource(source);
+ cachedSourceMap.set(source, cachedSource);
+ source = cachedSource;
+ }
+ }
+ }
+ this.emitAsset(file, source, assetInfo);
+ if (fileManifest.auxiliary) {
+ chunk.auxiliaryFiles.add(file);
+ } else {
+ chunk.files.add(file);
+ }
+ this.hooks.chunkAsset.call(chunk, file);
+ alreadyWrittenFiles.set(file, {
+ hash: usedHash,
+ source,
+ chunk
+ });
+ if (source !== sourceFromCache) {
+ assetCacheItem.store(source, err => {
+ if (err) return errorAndCallback(err);
+ inTry = false;
+ return callback();
+ });
+ } else {
+ inTry = false;
+ callback();
+ }
+ } catch (err) {
+ if (!inTry) throw err;
+ errorAndCallback(err);
+ }
+ });
+ },
+ callback
+ );
+ },
+ callback
+ );
+ }
+
+ /**
+ * @param {string | function(PathData, AssetInfo=): string} filename used to get asset path with hash
+ * @param {PathData} data context data
+ * @returns {string} interpolated path
+ */
+ getPath(filename, data = {}) {
+ if (!data.hash) {
+ data = {
+ hash: this.hash,
+ ...data
+ };
+ }
+ return this.getAssetPath(filename, data);
+ }
+
+ /**
+ * @param {string | function(PathData, AssetInfo=): string} filename used to get asset path with hash
+ * @param {PathData} data context data
+ * @returns {{ path: string, info: AssetInfo }} interpolated path and asset info
+ */
+ getPathWithInfo(filename, data = {}) {
+ if (!data.hash) {
+ data = {
+ hash: this.hash,
+ ...data
+ };
+ }
+ return this.getAssetPathWithInfo(filename, data);
+ }
+
+ /**
+ * @param {string | function(PathData, AssetInfo=): string} filename used to get asset path with hash
+ * @param {PathData} data context data
+ * @returns {string} interpolated path
+ */
+ getAssetPath(filename, data) {
+ return this.hooks.assetPath.call(
+ typeof filename === "function" ? filename(data) : filename,
+ data,
+ undefined
+ );
+ }
+
+ /**
+ * @param {string | function(PathData, AssetInfo=): string} filename used to get asset path with hash
+ * @param {PathData} data context data
+ * @returns {{ path: string, info: AssetInfo }} interpolated path and asset info
+ */
+ getAssetPathWithInfo(filename, data) {
+ const assetInfo = {};
+ // TODO webpack 5: refactor assetPath hook to receive { path, info } object
+ const newPath = this.hooks.assetPath.call(
+ typeof filename === "function" ? filename(data, assetInfo) : filename,
+ data,
+ assetInfo
+ );
+ return { path: newPath, info: assetInfo };
+ }
+
+ getWarnings() {
+ return this.hooks.processWarnings.call(this.warnings);
+ }
+
+ getErrors() {
+ return this.hooks.processErrors.call(this.errors);
+ }
+
+ /**
+ * This function allows you to run another instance of webpack inside of webpack however as
+ * a child with different settings and configurations (if desired) applied. It copies all hooks, plugins
+ * from parent (or top level compiler) and creates a child Compilation
+ *
+ * @param {string} name name of the child compiler
+ * @param {OutputOptions=} outputOptions // Need to convert config schema to types for this
+ * @param {Array<WebpackPluginInstance | WebpackPluginFunction>=} plugins webpack plugins that will be applied
+ * @returns {Compiler} creates a child Compiler instance
+ */
+ createChildCompiler(name, outputOptions, plugins) {
+ const idx = this.childrenCounters[name] || 0;
+ this.childrenCounters[name] = idx + 1;
+ return this.compiler.createChildCompiler(
+ this,
+ name,
+ idx,
+ outputOptions,
+ plugins
+ );
+ }
+
+ /**
+ * @param {Module} module the module
+ * @param {ExecuteModuleOptions} options options
+ * @param {ExecuteModuleCallback} callback callback
+ */
+ executeModule(module, options, callback) {
+ // Aggregate all referenced modules and ensure they are ready
+ const modules = new Set([module]);
+ processAsyncTree(
+ modules,
+ 10,
+ /**
+ * @param {Module} module the module
+ * @param {function(Module): void} push push more jobs
+ * @param {Callback} callback callback
+ * @returns {void}
+ */
+ (module, push, callback) => {
+ this.buildQueue.waitFor(module, err => {
+ if (err) return callback(err);
+ this.processDependenciesQueue.waitFor(module, err => {
+ if (err) return callback(err);
+ for (const { module: m } of this.moduleGraph.getOutgoingConnections(
+ module
+ )) {
+ const size = modules.size;
+ modules.add(m);
+ if (modules.size !== size) push(m);
+ }
+ callback();
+ });
+ });
+ },
+ err => {
+ if (err) return callback(err);
+
+ // Create new chunk graph, chunk and entrypoint for the build time execution
+ const chunkGraph = new ChunkGraph(
+ this.moduleGraph,
+ this.outputOptions.hashFunction
+ );
+ const runtime = "build time";
+ const { hashFunction, hashDigest, hashDigestLength } =
+ this.outputOptions;
+ const runtimeTemplate = this.runtimeTemplate;
+
+ const chunk = new Chunk("build time chunk", this._backCompat);
+ chunk.id = chunk.name;
+ chunk.ids = [chunk.id];
+ chunk.runtime = runtime;
+
+ const entrypoint = new Entrypoint({
+ runtime,
+ chunkLoading: false,
+ ...options.entryOptions
+ });
+ chunkGraph.connectChunkAndEntryModule(chunk, module, entrypoint);
+ connectChunkGroupAndChunk(entrypoint, chunk);
+ entrypoint.setRuntimeChunk(chunk);
+ entrypoint.setEntrypointChunk(chunk);
+
+ const chunks = new Set([chunk]);
+
+ // Assign ids to modules and modules to the chunk
+ for (const module of modules) {
+ const id = module.identifier();
+ chunkGraph.setModuleId(module, id);
+ chunkGraph.connectChunkAndModule(chunk, module);
+ }
+
+ /** @type {WebpackError[]} */
+ const errors = [];
+
+ // Hash modules
+ for (const module of modules) {
+ this._createModuleHash(
+ module,
+ chunkGraph,
+ runtime,
+ hashFunction,
+ runtimeTemplate,
+ hashDigest,
+ hashDigestLength,
+ errors
+ );
+ }
+
+ const codeGenerationResults = new CodeGenerationResults(
+ this.outputOptions.hashFunction
+ );
+ /**
+ * @param {Module} module the module
+ * @param {Callback} callback callback
+ * @returns {void}
+ */
+ const codeGen = (module, callback) => {
+ this._codeGenerationModule(
+ module,
+ runtime,
+ [runtime],
+ chunkGraph.getModuleHash(module, runtime),
+ this.dependencyTemplates,
+ chunkGraph,
+ this.moduleGraph,
+ runtimeTemplate,
+ errors,
+ codeGenerationResults,
+ (err, codeGenerated) => {
+ callback(err);
+ }
+ );
+ };
+
+ const reportErrors = () => {
+ if (errors.length > 0) {
+ errors.sort(
+ compareSelect(err => err.module, compareModulesByIdentifier)
+ );
+ for (const error of errors) {
+ this.errors.push(error);
+ }
+ errors.length = 0;
+ }
+ };
+
+ // Generate code for all aggregated modules
+ asyncLib.eachLimit(modules, 10, codeGen, err => {
+ if (err) return callback(err);
+ reportErrors();
+
+ // for backward-compat temporary set the chunk graph
+ // TODO webpack 6
+ const old = this.chunkGraph;
+ this.chunkGraph = chunkGraph;
+ this.processRuntimeRequirements({
+ chunkGraph,
+ modules,
+ chunks,
+ codeGenerationResults,
+ chunkGraphEntries: chunks
+ });
+ this.chunkGraph = old;
+
+ const runtimeModules =
+ chunkGraph.getChunkRuntimeModulesIterable(chunk);
+
+ // Hash runtime modules
+ for (const module of runtimeModules) {
+ modules.add(module);
+ this._createModuleHash(
+ module,
+ chunkGraph,
+ runtime,
+ hashFunction,
+ runtimeTemplate,
+ hashDigest,
+ hashDigestLength
+ );
+ }
+
+ // Generate code for all runtime modules
+ asyncLib.eachLimit(runtimeModules, 10, codeGen, err => {
+ if (err) return callback(err);
+ reportErrors();
+
+ /** @type {Map<Module, ExecuteModuleArgument>} */
+ const moduleArgumentsMap = new Map();
+ /** @type {Map<string, ExecuteModuleArgument>} */
+ const moduleArgumentsById = new Map();
+
+ /** @type {ExecuteModuleResult["fileDependencies"]} */
+ const fileDependencies = new LazySet();
+ /** @type {ExecuteModuleResult["contextDependencies"]} */
+ const contextDependencies = new LazySet();
+ /** @type {ExecuteModuleResult["missingDependencies"]} */
+ const missingDependencies = new LazySet();
+ /** @type {ExecuteModuleResult["buildDependencies"]} */
+ const buildDependencies = new LazySet();
+
+ /** @type {ExecuteModuleResult["assets"]} */
+ const assets = new Map();
+
+ let cacheable = true;
+
+ /** @type {ExecuteModuleContext} */
+ const context = {
+ assets,
+ __webpack_require__: undefined,
+ chunk,
+ chunkGraph
+ };
+
+ // Prepare execution
+ asyncLib.eachLimit(
+ modules,
+ 10,
+ (module, callback) => {
+ const codeGenerationResult = codeGenerationResults.get(
+ module,
+ runtime
+ );
+ /** @type {ExecuteModuleArgument} */
+ const moduleArgument = {
+ module,
+ codeGenerationResult,
+ preparedInfo: undefined,
+ moduleObject: undefined
+ };
+ moduleArgumentsMap.set(module, moduleArgument);
+ moduleArgumentsById.set(module.identifier(), moduleArgument);
+ module.addCacheDependencies(
+ fileDependencies,
+ contextDependencies,
+ missingDependencies,
+ buildDependencies
+ );
+ if (module.buildInfo.cacheable === false) {
+ cacheable = false;
+ }
+ if (module.buildInfo && module.buildInfo.assets) {
+ const { assets: moduleAssets, assetsInfo } = module.buildInfo;
+ for (const assetName of Object.keys(moduleAssets)) {
+ assets.set(assetName, {
+ source: moduleAssets[assetName],
+ info: assetsInfo ? assetsInfo.get(assetName) : undefined
+ });
+ }
+ }
+ this.hooks.prepareModuleExecution.callAsync(
+ moduleArgument,
+ context,
+ callback
+ );
+ },
+ err => {
+ if (err) return callback(err);
+
+ let exports;
+ try {
+ const {
+ strictModuleErrorHandling,
+ strictModuleExceptionHandling
+ } = this.outputOptions;
+ const __webpack_require__ = id => {
+ const cached = moduleCache[id];
+ if (cached !== undefined) {
+ if (cached.error) throw cached.error;
+ return cached.exports;
+ }
+ const moduleArgument = moduleArgumentsById.get(id);
+ return __webpack_require_module__(moduleArgument, id);
+ };
+ const interceptModuleExecution = (__webpack_require__[
+ RuntimeGlobals.interceptModuleExecution.replace(
+ `${RuntimeGlobals.require}.`,
+ ""
+ )
+ ] = []);
+ const moduleCache = (__webpack_require__[
+ RuntimeGlobals.moduleCache.replace(
+ `${RuntimeGlobals.require}.`,
+ ""
+ )
+ ] = {});
+
+ context.__webpack_require__ = __webpack_require__;
+
+ /**
+ * @param {ExecuteModuleArgument} moduleArgument the module argument
+ * @param {string=} id id
+ * @returns {any} exports
+ */
+ const __webpack_require_module__ = (moduleArgument, id) => {
+ var execOptions = {
+ id,
+ module: {
+ id,
+ exports: {},
+ loaded: false,
+ error: undefined
+ },
+ require: __webpack_require__
+ };
+ interceptModuleExecution.forEach(handler =>
+ handler(execOptions)
+ );
+ const module = moduleArgument.module;
+ this.buildTimeExecutedModules.add(module);
+ const moduleObject = execOptions.module;
+ moduleArgument.moduleObject = moduleObject;
+ try {
+ if (id) moduleCache[id] = moduleObject;
+
+ tryRunOrWebpackError(
+ () =>
+ this.hooks.executeModule.call(
+ moduleArgument,
+ context
+ ),
+ "Compilation.hooks.executeModule"
+ );
+ moduleObject.loaded = true;
+ return moduleObject.exports;
+ } catch (e) {
+ if (strictModuleExceptionHandling) {
+ if (id) delete moduleCache[id];
+ } else if (strictModuleErrorHandling) {
+ moduleObject.error = e;
+ }
+ if (!e.module) e.module = module;
+ throw e;
+ }
+ };
+
+ for (const runtimeModule of chunkGraph.getChunkRuntimeModulesInOrder(
+ chunk
+ )) {
+ __webpack_require_module__(
+ moduleArgumentsMap.get(runtimeModule)
+ );
+ }
+ exports = __webpack_require__(module.identifier());
+ } catch (e) {
+ const err = new WebpackError(
+ `Execution of module code from module graph (${module.readableIdentifier(
+ this.requestShortener
+ )}) failed: ${e.message}`
+ );
+ err.stack = e.stack;
+ err.module = e.module;
+ return callback(err);
+ }
+
+ callback(null, {
+ exports,
+ assets,
+ cacheable,
+ fileDependencies,
+ contextDependencies,
+ missingDependencies,
+ buildDependencies
+ });
+ }
+ );
+ });
+ });
+ }
+ );
+ }
+
+ checkConstraints() {
+ const chunkGraph = this.chunkGraph;
+
+ /** @type {Set<number|string>} */
+ const usedIds = new Set();
+
+ for (const module of this.modules) {
+ if (module.type === WEBPACK_MODULE_TYPE_RUNTIME) continue;
+ const moduleId = chunkGraph.getModuleId(module);
+ if (moduleId === null) continue;
+ if (usedIds.has(moduleId)) {
+ throw new Error(`checkConstraints: duplicate module id ${moduleId}`);
+ }
+ usedIds.add(moduleId);
+ }
+
+ for (const chunk of this.chunks) {
+ for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
+ if (!this.modules.has(module)) {
+ throw new Error(
+ "checkConstraints: module in chunk but not in compilation " +
+ ` ${chunk.debugId} ${module.debugId}`
+ );
+ }
+ }
+ for (const module of chunkGraph.getChunkEntryModulesIterable(chunk)) {
+ if (!this.modules.has(module)) {
+ throw new Error(
+ "checkConstraints: entry module in chunk but not in compilation " +
+ ` ${chunk.debugId} ${module.debugId}`
+ );
+ }
+ }
+ }
+
+ for (const chunkGroup of this.chunkGroups) {
+ chunkGroup.checkConstraints();
+ }
+ }
+}
+
+/**
+ * @typedef {Object} FactorizeModuleOptions
+ * @property {ModuleProfile} currentProfile
+ * @property {ModuleFactory} factory
+ * @property {Dependency[]} dependencies
+ * @property {boolean=} factoryResult return full ModuleFactoryResult instead of only module
+ * @property {Module | null} originModule
+ * @property {Partial<ModuleFactoryCreateDataContextInfo>=} contextInfo
+ * @property {string=} context
+ */
+
+/**
+ * @param {FactorizeModuleOptions} options options object
+ * @param {ModuleCallback | ModuleFactoryResultCallback} callback callback
+ * @returns {void}
+ */
+
+// Workaround for typescript as it doesn't support function overloading in jsdoc within a class
+Compilation.prototype.factorizeModule = /** @type {{
+ (options: FactorizeModuleOptions & { factoryResult?: false }, callback: ModuleCallback): void;
+ (options: FactorizeModuleOptions & { factoryResult: true }, callback: ModuleFactoryResultCallback): void;
+}} */ (
+ function (options, callback) {
+ this.factorizeQueue.add(options, callback);
+ }
+);
+
+// Hide from typescript
+const compilationPrototype = Compilation.prototype;
+
+// TODO webpack 6 remove
+Object.defineProperty(compilationPrototype, "modifyHash", {
+ writable: false,
+ enumerable: false,
+ configurable: false,
+ value: () => {
+ throw new Error(
+ "Compilation.modifyHash was removed in favor of Compilation.hooks.fullHash"
+ );
+ }
+});
+
+// TODO webpack 6 remove
+Object.defineProperty(compilationPrototype, "cache", {
+ enumerable: false,
+ configurable: false,
+ get: util.deprecate(
+ /**
+ * @this {Compilation} the compilation
+ * @returns {Cache} the cache
+ */
+ function () {
+ return this.compiler.cache;
+ },
+ "Compilation.cache was removed in favor of Compilation.getCache()",
+ "DEP_WEBPACK_COMPILATION_CACHE"
+ ),
+ set: util.deprecate(
+ v => {},
+ "Compilation.cache was removed in favor of Compilation.getCache()",
+ "DEP_WEBPACK_COMPILATION_CACHE"
+ )
+});
+
+/**
+ * Add additional assets to the compilation.
+ */
+Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL = -2000;
+
+/**
+ * Basic preprocessing of assets.
+ */
+Compilation.PROCESS_ASSETS_STAGE_PRE_PROCESS = -1000;
+
+/**
+ * Derive new assets from existing assets.
+ * Existing assets should not be treated as complete.
+ */
+Compilation.PROCESS_ASSETS_STAGE_DERIVED = -200;
+
+/**
+ * Add additional sections to existing assets, like a banner or initialization code.
+ */
+Compilation.PROCESS_ASSETS_STAGE_ADDITIONS = -100;
+
+/**
+ * Optimize existing assets in a general way.
+ */
+Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE = 100;
+
+/**
+ * Optimize the count of existing assets, e. g. by merging them.
+ * Only assets of the same type should be merged.
+ * For assets of different types see PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE.
+ */
+Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_COUNT = 200;
+
+/**
+ * Optimize the compatibility of existing assets, e. g. add polyfills or vendor-prefixes.
+ */
+Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_COMPATIBILITY = 300;
+
+/**
+ * Optimize the size of existing assets, e. g. by minimizing or omitting whitespace.
+ */
+Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE = 400;
+
+/**
+ * Add development tooling to assets, e. g. by extracting a SourceMap.
+ */
+Compilation.PROCESS_ASSETS_STAGE_DEV_TOOLING = 500;
+
+/**
+ * Optimize the count of existing assets, e. g. by inlining assets of into other assets.
+ * Only assets of different types should be inlined.
+ * For assets of the same type see PROCESS_ASSETS_STAGE_OPTIMIZE_COUNT.
+ */
+Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE = 700;
+
+/**
+ * Summarize the list of existing assets
+ * e. g. creating an assets manifest of Service Workers.
+ */
+Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE = 1000;
+
+/**
+ * Optimize the hashes of the assets, e. g. by generating real hashes of the asset content.
+ */
+Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_HASH = 2500;
+
+/**
+ * Optimize the transfer of existing assets, e. g. by preparing a compressed (gzip) file as separate asset.
+ */
+Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER = 3000;
+
+/**
+ * Analyse existing assets.
+ */
+Compilation.PROCESS_ASSETS_STAGE_ANALYSE = 4000;
+
+/**
+ * Creating assets for reporting purposes.
+ */
+Compilation.PROCESS_ASSETS_STAGE_REPORT = 5000;
+
+module.exports = Compilation;
generated by cgit v1.2.3 (git 2.25.1) at 2026-11-01 16:14:24 +0000