mcarman
/
React_Client_App_Access
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2 Commits
1 Branch
84 MiB
 
 
 
 
Tree: f190052c12
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f190052c12'
${ noResults }
React_Client_App_Access/node_modules/webpack/lib/Compilation.js

2514 lines
71 KiB
Raw Blame History 

  1. /*

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

  3. 	Author Tobias Koppers @sokra

  4. 	*/

  5. "use strict";

  6. 

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

  8. const util = require("util");

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

  10. const {

  11. 	Tapable,

  12. 	SyncHook,

  13. 	SyncBailHook,

  14. 	SyncWaterfallHook,

  15. 	AsyncSeriesHook

  16. } = require("tapable");

  17. const EntryModuleNotFoundError = require("./EntryModuleNotFoundError");

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

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

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

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

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

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

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

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

  26. const HotUpdateChunkTemplate = require("./HotUpdateChunkTemplate");

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

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

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

  30. const AsyncDependencyToInitialChunkError = require("./AsyncDependencyToInitialChunkError");

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

  32. const Semaphore = require("./util/Semaphore");

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

  34. const Queue = require("./util/Queue");

  35. const SortableSet = require("./util/SortableSet");

  36. const GraphHelpers = require("./GraphHelpers");

  37. const ModuleDependency = require("./dependencies/ModuleDependency");

  38. const compareLocations = require("./compareLocations");

  39. 

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

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

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

  43. /** @typedef {import("./WebpackError")} WebpackError */

  44. /** @typedef {import("./DependenciesBlockVariable")} DependenciesBlockVariable */

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

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

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

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

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

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

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

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

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

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

  55. 

  56. // TODO use @callback

  57. /** @typedef {{[assetName: string]: Source}} CompilationAssets */

  58. /** @typedef {(err: Error|null, result?: Module) => void } ModuleCallback */

  59. /** @typedef {(err?: Error|null, result?: Module) => void } ModuleChainCallback */

  60. /** @typedef {(module: Module) => void} OnModuleCallback */

  61. /** @typedef {(err?: Error|null) => void} Callback */

  62. /** @typedef {(d: Dependency) => any} DepBlockVarDependenciesCallback */

  63. /** @typedef {new (...args: any[]) => Dependency} DepConstructor */

  64. /** @typedef {{apply: () => void}} Plugin */

  65. 

  66. /**

  67.  * @typedef {Object} ModuleFactoryCreateDataContextInfo

  68.  * @property {string} issuer

  69.  * @property {string} compiler

  70.  */

  71. 

  72. /**

  73.  * @typedef {Object} ModuleFactoryCreateData

  74.  * @property {ModuleFactoryCreateDataContextInfo} contextInfo

  75.  * @property {any=} resolveOptions

  76.  * @property {string} context

  77.  * @property {Dependency[]} dependencies

  78.  */

  79. 

  80. /**

  81.  * @typedef {Object} ModuleFactory

  82.  * @property {(data: ModuleFactoryCreateData, callback: ModuleCallback) => any} create

  83.  */

  84. 

  85. /**

  86.  * @typedef {Object} SortedDependency

  87.  * @property {ModuleFactory} factory

  88.  * @property {Dependency[]} dependencies

  89.  */

  90. 

  91. /**

  92.  * @typedef {Object} AvailableModulesChunkGroupMapping

  93.  * @property {ChunkGroup} chunkGroup

  94.  * @property {Set<Module>} availableModules

  95.  */

  96. 

  97. /**

  98.  * @typedef {Object} DependenciesBlockLike

  99.  * @property {Dependency[]} dependencies

  100.  * @property {AsyncDependenciesBlock[]} blocks

  101.  * @property {DependenciesBlockVariable[]} variables

  102.  */

  103. 

  104. /**

  105.  * @param {Chunk} a first chunk to sort by id

  106.  * @param {Chunk} b second chunk to sort by id

  107.  * @returns {-1|0|1} sort value

  108.  */

  109. const byId = (a, b) => {

  110. 	if (a.id !== null && b.id !== null) {

  111. 		if (a.id < b.id) return -1;

  112. 		if (a.id > b.id) return 1;

  113. 	}

  114. 	return 0;

  115. };

  116. 

  117. /**

  118.  * @param {Module} a first module to sort by

  119.  * @param {Module} b second module to sort by

  120.  * @returns {-1|0|1} sort value

  121.  */

  122. const byIdOrIdentifier = (a, b) => {

  123. 	if (a.id < b.id) return -1;

  124. 	if (a.id > b.id) return 1;

  125. 	const identA = a.identifier();

  126. 	const identB = b.identifier();

  127. 	if (identA < identB) return -1;

  128. 	if (identA > identB) return 1;

  129. 	return 0;

  130. };

  131. 

  132. /**

  133.  * @param {Module} a first module to sort by

  134.  * @param {Module} b second module to sort by

  135.  * @returns {-1|0|1} sort value

  136.  */

  137. const byIndexOrIdentifier = (a, b) => {

  138. 	if (a.index < b.index) return -1;

  139. 	if (a.index > b.index) return 1;

  140. 	const identA = a.identifier();

  141. 	const identB = b.identifier();

  142. 	if (identA < identB) return -1;

  143. 	if (identA > identB) return 1;

  144. 	return 0;

  145. };

  146. 

  147. /**

  148.  * @param {Compilation} a first compilation to sort by

  149.  * @param {Compilation} b second compilation to sort by

  150.  * @returns {-1|0|1} sort value

  151.  */

  152. const byNameOrHash = (a, b) => {

  153. 	if (a.name < b.name) return -1;

  154. 	if (a.name > b.name) return 1;

  155. 	if (a.fullHash < b.fullHash) return -1;

  156. 	if (a.fullHash > b.fullHash) return 1;

  157. 	return 0;

  158. };

  159. 

  160. /**

  161.  * @param {DependenciesBlockVariable[]} variables DepBlock Variables to iterate over

  162.  * @param {DepBlockVarDependenciesCallback} fn callback to apply on iterated elements

  163.  * @returns {void}

  164.  */

  165. const iterationBlockVariable = (variables, fn) => {

  166. 	for (

  167. 		let indexVariable = 0;

  168. 		indexVariable < variables.length;

  169. 		indexVariable++

  170. 	) {

  171. 		const varDep = variables[indexVariable].dependencies;

  172. 		for (let indexVDep = 0; indexVDep < varDep.length; indexVDep++) {

  173. 			fn(varDep[indexVDep]);

  174. 		}

  175. 	}

  176. };

  177. 

  178. /**

  179.  * @template T

  180.  * @param {T[]} arr array of elements to iterate over

  181.  * @param {function(T): void} fn callback applied to each element

  182.  * @returns {void}

  183.  */

  184. const iterationOfArrayCallback = (arr, fn) => {

  185. 	for (let index = 0; index < arr.length; index++) {

  186. 		fn(arr[index]);

  187. 	}

  188. };

  189. 

  190. /**

  191.  * @template T

  192.  * @param {Set<T>} set set to add items to

  193.  * @param {Set<T>} otherSet set to add items from

  194.  * @returns {void}

  195.  */

  196. const addAllToSet = (set, otherSet) => {

  197. 	for (const item of otherSet) {

  198. 		set.add(item);

  199. 	}

  200. };

  201. 

  202. class Compilation extends Tapable {

  203. 	/**

  204. 	 * Creates an instance of Compilation.

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

  206. 	 */

  207. 	constructor(compiler) {

  208. 		super();

  209. 		this.hooks = {

  210. 			/** @type {SyncHook<Module>} */

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

  212. 			/** @type {SyncHook<Module>} */

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

  214. 			/** @type {SyncHook<Module, Error>} */

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

  216. 			/** @type {SyncHook<Module>} */

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

  218. 

  219. 			/** @type {SyncWaterfallHook<DependencyReference, Dependency, Module>} */

  220. 			dependencyReference: new SyncWaterfallHook([

  221. 				"dependencyReference",

  222. 				"dependency",

  223. 				"module"

  224. 			]),

  225. 

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

  227. 			finishModules: new SyncHook(["modules"]),

  228. 			/** @type {SyncHook<Module>} */

  229. 			finishRebuildingModule: new SyncHook(["module"]),

  230. 			/** @type {SyncHook} */

  231. 			unseal: new SyncHook([]),

  232. 			/** @type {SyncHook} */

  233. 			seal: new SyncHook([]),

  234. 

  235. 			/** @type {SyncHook} */

  236. 			beforeChunks: new SyncHook([]),

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

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

  239. 

  240. 			/** @type {SyncBailHook<Module[]>} */

  241. 			optimizeDependenciesBasic: new SyncBailHook(["modules"]),

  242. 			/** @type {SyncBailHook<Module[]>} */

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

  244. 			/** @type {SyncBailHook<Module[]>} */

  245. 			optimizeDependenciesAdvanced: new SyncBailHook(["modules"]),

  246. 			/** @type {SyncBailHook<Module[]>} */

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

  248. 

  249. 			/** @type {SyncHook} */

  250. 			optimize: new SyncHook([]),

  251. 			/** @type {SyncBailHook<Module[]>} */

  252. 			optimizeModulesBasic: new SyncBailHook(["modules"]),

  253. 			/** @type {SyncBailHook<Module[]>} */

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

  255. 			/** @type {SyncBailHook<Module[]>} */

  256. 			optimizeModulesAdvanced: new SyncBailHook(["modules"]),

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

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

  259. 

  260. 			/** @type {SyncBailHook<Chunk[], ChunkGroup[]>} */

  261. 			optimizeChunksBasic: new SyncBailHook(["chunks", "chunkGroups"]),

  262. 			/** @type {SyncBailHook<Chunk[], ChunkGroup[]>} */

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

  264. 			/** @type {SyncBailHook<Chunk[], ChunkGroup[]>} */

  265. 			optimizeChunksAdvanced: new SyncBailHook(["chunks", "chunkGroups"]),

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

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

  268. 

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

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

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

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

  273. 

  274. 			/** @type {SyncBailHook<Chunk[], Module[]>} */

  275. 			optimizeChunkModulesBasic: new SyncBailHook(["chunks", "modules"]),

  276. 			/** @type {SyncBailHook<Chunk[], Module[]>} */

  277. 			optimizeChunkModules: new SyncBailHook(["chunks", "modules"]),

  278. 			/** @type {SyncBailHook<Chunk[], Module[]>} */

  279. 			optimizeChunkModulesAdvanced: new SyncBailHook(["chunks", "modules"]),

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

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

  282. 			/** @type {SyncBailHook} */

  283. 			shouldRecord: new SyncBailHook([]),

  284. 

  285. 			/** @type {SyncHook<Module[], any>} */

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

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

  288. 			optimizeModuleOrder: new SyncHook(["modules"]),

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

  290. 			advancedOptimizeModuleOrder: new SyncHook(["modules"]),

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

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

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

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

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

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

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

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

  299. 

  300. 			/** @type {SyncHook<Chunk[], any>} */

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

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

  303. 			optimizeChunkOrder: new SyncHook(["chunks"]),

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

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

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

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

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

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

  310. 

  311. 			/** @type {SyncHook<Module[], any>} */

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

  313. 			/** @type {SyncHook<Chunk[], any>} */

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

  315. 

  316. 			/** @type {SyncHook} */

  317. 			beforeHash: new SyncHook([]),

  318. 			/** @type {SyncHook<Chunk>} */

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

  320. 			/** @type {SyncHook} */

  321. 			afterHash: new SyncHook([]),

  322. 			/** @type {SyncHook<any>} */

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

  324. 			/** @type {SyncHook<Compilation, any>} */

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

  326. 

  327. 			/** @type {SyncHook} */

  328. 			beforeModuleAssets: new SyncHook([]),

  329. 			/** @type {SyncBailHook} */

  330. 			shouldGenerateChunkAssets: new SyncBailHook([]),

  331. 			/** @type {SyncHook} */

  332. 			beforeChunkAssets: new SyncHook([]),

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

  334. 			additionalChunkAssets: new SyncHook(["chunks"]),

  335. 

  336. 			/** @type {AsyncSeriesHook} */

  337. 			additionalAssets: new AsyncSeriesHook([]),

  338. 			/** @type {AsyncSeriesHook<Chunk[]>} */

  339. 			optimizeChunkAssets: new AsyncSeriesHook(["chunks"]),

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

  341. 			afterOptimizeChunkAssets: new SyncHook(["chunks"]),

  342. 			/** @type {AsyncSeriesHook<CompilationAssets>} */

  343. 			optimizeAssets: new AsyncSeriesHook(["assets"]),

  344. 			/** @type {SyncHook<CompilationAssets>} */

  345. 			afterOptimizeAssets: new SyncHook(["assets"]),

  346. 

  347. 			/** @type {SyncBailHook} */

  348. 			needAdditionalSeal: new SyncBailHook([]),

  349. 			/** @type {AsyncSeriesHook} */

  350. 			afterSeal: new AsyncSeriesHook([]),

  351. 

  352. 			/** @type {SyncHook<Chunk, Hash>} */

  353. 			chunkHash: new SyncHook(["chunk", "chunkHash"]),

  354. 			/** @type {SyncHook<Module, string>} */

  355. 			moduleAsset: new SyncHook(["module", "filename"]),

  356. 			/** @type {SyncHook<Chunk, string>} */

  357. 			chunkAsset: new SyncHook(["chunk", "filename"]),

  358. 

  359. 			/** @type {SyncWaterfallHook<string, TODO>} */

  360. 			assetPath: new SyncWaterfallHook(["filename", "data"]), // TODO MainTemplate

  361. 

  362. 			/** @type {SyncBailHook} */

  363. 			needAdditionalPass: new SyncBailHook([]),

  364. 

  365. 			/** @type {SyncHook<Compiler, string, number>} */

  366. 			childCompiler: new SyncHook([

  367. 				"childCompiler",

  368. 				"compilerName",

  369. 				"compilerIndex"

  370. 			]),

  371. 

  372. 			// TODO the following hooks are weirdly located here

  373. 			// TODO move them for webpack 5

  374. 			/** @type {SyncHook<object, Module>} */

  375. 			normalModuleLoader: new SyncHook(["loaderContext", "module"]),

  376. 

  377. 			/** @type {SyncBailHook<Chunk[]>} */

  378. 			optimizeExtractedChunksBasic: new SyncBailHook(["chunks"]),

  379. 			/** @type {SyncBailHook<Chunk[]>} */

  380. 			optimizeExtractedChunks: new SyncBailHook(["chunks"]),

  381. 			/** @type {SyncBailHook<Chunk[]>} */

  382. 			optimizeExtractedChunksAdvanced: new SyncBailHook(["chunks"]),

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

  384. 			afterOptimizeExtractedChunks: new SyncHook(["chunks"])

  385. 		};

  386. 		this._pluginCompat.tap("Compilation", options => {

  387. 			switch (options.name) {

  388. 				case "optimize-tree":

  389. 				case "additional-assets":

  390. 				case "optimize-chunk-assets":

  391. 				case "optimize-assets":

  392. 				case "after-seal":

  393. 					options.async = true;

  394. 					break;

  395. 			}

  396. 		});

  397. 		/** @type {string=} */

  398. 		this.name = undefined;

  399. 		/** @type {Compiler} */

  400. 		this.compiler = compiler;

  401. 		this.resolverFactory = compiler.resolverFactory;

  402. 		this.inputFileSystem = compiler.inputFileSystem;

  403. 		this.requestShortener = compiler.requestShortener;

  404. 

  405. 		const options = (this.options = compiler.options);

  406. 		this.outputOptions = options && options.output;

  407. 		/** @type {boolean=} */

  408. 		this.bail = options && options.bail;

  409. 		this.profile = options && options.profile;

  410. 		this.performance = options && options.performance;

  411. 

  412. 		this.mainTemplate = new MainTemplate(this.outputOptions);

  413. 		this.chunkTemplate = new ChunkTemplate(this.outputOptions);

  414. 		this.hotUpdateChunkTemplate = new HotUpdateChunkTemplate(

  415. 			this.outputOptions

  416. 		);

  417. 		this.runtimeTemplate = new RuntimeTemplate(

  418. 			this.outputOptions,

  419. 			this.requestShortener

  420. 		);

  421. 		this.moduleTemplates = {

  422. 			javascript: new ModuleTemplate(this.runtimeTemplate, "javascript"),

  423. 			webassembly: new ModuleTemplate(this.runtimeTemplate, "webassembly")

  424. 		};

  425. 

  426. 		this.semaphore = new Semaphore(options.parallelism || 100);

  427. 

  428. 		this.entries = [];

  429. 		/** @private @type {{name: string, request: string, module: Module}[]} */

  430. 		this._preparedEntrypoints = [];

  431. 		this.entrypoints = new Map();

  432. 		/** @type {Chunk[]} */

  433. 		this.chunks = [];

  434. 		/** @type {ChunkGroup[]} */

  435. 		this.chunkGroups = [];

  436. 		/** @type {Map<string, ChunkGroup>} */

  437. 		this.namedChunkGroups = new Map();

  438. 		/** @type {Map<string, Chunk>} */

  439. 		this.namedChunks = new Map();

  440. 		/** @type {Module[]} */

  441. 		this.modules = [];

  442. 		/** @private @type {Map<string, Module>} */

  443. 		this._modules = new Map();

  444. 		this.cache = null;

  445. 		this.records = null;

  446. 		/** @type {string[]} */

  447. 		this.additionalChunkAssets = [];

  448. 		/** @type {CompilationAssets} */

  449. 		this.assets = {};

  450. 		/** @type {WebpackError[]} */

  451. 		this.errors = [];

  452. 		/** @type {WebpackError[]} */

  453. 		this.warnings = [];

  454. 		/** @type {Compilation[]} */

  455. 		this.children = [];

  456. 		/** @type {Map<DepConstructor, ModuleFactory>} */

  457. 		this.dependencyFactories = new Map();

  458. 		/** @type {Map<DepConstructor, DependencyTemplate>} */

  459. 		this.dependencyTemplates = new Map();

  460. 		// TODO refactor this in webpack 5 to a custom DependencyTemplates class with a hash property

  461. 		// @ts-ignore

  462. 		this.dependencyTemplates.set("hash", "");

  463. 		this.childrenCounters = {};

  464. 		/** @type {Set<number|string>} */

  465. 		this.usedChunkIds = null;

  466. 		/** @type {Set<number>} */

  467. 		this.usedModuleIds = null;

  468. 		/** @type {Map<string, number>=} */

  469. 		this.fileTimestamps = undefined;

  470. 		/** @type {Map<string, number>=} */

  471. 		this.contextTimestamps = undefined;

  472. 		/** @type {Set<string>=} */

  473. 		this.compilationDependencies = undefined;

  474. 		/** @private @type {Map<Module, Callback[]>} */

  475. 		this._buildingModules = new Map();

  476. 		/** @private @type {Map<Module, Callback[]>} */

  477. 		this._rebuildingModules = new Map();

  478. 	}

  479. 

  480. 	getStats() {

  481. 		return new Stats(this);

  482. 	}

  483. 

  484. 	/**

  485. 	 * @typedef {Object} AddModuleResult

  486. 	 * @property {Module} module the added or existing module

  487. 	 * @property {boolean} issuer was this the first request for this module

  488. 	 * @property {boolean} build should the module be build

  489. 	 * @property {boolean} dependencies should dependencies be walked

  490. 	 */

  491. 

  492. 	/**

  493. 	 * @param {Module} module module to be added that was created

  494. 	 * @param {any=} cacheGroup cacheGroup it is apart of

  495. 	 * @returns {AddModuleResult} returns meta about whether or not the module had built

  496. 	 * had an issuer, or any dependnecies

  497. 	 */

  498. 	addModule(module, cacheGroup) {

  499. 		const identifier = module.identifier();

  500. 		const alreadyAddedModule = this._modules.get(identifier);

  501. 		if (alreadyAddedModule) {

  502. 			return {

  503. 				module: alreadyAddedModule,

  504. 				issuer: false,

  505. 				build: false,

  506. 				dependencies: false

  507. 			};

  508. 		}

  509. 		const cacheName = (cacheGroup || "m") + identifier;

  510. 		if (this.cache && this.cache[cacheName]) {

  511. 			const cacheModule = this.cache[cacheName];

  512. 

  513. 			if (typeof cacheModule.updateCacheModule === "function") {

  514. 				cacheModule.updateCacheModule(module);

  515. 			}

  516. 

  517. 			let rebuild = true;

  518. 			if (this.fileTimestamps && this.contextTimestamps) {

  519. 				rebuild = cacheModule.needRebuild(

  520. 					this.fileTimestamps,

  521. 					this.contextTimestamps

  522. 				);

  523. 			}

  524. 

  525. 			if (!rebuild) {

  526. 				cacheModule.disconnect();

  527. 				this._modules.set(identifier, cacheModule);

  528. 				this.modules.push(cacheModule);

  529. 				for (const err of cacheModule.errors) {

  530. 					this.errors.push(err);

  531. 				}

  532. 				for (const err of cacheModule.warnings) {

  533. 					this.warnings.push(err);

  534. 				}

  535. 				return {

  536. 					module: cacheModule,

  537. 					issuer: true,

  538. 					build: false,

  539. 					dependencies: true

  540. 				};

  541. 			}

  542. 			cacheModule.unbuild();

  543. 			module = cacheModule;

  544. 		}

  545. 		this._modules.set(identifier, module);

  546. 		if (this.cache) {

  547. 			this.cache[cacheName] = module;

  548. 		}

  549. 		this.modules.push(module);

  550. 		return {

  551. 			module: module,

  552. 			issuer: true,

  553. 			build: true,

  554. 			dependencies: true

  555. 		};

  556. 	}

  557. 

  558. 	/**

  559. 	 * Fetches a module from a compilation by its identifier

  560. 	 * @param {Module} module the module provided

  561. 	 * @returns {Module} the module requested

  562. 	 */

  563. 	getModule(module) {

  564. 		const identifier = module.identifier();

  565. 		return this._modules.get(identifier);

  566. 	}

  567. 

  568. 	/**

  569. 	 * Attempts to search for a module by its identifier

  570. 	 * @param {string} identifier identifier (usually path) for module

  571. 	 * @returns {Module|undefined} attempt to search for module and return it, else undefined

  572. 	 */

  573. 	findModule(identifier) {

  574. 		return this._modules.get(identifier);

  575. 	}

  576. 

  577. 	/**

  578. 	 * @param {Module} module module with its callback list

  579. 	 * @param {Callback} callback the callback function

  580. 	 * @returns {void}

  581. 	 */

  582. 	waitForBuildingFinished(module, callback) {

  583. 		let callbackList = this._buildingModules.get(module);

  584. 		if (callbackList) {

  585. 			callbackList.push(() => callback());

  586. 		} else {

  587. 			process.nextTick(callback);

  588. 		}

  589. 	}

  590. 

  591. 	/**

  592. 	 * Builds the module object

  593. 	 *

  594. 	 * @param {Module} module module to be built

  595. 	 * @param {boolean} optional optional flag

  596. 	 * @param {Module=} origin origin module this module build was requested from

  597. 	 * @param {Dependency[]=} dependencies optional dependencies from the module to be built

  598. 	 * @param {TODO} thisCallback the callback

  599. 	 * @returns {TODO} returns the callback function with results

  600. 	 */

  601. 	buildModule(module, optional, origin, dependencies, thisCallback) {

  602. 		let callbackList = this._buildingModules.get(module);

  603. 		if (callbackList) {

  604. 			callbackList.push(thisCallback);

  605. 			return;

  606. 		}

  607. 		this._buildingModules.set(module, (callbackList = [thisCallback]));

  608. 

  609. 		const callback = err => {

  610. 			this._buildingModules.delete(module);

  611. 			for (const cb of callbackList) {

  612. 				cb(err);

  613. 			}

  614. 		};

  615. 

  616. 		this.hooks.buildModule.call(module);

  617. 		module.build(

  618. 			this.options,

  619. 			this,

  620. 			this.resolverFactory.get("normal", module.resolveOptions),

  621. 			this.inputFileSystem,

  622. 			error => {

  623. 				const errors = module.errors;

  624. 				for (let indexError = 0; indexError < errors.length; indexError++) {

  625. 					const err = errors[indexError];

  626. 					err.origin = origin;

  627. 					err.dependencies = dependencies;

  628. 					if (optional) {

  629. 						this.warnings.push(err);

  630. 					} else {

  631. 						this.errors.push(err);

  632. 					}

  633. 				}

  634. 

  635. 				const warnings = module.warnings;

  636. 				for (

  637. 					let indexWarning = 0;

  638. 					indexWarning < warnings.length;

  639. 					indexWarning++

  640. 				) {

  641. 					const war = warnings[indexWarning];

  642. 					war.origin = origin;

  643. 					war.dependencies = dependencies;

  644. 					this.warnings.push(war);

  645. 				}

  646. 				module.dependencies.sort((a, b) => compareLocations(a.loc, b.loc));

  647. 				if (error) {

  648. 					this.hooks.failedModule.call(module, error);

  649. 					return callback(error);

  650. 				}

  651. 				this.hooks.succeedModule.call(module);

  652. 				return callback();

  653. 			}

  654. 		);

  655. 	}

  656. 

  657. 	/**

  658. 	 * @param {Module} module to be processed for deps

  659. 	 * @param {ModuleCallback} callback callback to be triggered

  660. 	 * @returns {void}

  661. 	 */

  662. 	processModuleDependencies(module, callback) {

  663. 		const dependencies = new Map();

  664. 

  665. 		const addDependency = dep => {

  666. 			const resourceIdent = dep.getResourceIdentifier();

  667. 			if (resourceIdent) {

  668. 				const factory = this.dependencyFactories.get(dep.constructor);

  669. 				if (factory === undefined) {

  670. 					throw new Error(

  671. 						`No module factory available for dependency type: ${

  672. 							dep.constructor.name

  673. 						}`

  674. 					);

  675. 				}

  676. 				let innerMap = dependencies.get(factory);

  677. 				if (innerMap === undefined) {

  678. 					dependencies.set(factory, (innerMap = new Map()));

  679. 				}

  680. 				let list = innerMap.get(resourceIdent);

  681. 				if (list === undefined) innerMap.set(resourceIdent, (list = []));

  682. 				list.push(dep);

  683. 			}

  684. 		};

  685. 

  686. 		const addDependenciesBlock = block => {

  687. 			if (block.dependencies) {

  688. 				iterationOfArrayCallback(block.dependencies, addDependency);

  689. 			}

  690. 			if (block.blocks) {

  691. 				iterationOfArrayCallback(block.blocks, addDependenciesBlock);

  692. 			}

  693. 			if (block.variables) {

  694. 				iterationBlockVariable(block.variables, addDependency);

  695. 			}

  696. 		};

  697. 

  698. 		try {

  699. 			addDependenciesBlock(module);

  700. 		} catch (e) {

  701. 			callback(e);

  702. 		}

  703. 

  704. 		const sortedDependencies = [];

  705. 

  706. 		for (const pair1 of dependencies) {

  707. 			for (const pair2 of pair1[1]) {

  708. 				sortedDependencies.push({

  709. 					factory: pair1[0],

  710. 					dependencies: pair2[1]

  711. 				});

  712. 			}

  713. 		}

  714. 

  715. 		this.addModuleDependencies(

  716. 			module,

  717. 			sortedDependencies,

  718. 			this.bail,

  719. 			null,

  720. 			true,

  721. 			callback

  722. 		);

  723. 	}

  724. 

  725. 	/**

  726. 	 * @param {Module} module module to add deps to

  727. 	 * @param {SortedDependency[]} dependencies set of sorted dependencies to iterate through

  728. 	 * @param {(boolean|null)=} bail whether to bail or not

  729. 	 * @param {TODO} cacheGroup optional cacheGroup

  730. 	 * @param {boolean} recursive whether it is recursive traversal

  731. 	 * @param {function} callback callback for when dependencies are finished being added

  732. 	 * @returns {void}

  733. 	 */

  734. 	addModuleDependencies(

  735. 		module,

  736. 		dependencies,

  737. 		bail,

  738. 		cacheGroup,

  739. 		recursive,

  740. 		callback

  741. 	) {

  742. 		const start = this.profile && Date.now();

  743. 		const currentProfile = this.profile && {};

  744. 

  745. 		asyncLib.forEach(

  746. 			dependencies,

  747. 			(item, callback) => {

  748. 				const dependencies = item.dependencies;

  749. 

  750. 				const errorAndCallback = err => {

  751. 					err.origin = module;

  752. 					err.dependencies = dependencies;

  753. 					this.errors.push(err);

  754. 					if (bail) {

  755. 						callback(err);

  756. 					} else {

  757. 						callback();

  758. 					}

  759. 				};

  760. 				const warningAndCallback = err => {

  761. 					err.origin = module;

  762. 					this.warnings.push(err);

  763. 					callback();

  764. 				};

  765. 

  766. 				const semaphore = this.semaphore;

  767. 				semaphore.acquire(() => {

  768. 					const factory = item.factory;

  769. 					factory.create(

  770. 						{

  771. 							contextInfo: {

  772. 								issuer: module.nameForCondition && module.nameForCondition(),

  773. 								compiler: this.compiler.name

  774. 							},

  775. 							resolveOptions: module.resolveOptions,

  776. 							context: module.context,

  777. 							dependencies: dependencies

  778. 						},

  779. 						(err, dependentModule) => {

  780. 							let afterFactory;

  781. 

  782. 							const isOptional = () => {

  783. 								return dependencies.every(d => d.optional);

  784. 							};

  785. 

  786. 							const errorOrWarningAndCallback = err => {

  787. 								if (isOptional()) {

  788. 									return warningAndCallback(err);

  789. 								} else {

  790. 									return errorAndCallback(err);

  791. 								}

  792. 							};

  793. 

  794. 							if (err) {

  795. 								semaphore.release();

  796. 								return errorOrWarningAndCallback(

  797. 									new ModuleNotFoundError(module, err)

  798. 								);

  799. 							}

  800. 							if (!dependentModule) {

  801. 								semaphore.release();

  802. 								return process.nextTick(callback);

  803. 							}

  804. 							if (currentProfile) {

  805. 								afterFactory = Date.now();

  806. 								currentProfile.factory = afterFactory - start;

  807. 							}

  808. 

  809. 							const iterationDependencies = depend => {

  810. 								for (let index = 0; index < depend.length; index++) {

  811. 									const dep = depend[index];

  812. 									dep.module = dependentModule;

  813. 									dependentModule.addReason(module, dep);

  814. 								}

  815. 							};

  816. 

  817. 							const addModuleResult = this.addModule(

  818. 								dependentModule,

  819. 								cacheGroup

  820. 							);

  821. 							dependentModule = addModuleResult.module;

  822. 							iterationDependencies(dependencies);

  823. 

  824. 							const afterBuild = () => {

  825. 								if (currentProfile) {

  826. 									const afterBuilding = Date.now();

  827. 									currentProfile.building = afterBuilding - afterFactory;

  828. 								}

  829. 

  830. 								if (recursive && addModuleResult.dependencies) {

  831. 									this.processModuleDependencies(dependentModule, callback);

  832. 								} else {

  833. 									return callback();

  834. 								}

  835. 							};

  836. 

  837. 							if (addModuleResult.issuer) {

  838. 								if (currentProfile) {

  839. 									dependentModule.profile = currentProfile;

  840. 								}

  841. 

  842. 								dependentModule.issuer = module;

  843. 							} else {

  844. 								if (this.profile) {

  845. 									if (module.profile) {

  846. 										const time = Date.now() - start;

  847. 										if (

  848. 											!module.profile.dependencies ||

  849. 											time > module.profile.dependencies

  850. 										) {

  851. 											module.profile.dependencies = time;

  852. 										}

  853. 									}

  854. 								}

  855. 							}

  856. 

  857. 							if (addModuleResult.build) {

  858. 								this.buildModule(

  859. 									dependentModule,

  860. 									isOptional(),

  861. 									module,

  862. 									dependencies,

  863. 									err => {

  864. 										if (err) {

  865. 											semaphore.release();

  866. 											return errorOrWarningAndCallback(err);

  867. 										}

  868. 

  869. 										if (currentProfile) {

  870. 											const afterBuilding = Date.now();

  871. 											currentProfile.building = afterBuilding - afterFactory;

  872. 										}

  873. 

  874. 										semaphore.release();

  875. 										afterBuild();

  876. 									}

  877. 								);

  878. 							} else {

  879. 								semaphore.release();

  880. 								this.waitForBuildingFinished(dependentModule, afterBuild);

  881. 							}

  882. 						}

  883. 					);

  884. 				});

  885. 			},

  886. 			err => {

  887. 				// In V8, the Error objects keep a reference to the functions on the stack. These warnings &

  888. 				// errors are created inside closures that keep a reference to the Compilation, so errors are

  889. 				// leaking the Compilation object.

  890. 

  891. 				if (err) {

  892. 					// eslint-disable-next-line no-self-assign

  893. 					err.stack = err.stack;

  894. 					return callback(err);

  895. 				}

  896. 

  897. 				return process.nextTick(callback);

  898. 			}

  899. 		);

  900. 	}

  901. 

  902. 	/**

  903. 	 *

  904. 	 * @param {string} context context string path

  905. 	 * @param {Dependency} dependency dependency used to create Module chain

  906. 	 * @param {OnModuleCallback} onModule function invoked on modules creation

  907. 	 * @param {ModuleChainCallback} callback callback for when module chain is complete

  908. 	 * @returns {void} will throw if dependency instance is not a valid Dependency

  909. 	 */

  910. 	_addModuleChain(context, dependency, onModule, callback) {

  911. 		const start = this.profile && Date.now();

  912. 		const currentProfile = this.profile && {};

  913. 

  914. 		const errorAndCallback = this.bail

  915. 			? err => {

  916. 					callback(err);

  917. 			  }

  918. 			: err => {

  919. 					err.dependencies = [dependency];

  920. 					this.errors.push(err);

  921. 					callback();

  922. 			  };

  923. 

  924. 		if (

  925. 			typeof dependency !== "object" ||

  926. 			dependency === null ||

  927. 			!dependency.constructor

  928. 		) {

  929. 			throw new Error("Parameter 'dependency' must be a Dependency");

  930. 		}

  931. 		const Dep = /** @type {DepConstructor} */ (dependency.constructor);

  932. 		const moduleFactory = this.dependencyFactories.get(Dep);

  933. 		if (!moduleFactory) {

  934. 			throw new Error(

  935. 				`No dependency factory available for this dependency type: ${

  936. 					dependency.constructor.name

  937. 				}`

  938. 			);

  939. 		}

  940. 

  941. 		this.semaphore.acquire(() => {

  942. 			moduleFactory.create(

  943. 				{

  944. 					contextInfo: {

  945. 						issuer: "",

  946. 						compiler: this.compiler.name

  947. 					},

  948. 					context: context,

  949. 					dependencies: [dependency]

  950. 				},

  951. 				(err, module) => {

  952. 					if (err) {

  953. 						this.semaphore.release();

  954. 						return errorAndCallback(new EntryModuleNotFoundError(err));

  955. 					}

  956. 

  957. 					let afterFactory;

  958. 

  959. 					if (currentProfile) {

  960. 						afterFactory = Date.now();

  961. 						currentProfile.factory = afterFactory - start;

  962. 					}

  963. 

  964. 					const addModuleResult = this.addModule(module);

  965. 					module = addModuleResult.module;

  966. 

  967. 					onModule(module);

  968. 

  969. 					dependency.module = module;

  970. 					module.addReason(null, dependency);

  971. 

  972. 					const afterBuild = () => {

  973. 						if (currentProfile) {

  974. 							const afterBuilding = Date.now();

  975. 							currentProfile.building = afterBuilding - afterFactory;

  976. 						}

  977. 

  978. 						if (addModuleResult.dependencies) {

  979. 							this.processModuleDependencies(module, err => {

  980. 								if (err) return callback(err);

  981. 								callback(null, module);

  982. 							});

  983. 						} else {

  984. 							return callback(null, module);

  985. 						}

  986. 					};

  987. 

  988. 					if (addModuleResult.issuer) {

  989. 						if (currentProfile) {

  990. 							module.profile = currentProfile;

  991. 						}

  992. 					}

  993. 

  994. 					if (addModuleResult.build) {

  995. 						this.buildModule(module, false, null, null, err => {

  996. 							if (err) {

  997. 								this.semaphore.release();

  998. 								return errorAndCallback(err);

  999. 							}

  1000. 

  1001. 							if (currentProfile) {

  1002. 								const afterBuilding = Date.now();

  1003. 								currentProfile.building = afterBuilding - afterFactory;

  1004. 							}

  1005. 

  1006. 							this.semaphore.release();

  1007. 							afterBuild();

  1008. 						});

  1009. 					} else {

  1010. 						this.semaphore.release();

  1011. 						this.waitForBuildingFinished(module, afterBuild);

  1012. 					}

  1013. 				}

  1014. 			);

  1015. 		});

  1016. 	}

  1017. 

  1018. 	/**

  1019. 	 *

  1020. 	 * @param {string} context context path for entry

  1021. 	 * @param {Dependency} entry entry dependency being created

  1022. 	 * @param {string} name name of entry

  1023. 	 * @param {ModuleCallback} callback callback function

  1024. 	 * @returns {void} returns

  1025. 	 */

  1026. 	addEntry(context, entry, name, callback) {

  1027. 		const slot = {

  1028. 			name: name,

  1029. 			// TODO webpack 5 remove `request`

  1030. 			request: null,

  1031. 			module: null

  1032. 		};

  1033. 

  1034. 		if (entry instanceof ModuleDependency) {

  1035. 			slot.request = entry.request;

  1036. 		}

  1037. 

  1038. 		// TODO webpack 5: merge modules instead when multiple entry modules are supported

  1039. 		const idx = this._preparedEntrypoints.findIndex(slot => slot.name === name);

  1040. 		if (idx >= 0) {

  1041. 			// Overwrite existing entrypoint

  1042. 			this._preparedEntrypoints[idx] = slot;

  1043. 		} else {

  1044. 			this._preparedEntrypoints.push(slot);

  1045. 		}

  1046. 		this._addModuleChain(

  1047. 			context,

  1048. 			entry,

  1049. 			module => {

  1050. 				this.entries.push(module);

  1051. 			},

  1052. 			(err, module) => {

  1053. 				if (err) {

  1054. 					return callback(err);

  1055. 				}

  1056. 

  1057. 				if (module) {

  1058. 					slot.module = module;

  1059. 				} else {

  1060. 					const idx = this._preparedEntrypoints.indexOf(slot);

  1061. 					if (idx >= 0) {

  1062. 						this._preparedEntrypoints.splice(idx, 1);

  1063. 					}

  1064. 				}

  1065. 				return callback(null, module);

  1066. 			}

  1067. 		);

  1068. 	}

  1069. 

  1070. 	/**

  1071. 	 * @param {string} context context path string

  1072. 	 * @param {Dependency} dependency dep used to create module

  1073. 	 * @param {ModuleCallback} callback module callback sending module up a level

  1074. 	 * @returns {void}

  1075. 	 */

  1076. 	prefetch(context, dependency, callback) {

  1077. 		this._addModuleChain(

  1078. 			context,

  1079. 			dependency,

  1080. 			module => {

  1081. 				module.prefetched = true;

  1082. 			},

  1083. 			callback

  1084. 		);

  1085. 	}

  1086. 

  1087. 	/**

  1088. 	 * @param {Module} module module to be rebuilt

  1089. 	 * @param {Callback} thisCallback callback when module finishes rebuilding

  1090. 	 * @returns {void}

  1091. 	 */

  1092. 	rebuildModule(module, thisCallback) {

  1093. 		let callbackList = this._rebuildingModules.get(module);

  1094. 		if (callbackList) {

  1095. 			callbackList.push(thisCallback);

  1096. 			return;

  1097. 		}

  1098. 		this._rebuildingModules.set(module, (callbackList = [thisCallback]));

  1099. 

  1100. 		const callback = err => {

  1101. 			this._rebuildingModules.delete(module);

  1102. 			for (const cb of callbackList) {

  1103. 				cb(err);

  1104. 			}

  1105. 		};

  1106. 

  1107. 		this.hooks.rebuildModule.call(module);

  1108. 		const oldDependencies = module.dependencies.slice();

  1109. 		const oldVariables = module.variables.slice();

  1110. 		const oldBlocks = module.blocks.slice();

  1111. 		module.unbuild();

  1112. 		this.buildModule(module, false, module, null, err => {

  1113. 			if (err) {

  1114. 				this.hooks.finishRebuildingModule.call(module);

  1115. 				return callback(err);

  1116. 			}

  1117. 

  1118. 			this.processModuleDependencies(module, err => {

  1119. 				if (err) return callback(err);

  1120. 				this.removeReasonsOfDependencyBlock(module, {

  1121. 					dependencies: oldDependencies,

  1122. 					variables: oldVariables,

  1123. 					blocks: oldBlocks

  1124. 				});

  1125. 				this.hooks.finishRebuildingModule.call(module);

  1126. 				callback();

  1127. 			});

  1128. 		});

  1129. 	}

  1130. 

  1131. 	finish() {

  1132. 		const modules = this.modules;

  1133. 		this.hooks.finishModules.call(modules);

  1134. 

  1135. 		for (let index = 0; index < modules.length; index++) {

  1136. 			const module = modules[index];

  1137. 			this.reportDependencyErrorsAndWarnings(module, [module]);

  1138. 		}

  1139. 	}

  1140. 

  1141. 	unseal() {

  1142. 		this.hooks.unseal.call();

  1143. 		this.chunks.length = 0;

  1144. 		this.chunkGroups.length = 0;

  1145. 		this.namedChunks.clear();

  1146. 		this.namedChunkGroups.clear();

  1147. 		this.additionalChunkAssets.length = 0;

  1148. 		this.assets = {};

  1149. 		for (const module of this.modules) {

  1150. 			module.unseal();

  1151. 		}

  1152. 	}

  1153. 

  1154. 	/**

  1155. 	 * @param {Callback} callback signals when the seal method is finishes

  1156. 	 * @returns {void}

  1157. 	 */

  1158. 	seal(callback) {

  1159. 		this.hooks.seal.call();

  1160. 

  1161. 		while (

  1162. 			this.hooks.optimizeDependenciesBasic.call(this.modules) ||

  1163. 			this.hooks.optimizeDependencies.call(this.modules) ||

  1164. 			this.hooks.optimizeDependenciesAdvanced.call(this.modules)

  1165. 		) {

  1166. 			/* empty */

  1167. 		}

  1168. 		this.hooks.afterOptimizeDependencies.call(this.modules);

  1169. 

  1170. 		this.hooks.beforeChunks.call();

  1171. 		for (const preparedEntrypoint of this._preparedEntrypoints) {

  1172. 			const module = preparedEntrypoint.module;

  1173. 			const name = preparedEntrypoint.name;

  1174. 			const chunk = this.addChunk(name);

  1175. 			const entrypoint = new Entrypoint(name);

  1176. 			entrypoint.setRuntimeChunk(chunk);

  1177. 			entrypoint.addOrigin(null, name, preparedEntrypoint.request);

  1178. 			this.namedChunkGroups.set(name, entrypoint);

  1179. 			this.entrypoints.set(name, entrypoint);

  1180. 			this.chunkGroups.push(entrypoint);

  1181. 

  1182. 			GraphHelpers.connectChunkGroupAndChunk(entrypoint, chunk);

  1183. 			GraphHelpers.connectChunkAndModule(chunk, module);

  1184. 

  1185. 			chunk.entryModule = module;

  1186. 			chunk.name = name;

  1187. 

  1188. 			this.assignDepth(module);

  1189. 		}

  1190. 		this.processDependenciesBlocksForChunkGroups(this.chunkGroups.slice());

  1191. 		this.sortModules(this.modules);

  1192. 		this.hooks.afterChunks.call(this.chunks);

  1193. 

  1194. 		this.hooks.optimize.call();

  1195. 

  1196. 		while (

  1197. 			this.hooks.optimizeModulesBasic.call(this.modules) ||

  1198. 			this.hooks.optimizeModules.call(this.modules) ||

  1199. 			this.hooks.optimizeModulesAdvanced.call(this.modules)

  1200. 		) {

  1201. 			/* empty */

  1202. 		}

  1203. 		this.hooks.afterOptimizeModules.call(this.modules);

  1204. 

  1205. 		while (

  1206. 			this.hooks.optimizeChunksBasic.call(this.chunks, this.chunkGroups) ||

  1207. 			this.hooks.optimizeChunks.call(this.chunks, this.chunkGroups) ||

  1208. 			this.hooks.optimizeChunksAdvanced.call(this.chunks, this.chunkGroups)

  1209. 		) {

  1210. 			/* empty */

  1211. 		}

  1212. 		this.hooks.afterOptimizeChunks.call(this.chunks, this.chunkGroups);

  1213. 

  1214. 		this.hooks.optimizeTree.callAsync(this.chunks, this.modules, err => {

  1215. 			if (err) {

  1216. 				return callback(err);

  1217. 			}

  1218. 

  1219. 			this.hooks.afterOptimizeTree.call(this.chunks, this.modules);

  1220. 

  1221. 			while (

  1222. 				this.hooks.optimizeChunkModulesBasic.call(this.chunks, this.modules) ||

  1223. 				this.hooks.optimizeChunkModules.call(this.chunks, this.modules) ||

  1224. 				this.hooks.optimizeChunkModulesAdvanced.call(this.chunks, this.modules)

  1225. 			) {

  1226. 				/* empty */

  1227. 			}

  1228. 			this.hooks.afterOptimizeChunkModules.call(this.chunks, this.modules);

  1229. 

  1230. 			const shouldRecord = this.hooks.shouldRecord.call() !== false;

  1231. 

  1232. 			this.hooks.reviveModules.call(this.modules, this.records);

  1233. 			this.hooks.optimizeModuleOrder.call(this.modules);

  1234. 			this.hooks.advancedOptimizeModuleOrder.call(this.modules);

  1235. 			this.hooks.beforeModuleIds.call(this.modules);

  1236. 			this.hooks.moduleIds.call(this.modules);

  1237. 			this.applyModuleIds();

  1238. 			this.hooks.optimizeModuleIds.call(this.modules);

  1239. 			this.hooks.afterOptimizeModuleIds.call(this.modules);

  1240. 

  1241. 			this.sortItemsWithModuleIds();

  1242. 

  1243. 			this.hooks.reviveChunks.call(this.chunks, this.records);

  1244. 			this.hooks.optimizeChunkOrder.call(this.chunks);

  1245. 			this.hooks.beforeChunkIds.call(this.chunks);

  1246. 			this.applyChunkIds();

  1247. 			this.hooks.optimizeChunkIds.call(this.chunks);

  1248. 			this.hooks.afterOptimizeChunkIds.call(this.chunks);

  1249. 

  1250. 			this.sortItemsWithChunkIds();

  1251. 

  1252. 			if (shouldRecord) {

  1253. 				this.hooks.recordModules.call(this.modules, this.records);

  1254. 				this.hooks.recordChunks.call(this.chunks, this.records);

  1255. 			}

  1256. 

  1257. 			this.hooks.beforeHash.call();

  1258. 			this.createHash();

  1259. 			this.hooks.afterHash.call();

  1260. 

  1261. 			if (shouldRecord) {

  1262. 				this.hooks.recordHash.call(this.records);

  1263. 			}

  1264. 

  1265. 			this.hooks.beforeModuleAssets.call();

  1266. 			this.createModuleAssets();

  1267. 			if (this.hooks.shouldGenerateChunkAssets.call() !== false) {

  1268. 				this.hooks.beforeChunkAssets.call();

  1269. 				this.createChunkAssets();

  1270. 			}

  1271. 			this.hooks.additionalChunkAssets.call(this.chunks);

  1272. 			this.summarizeDependencies();

  1273. 			if (shouldRecord) {

  1274. 				this.hooks.record.call(this, this.records);

  1275. 			}

  1276. 

  1277. 			this.hooks.additionalAssets.callAsync(err => {

  1278. 				if (err) {

  1279. 					return callback(err);

  1280. 				}

  1281. 				this.hooks.optimizeChunkAssets.callAsync(this.chunks, err => {

  1282. 					if (err) {

  1283. 						return callback(err);

  1284. 					}

  1285. 					this.hooks.afterOptimizeChunkAssets.call(this.chunks);

  1286. 					this.hooks.optimizeAssets.callAsync(this.assets, err => {

  1287. 						if (err) {

  1288. 							return callback(err);

  1289. 						}

  1290. 						this.hooks.afterOptimizeAssets.call(this.assets);

  1291. 						if (this.hooks.needAdditionalSeal.call()) {

  1292. 							this.unseal();

  1293. 							return this.seal(callback);

  1294. 						}

  1295. 						return this.hooks.afterSeal.callAsync(callback);

  1296. 					});

  1297. 				});

  1298. 			});

  1299. 		});

  1300. 	}

  1301. 

  1302. 	/**

  1303. 	 * @param {Module[]} modules the modules array on compilation to perform the sort for

  1304. 	 * @returns {void}

  1305. 	 */

  1306. 	sortModules(modules) {

  1307. 		// TODO webpack 5: this should only be enabled when `moduleIds: "natural"`

  1308. 		// TODO move it into a plugin (NaturalModuleIdsPlugin) and use this in WebpackOptionsApply

  1309. 		// TODO remove this method

  1310. 		modules.sort(byIndexOrIdentifier);

  1311. 	}

  1312. 

  1313. 	/**

  1314. 	 * @param {Module} module moulde to report from

  1315. 	 * @param {DependenciesBlock[]} blocks blocks to report from

  1316. 	 * @returns {void}

  1317. 	 */

  1318. 	reportDependencyErrorsAndWarnings(module, blocks) {

  1319. 		for (let indexBlock = 0; indexBlock < blocks.length; indexBlock++) {

  1320. 			const block = blocks[indexBlock];

  1321. 			const dependencies = block.dependencies;

  1322. 

  1323. 			for (let indexDep = 0; indexDep < dependencies.length; indexDep++) {

  1324. 				const d = dependencies[indexDep];

  1325. 

  1326. 				const warnings = d.getWarnings();

  1327. 				if (warnings) {

  1328. 					for (let indexWar = 0; indexWar < warnings.length; indexWar++) {

  1329. 						const w = warnings[indexWar];

  1330. 

  1331. 						const warning = new ModuleDependencyWarning(module, w, d.loc);

  1332. 						this.warnings.push(warning);

  1333. 					}

  1334. 				}

  1335. 				const errors = d.getErrors();

  1336. 				if (errors) {

  1337. 					for (let indexErr = 0; indexErr < errors.length; indexErr++) {

  1338. 						const e = errors[indexErr];

  1339. 

  1340. 						const error = new ModuleDependencyError(module, e, d.loc);

  1341. 						this.errors.push(error);

  1342. 					}

  1343. 				}

  1344. 			}

  1345. 

  1346. 			this.reportDependencyErrorsAndWarnings(module, block.blocks);

  1347. 		}

  1348. 	}

  1349. 

  1350. 	/**

  1351. 	 * @param {TODO} groupOptions options for the chunk group

  1352. 	 * @param {Module} module the module the references the chunk group

  1353. 	 * @param {DependencyLocation} loc the location from with the chunk group is referenced (inside of module)

  1354. 	 * @param {string} request the request from which the the chunk group is referenced

  1355. 	 * @returns {ChunkGroup} the new or existing chunk group

  1356. 	 */

  1357. 	addChunkInGroup(groupOptions, module, loc, request) {

  1358. 		if (typeof groupOptions === "string") {

  1359. 			groupOptions = { name: groupOptions };

  1360. 		}

  1361. 		const name = groupOptions.name;

  1362. 		if (name) {

  1363. 			const chunkGroup = this.namedChunkGroups.get(name);

  1364. 			if (chunkGroup !== undefined) {

  1365. 				chunkGroup.addOptions(groupOptions);

  1366. 				if (module) {

  1367. 					chunkGroup.addOrigin(module, loc, request);

  1368. 				}

  1369. 				return chunkGroup;

  1370. 			}

  1371. 		}

  1372. 		const chunkGroup = new ChunkGroup(groupOptions);

  1373. 		if (module) chunkGroup.addOrigin(module, loc, request);

  1374. 		const chunk = this.addChunk(name);

  1375. 

  1376. 		GraphHelpers.connectChunkGroupAndChunk(chunkGroup, chunk);

  1377. 

  1378. 		this.chunkGroups.push(chunkGroup);

  1379. 		if (name) {

  1380. 			this.namedChunkGroups.set(name, chunkGroup);

  1381. 		}

  1382. 		return chunkGroup;

  1383. 	}

  1384. 

  1385. 	/**

  1386. 	 * This method first looks to see if a name is provided for a new chunk,

  1387. 	 * and first looks to see if any named chunks already exist and reuse that chunk instead.

  1388. 	 *

  1389. 	 * @param {string=} name optional chunk name to be provided

  1390. 	 * @returns {Chunk} create a chunk (invoked during seal event)

  1391. 	 */

  1392. 	addChunk(name) {

  1393. 		if (name) {

  1394. 			const chunk = this.namedChunks.get(name);

  1395. 			if (chunk !== undefined) {

  1396. 				return chunk;

  1397. 			}

  1398. 		}

  1399. 		const chunk = new Chunk(name);

  1400. 		this.chunks.push(chunk);

  1401. 		if (name) {

  1402. 			this.namedChunks.set(name, chunk);

  1403. 		}

  1404. 		return chunk;

  1405. 	}

  1406. 

  1407. 	/**

  1408. 	 * @param {Module} module module to assign depth

  1409. 	 * @returns {void}

  1410. 	 */

  1411. 	assignDepth(module) {

  1412. 		const queue = new Set([module]);

  1413. 		let depth;

  1414. 

  1415. 		module.depth = 0;

  1416. 

  1417. 		/**

  1418. 		 * @param {Module} module module for processeing

  1419. 		 * @returns {void}

  1420. 		 */

  1421. 		const enqueueJob = module => {

  1422. 			const d = module.depth;

  1423. 			if (typeof d === "number" && d <= depth) return;

  1424. 			queue.add(module);

  1425. 			module.depth = depth;

  1426. 		};

  1427. 

  1428. 		/**

  1429. 		 * @param {Dependency} dependency dependency to assign depth to

  1430. 		 * @returns {void}

  1431. 		 */

  1432. 		const assignDepthToDependency = dependency => {

  1433. 			if (dependency.module) {

  1434. 				enqueueJob(dependency.module);

  1435. 			}

  1436. 		};

  1437. 

  1438. 		/**

  1439. 		 * @param {DependenciesBlock} block block to assign depth to

  1440. 		 * @returns {void}

  1441. 		 */

  1442. 		const assignDepthToDependencyBlock = block => {

  1443. 			if (block.variables) {

  1444. 				iterationBlockVariable(block.variables, assignDepthToDependency);

  1445. 			}

  1446. 

  1447. 			if (block.dependencies) {

  1448. 				iterationOfArrayCallback(block.dependencies, assignDepthToDependency);

  1449. 			}

  1450. 

  1451. 			if (block.blocks) {

  1452. 				iterationOfArrayCallback(block.blocks, assignDepthToDependencyBlock);

  1453. 			}

  1454. 		};

  1455. 

  1456. 		for (module of queue) {

  1457. 			queue.delete(module);

  1458. 			depth = module.depth;

  1459. 

  1460. 			depth++;

  1461. 			assignDepthToDependencyBlock(module);

  1462. 		}

  1463. 	}

  1464. 

  1465. 	/**

  1466. 	 * @param {Module} module the module containing the dependency

  1467. 	 * @param {Dependency} dependency the dependency

  1468. 	 * @returns {DependencyReference} a reference for the dependency

  1469. 	 */

  1470. 	getDependencyReference(module, dependency) {

  1471. 		// TODO remove dep.getReference existence check in webpack 5

  1472. 		if (typeof dependency.getReference !== "function") return null;

  1473. 		const ref = dependency.getReference();

  1474. 		if (!ref) return null;

  1475. 		return this.hooks.dependencyReference.call(ref, dependency, module);

  1476. 	}

  1477. 

  1478. 	/**

  1479. 	 * This method creates the Chunk graph from the Module graph

  1480. 	 * @private

  1481. 	 * @param {TODO[]} inputChunkGroups chunk groups which are processed

  1482. 	 * @returns {void}

  1483. 	 */

  1484. 	processDependenciesBlocksForChunkGroups(inputChunkGroups) {

  1485. 		// Process is splitting into two parts:

  1486. 		// Part one traverse the module graph and builds a very basic chunks graph

  1487. 		//   in chunkDependencies.

  1488. 		// Part two traverse every possible way through the basic chunk graph and

  1489. 		//   tracks the available modules. While traversing it connects chunks with

  1490. 		//   eachother and Blocks with Chunks. It stops traversing when all modules

  1491. 		//   for a chunk are already available. So it doesn't connect unneeded chunks.

  1492. 

  1493. 		/** @type {Map<ChunkGroup, {block: AsyncDependenciesBlock, chunkGroup: ChunkGroup}[]>} */

  1494. 		const chunkDependencies = new Map();

  1495. 		const allCreatedChunkGroups = new Set();

  1496. 

  1497. 		// PREPARE

  1498. 		/** @type {Map<DependenciesBlock, { modules: Module[], blocks: AsyncDependenciesBlock[]}>} */

  1499. 		const blockInfoMap = new Map();

  1500. 

  1501. 		/**

  1502. 		 * @param {Dependency} d dependency to iterate over

  1503. 		 * @returns {void}

  1504. 		 */

  1505. 		const iteratorDependency = d => {

  1506. 			// We skip Dependencies without Reference

  1507. 			const ref = this.getDependencyReference(currentModule, d);

  1508. 			if (!ref) {

  1509. 				return;

  1510. 			}

  1511. 			// We skip Dependencies without Module pointer

  1512. 			const refModule = ref.module;

  1513. 			if (!refModule) {

  1514. 				return;

  1515. 			}

  1516. 			// We skip weak Dependencies

  1517. 			if (ref.weak) {

  1518. 				return;

  1519. 			}

  1520. 

  1521. 			blockInfoModules.add(refModule);

  1522. 		};

  1523. 

  1524. 		/**

  1525. 		 * @param {AsyncDependenciesBlock} b blocks to prepare

  1526. 		 * @returns {void}

  1527. 		 */

  1528. 		const iteratorBlockPrepare = b => {

  1529. 			blockInfoBlocks.push(b);

  1530. 			blockQueue.push(b);

  1531. 		};

  1532. 

  1533. 		/** @type {Module} */

  1534. 		let currentModule;

  1535. 		/** @type {DependenciesBlock} */

  1536. 		let block;

  1537. 		/** @type {DependenciesBlock[]} */

  1538. 		let blockQueue;

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

  1540. 		let blockInfoModules;

  1541. 		/** @type {AsyncDependenciesBlock[]} */

  1542. 		let blockInfoBlocks;

  1543. 

  1544. 		for (const module of this.modules) {

  1545. 			blockQueue = [module];

  1546. 			currentModule = module;

  1547. 			while (blockQueue.length > 0) {

  1548. 				block = blockQueue.pop();

  1549. 				blockInfoModules = new Set();

  1550. 				blockInfoBlocks = [];

  1551. 

  1552. 				if (block.variables) {

  1553. 					iterationBlockVariable(block.variables, iteratorDependency);

  1554. 				}

  1555. 

  1556. 				if (block.dependencies) {

  1557. 					iterationOfArrayCallback(block.dependencies, iteratorDependency);

  1558. 				}

  1559. 

  1560. 				if (block.blocks) {

  1561. 					iterationOfArrayCallback(block.blocks, iteratorBlockPrepare);

  1562. 				}

  1563. 

  1564. 				const blockInfo = {

  1565. 					modules: Array.from(blockInfoModules),

  1566. 					blocks: blockInfoBlocks

  1567. 				};

  1568. 				blockInfoMap.set(block, blockInfo);

  1569. 			}

  1570. 		}

  1571. 

  1572. 		// PART ONE

  1573. 

  1574. 		/** @type {Map<ChunkGroup, { index: number, index2: number }>} */

  1575. 		const chunkGroupCounters = new Map();

  1576. 		for (const chunkGroup of inputChunkGroups) {

  1577. 			chunkGroupCounters.set(chunkGroup, { index: 0, index2: 0 });

  1578. 		}

  1579. 

  1580. 		let nextFreeModuleIndex = 0;

  1581. 		let nextFreeModuleIndex2 = 0;

  1582. 

  1583. 		/** @type {Map<DependenciesBlock, ChunkGroup>} */

  1584. 		const blockChunkGroups = new Map();

  1585. 

  1586. 		/** @type {Set<DependenciesBlock>} */

  1587. 		const blocksWithNestedBlocks = new Set();

  1588. 

  1589. 		const ADD_AND_ENTER_MODULE = 0;

  1590. 		const ENTER_MODULE = 1;

  1591. 		const PROCESS_BLOCK = 2;

  1592. 		const LEAVE_MODULE = 3;

  1593. 

  1594. 		/**

  1595. 		 * @typedef {Object} QueueItem

  1596. 		 * @property {number} action

  1597. 		 * @property {DependenciesBlock} block

  1598. 		 * @property {Module} module

  1599. 		 * @property {Chunk} chunk

  1600. 		 * @property {ChunkGroup} chunkGroup

  1601. 		 */

  1602. 

  1603. 		/**

  1604. 		 * @param {ChunkGroup} chunkGroup chunk group

  1605. 		 * @returns {QueueItem} queue item

  1606. 		 */

  1607. 		const chunkGroupToQueueItem = chunkGroup => ({

  1608. 			action: ENTER_MODULE,

  1609. 			block: chunkGroup.chunks[0].entryModule,

  1610. 			module: chunkGroup.chunks[0].entryModule,

  1611. 			chunk: chunkGroup.chunks[0],

  1612. 			chunkGroup

  1613. 		});

  1614. 

  1615. 		// Start with the provided modules/chunks

  1616. 		/** @type {QueueItem[]} */

  1617. 		let queue = inputChunkGroups.map(chunkGroupToQueueItem).reverse();

  1618. 		/** @type {QueueItem[]} */

  1619. 		let queueDelayed = [];

  1620. 

  1621. 		/** @type {Module} */

  1622. 		let module;

  1623. 		/** @type {Chunk} */

  1624. 		let chunk;

  1625. 		/** @type {ChunkGroup} */

  1626. 		let chunkGroup;

  1627. 

  1628. 		// For each async Block in graph

  1629. 		/**

  1630. 		 * @param {AsyncDependenciesBlock} b iterating over each Async DepBlock

  1631. 		 * @returns {void}

  1632. 		 */

  1633. 		const iteratorBlock = b => {

  1634. 			// 1. We create a chunk for this Block

  1635. 			// but only once (blockChunkGroups map)

  1636. 			let c = blockChunkGroups.get(b);

  1637. 			if (c === undefined) {

  1638. 				c = this.namedChunkGroups.get(b.chunkName);

  1639. 				if (c && c.isInitial()) {

  1640. 					this.errors.push(

  1641. 						new AsyncDependencyToInitialChunkError(b.chunkName, module, b.loc)

  1642. 					);

  1643. 					c = chunkGroup;

  1644. 				} else {

  1645. 					c = this.addChunkInGroup(

  1646. 						b.groupOptions || b.chunkName,

  1647. 						module,

  1648. 						b.loc,

  1649. 						b.request

  1650. 					);

  1651. 					chunkGroupCounters.set(c, { index: 0, index2: 0 });

  1652. 					blockChunkGroups.set(b, c);

  1653. 					allCreatedChunkGroups.add(c);

  1654. 				}

  1655. 			} else {

  1656. 				// TODO webpack 5 remove addOptions check

  1657. 				if (c.addOptions) c.addOptions(b.groupOptions);

  1658. 				c.addOrigin(module, b.loc, b.request);

  1659. 			}

  1660. 

  1661. 			// 2. We store the Block+Chunk mapping as dependency for the chunk

  1662. 			let deps = chunkDependencies.get(chunkGroup);

  1663. 			if (!deps) chunkDependencies.set(chunkGroup, (deps = []));

  1664. 			deps.push({

  1665. 				block: b,

  1666. 				chunkGroup: c

  1667. 			});

  1668. 

  1669. 			// 3. We enqueue the DependenciesBlock for traversal

  1670. 			queueDelayed.push({

  1671. 				action: PROCESS_BLOCK,

  1672. 				block: b,

  1673. 				module: module,

  1674. 				chunk: c.chunks[0],

  1675. 				chunkGroup: c

  1676. 			});

  1677. 		};

  1678. 

  1679. 		// Iterative traversal of the Module graph

  1680. 		// Recursive would be simpler to write but could result in Stack Overflows

  1681. 		while (queue.length) {

  1682. 			while (queue.length) {

  1683. 				const queueItem = queue.pop();

  1684. 				module = queueItem.module;

  1685. 				block = queueItem.block;

  1686. 				chunk = queueItem.chunk;

  1687. 				chunkGroup = queueItem.chunkGroup;

  1688. 

  1689. 				switch (queueItem.action) {

  1690. 					case ADD_AND_ENTER_MODULE: {

  1691. 						// We connect Module and Chunk when not already done

  1692. 						if (chunk.addModule(module)) {

  1693. 							module.addChunk(chunk);

  1694. 						} else {

  1695. 							// already connected, skip it

  1696. 							break;

  1697. 						}

  1698. 					}

  1699. 					// fallthrough

  1700. 					case ENTER_MODULE: {

  1701. 						if (chunkGroup !== undefined) {

  1702. 							const index = chunkGroup.getModuleIndex(module);

  1703. 							if (index === undefined) {

  1704. 								chunkGroup.setModuleIndex(

  1705. 									module,

  1706. 									chunkGroupCounters.get(chunkGroup).index++

  1707. 								);

  1708. 							}

  1709. 						}

  1710. 

  1711. 						if (module.index === null) {

  1712. 							module.index = nextFreeModuleIndex++;

  1713. 						}

  1714. 

  1715. 						queue.push({

  1716. 							action: LEAVE_MODULE,

  1717. 							block,

  1718. 							module,

  1719. 							chunk,

  1720. 							chunkGroup

  1721. 						});

  1722. 					}

  1723. 					// fallthrough

  1724. 					case PROCESS_BLOCK: {

  1725. 						// get prepared block info

  1726. 						const blockInfo = blockInfoMap.get(block);

  1727. 

  1728. 						// Traverse all referenced modules

  1729. 						for (let i = blockInfo.modules.length - 1; i >= 0; i--) {

  1730. 							const refModule = blockInfo.modules[i];

  1731. 							if (chunk.containsModule(refModule)) {

  1732. 								// skip early if already connected

  1733. 								continue;

  1734. 							}

  1735. 							// enqueue the add and enter to enter in the correct order

  1736. 							// this is relevant with circular dependencies

  1737. 							queue.push({

  1738. 								action: ADD_AND_ENTER_MODULE,

  1739. 								block: refModule,

  1740. 								module: refModule,

  1741. 								chunk,

  1742. 								chunkGroup

  1743. 							});

  1744. 						}

  1745. 

  1746. 						// Traverse all Blocks

  1747. 						iterationOfArrayCallback(blockInfo.blocks, iteratorBlock);

  1748. 

  1749. 						if (blockInfo.blocks.length > 0 && module !== block) {

  1750. 							blocksWithNestedBlocks.add(block);

  1751. 						}

  1752. 						break;

  1753. 					}

  1754. 					case LEAVE_MODULE: {

  1755. 						if (chunkGroup !== undefined) {

  1756. 							const index = chunkGroup.getModuleIndex2(module);

  1757. 							if (index === undefined) {

  1758. 								chunkGroup.setModuleIndex2(

  1759. 									module,

  1760. 									chunkGroupCounters.get(chunkGroup).index2++

  1761. 								);

  1762. 							}

  1763. 						}

  1764. 

  1765. 						if (module.index2 === null) {

  1766. 							module.index2 = nextFreeModuleIndex2++;

  1767. 						}

  1768. 						break;

  1769. 					}

  1770. 				}

  1771. 			}

  1772. 			const tempQueue = queue;

  1773. 			queue = queueDelayed.reverse();

  1774. 			queueDelayed = tempQueue;

  1775. 		}

  1776. 

  1777. 		// PART TWO

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

  1779. 		let availableModules;

  1780. 		let newAvailableModules;

  1781. 		/** @type {Queue<AvailableModulesChunkGroupMapping>} */

  1782. 		const queue2 = new Queue(

  1783. 			inputChunkGroups.map(chunkGroup => ({

  1784. 				chunkGroup,

  1785. 				availableModules: new Set()

  1786. 			}))

  1787. 		);

  1788. 

  1789. 		/**

  1790. 		 * Helper function to check if all modules of a chunk are available

  1791. 		 *

  1792. 		 * @param {ChunkGroup} chunkGroup the chunkGroup to scan

  1793. 		 * @param {Set<Module>} availableModules the comparitor set

  1794. 		 * @returns {boolean} return true if all modules of a chunk are available

  1795. 		 */

  1796. 		const areModulesAvailable = (chunkGroup, availableModules) => {

  1797. 			for (const chunk of chunkGroup.chunks) {

  1798. 				for (const module of chunk.modulesIterable) {

  1799. 					if (!availableModules.has(module)) return false;

  1800. 				}

  1801. 			}

  1802. 			return true;

  1803. 		};

  1804. 

  1805. 		// For each edge in the basic chunk graph

  1806. 		/**

  1807. 		 * @param {TODO} dep the dependency used for filtering

  1808. 		 * @returns {boolean} used to filter "edges" (aka Dependencies) that were pointing

  1809. 		 * to modules that are already available. Also filters circular dependencies in the chunks graph

  1810. 		 */

  1811. 		const filterFn = dep => {

  1812. 			const depChunkGroup = dep.chunkGroup;

  1813. 			if (blocksWithNestedBlocks.has(dep.block)) return true;

  1814. 			if (areModulesAvailable(depChunkGroup, newAvailableModules)) return false; // break all modules are already available

  1815. 			return true;

  1816. 		};

  1817. 

  1818. 		/** @type {Map<ChunkGroup, Set<Module>>} */

  1819. 		const minAvailableModulesMap = new Map();

  1820. 

  1821. 		// Iterative traversing of the basic chunk graph

  1822. 		while (queue2.length) {

  1823. 			const queueItem = queue2.dequeue();

  1824. 			chunkGroup = queueItem.chunkGroup;

  1825. 			availableModules = queueItem.availableModules;

  1826. 

  1827. 			// 1. Get minimal available modules

  1828. 			// It doesn't make sense to traverse a chunk again with more available modules.

  1829. 			// This step calculates the minimal available modules and skips traversal when

  1830. 			// the list didn't shrink.

  1831. 			let minAvailableModules = minAvailableModulesMap.get(chunkGroup);

  1832. 			if (minAvailableModules === undefined) {

  1833. 				minAvailableModulesMap.set(chunkGroup, new Set(availableModules));

  1834. 			} else {

  1835. 				let deletedModules = false;

  1836. 				for (const m of minAvailableModules) {

  1837. 					if (!availableModules.has(m)) {

  1838. 						minAvailableModules.delete(m);

  1839. 						deletedModules = true;

  1840. 					}

  1841. 				}

  1842. 				if (!deletedModules) continue;

  1843. 				availableModules = minAvailableModules;

  1844. 			}

  1845. 

  1846. 			// 2. Get the edges at this point of the graph

  1847. 			const deps = chunkDependencies.get(chunkGroup);

  1848. 			if (!deps) continue;

  1849. 			if (deps.length === 0) continue;

  1850. 

  1851. 			// 3. Create a new Set of available modules at this points

  1852. 			newAvailableModules = new Set(availableModules);

  1853. 			for (const chunk of chunkGroup.chunks) {

  1854. 				for (const m of chunk.modulesIterable) {

  1855. 					newAvailableModules.add(m);

  1856. 				}

  1857. 			}

  1858. 

  1859. 			// 4. Filter edges with available modules

  1860. 			const filteredDeps = deps.filter(filterFn);

  1861. 

  1862. 			// 5. Foreach remaining edge

  1863. 			const nextChunkGroups = new Set();

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

  1865. 				const dep = filteredDeps[i];

  1866. 				const depChunkGroup = dep.chunkGroup;

  1867. 				const depBlock = dep.block;

  1868. 

  1869. 				// 6. Connect block with chunk

  1870. 				GraphHelpers.connectDependenciesBlockAndChunkGroup(

  1871. 					depBlock,

  1872. 					depChunkGroup

  1873. 				);

  1874. 

  1875. 				// 7. Connect chunk with parent

  1876. 				GraphHelpers.connectChunkGroupParentAndChild(chunkGroup, depChunkGroup);

  1877. 

  1878. 				nextChunkGroups.add(depChunkGroup);

  1879. 			}

  1880. 

  1881. 			// 8. Enqueue further traversal

  1882. 			for (const nextChunkGroup of nextChunkGroups) {

  1883. 				queue2.enqueue({

  1884. 					chunkGroup: nextChunkGroup,

  1885. 					availableModules: newAvailableModules

  1886. 				});

  1887. 			}

  1888. 		}

  1889. 

  1890. 		// Remove all unconnected chunk groups

  1891. 		for (const chunkGroup of allCreatedChunkGroups) {

  1892. 			if (chunkGroup.getNumberOfParents() === 0) {

  1893. 				for (const chunk of chunkGroup.chunks) {

  1894. 					const idx = this.chunks.indexOf(chunk);

  1895. 					if (idx >= 0) this.chunks.splice(idx, 1);

  1896. 					chunk.remove("unconnected");

  1897. 				}

  1898. 				chunkGroup.remove("unconnected");

  1899. 			}

  1900. 		}

  1901. 	}

  1902. 

  1903. 	/**

  1904. 	 *

  1905. 	 * @param {Module} module module relationship for removal

  1906. 	 * @param {DependenciesBlockLike} block //TODO: good description

  1907. 	 * @returns {void}

  1908. 	 */

  1909. 	removeReasonsOfDependencyBlock(module, block) {

  1910. 		const iteratorDependency = d => {

  1911. 			if (!d.module) {

  1912. 				return;

  1913. 			}

  1914. 			if (d.module.removeReason(module, d)) {

  1915. 				for (const chunk of d.module.chunksIterable) {

  1916. 					this.patchChunksAfterReasonRemoval(d.module, chunk);

  1917. 				}

  1918. 			}

  1919. 		};

  1920. 

  1921. 		if (block.blocks) {

  1922. 			iterationOfArrayCallback(block.blocks, block =>

  1923. 				this.removeReasonsOfDependencyBlock(module, block)

  1924. 			);

  1925. 		}

  1926. 

  1927. 		if (block.dependencies) {

  1928. 			iterationOfArrayCallback(block.dependencies, iteratorDependency);

  1929. 		}

  1930. 

  1931. 		if (block.variables) {

  1932. 			iterationBlockVariable(block.variables, iteratorDependency);

  1933. 		}

  1934. 	}

  1935. 

  1936. 	/**

  1937. 	 * @param {Module} module module to patch tie

  1938. 	 * @param {Chunk} chunk chunk to patch tie

  1939. 	 * @returns {void}

  1940. 	 */

  1941. 	patchChunksAfterReasonRemoval(module, chunk) {

  1942. 		if (!module.hasReasons()) {

  1943. 			this.removeReasonsOfDependencyBlock(module, module);

  1944. 		}

  1945. 		if (!module.hasReasonForChunk(chunk)) {

  1946. 			if (module.removeChunk(chunk)) {

  1947. 				this.removeChunkFromDependencies(module, chunk);

  1948. 			}

  1949. 		}

  1950. 	}

  1951. 

  1952. 	/**

  1953. 	 *

  1954. 	 * @param {DependenciesBlock} block block tie for Chunk

  1955. 	 * @param {Chunk} chunk chunk to remove from dep

  1956. 	 * @returns {void}

  1957. 	 */

  1958. 	removeChunkFromDependencies(block, chunk) {

  1959. 		const iteratorDependency = d => {

  1960. 			if (!d.module) {

  1961. 				return;

  1962. 			}

  1963. 			this.patchChunksAfterReasonRemoval(d.module, chunk);

  1964. 		};

  1965. 

  1966. 		const blocks = block.blocks;

  1967. 		for (let indexBlock = 0; indexBlock < blocks.length; indexBlock++) {

  1968. 			const asyncBlock = blocks[indexBlock];

  1969. 			// Grab all chunks from the first Block's AsyncDepBlock

  1970. 			const chunks = asyncBlock.chunkGroup.chunks;

  1971. 			// For each chunk in chunkGroup

  1972. 			for (let indexChunk = 0; indexChunk < chunks.length; indexChunk++) {

  1973. 				const iteratedChunk = chunks[indexChunk];

  1974. 				asyncBlock.chunkGroup.removeChunk(iteratedChunk);

  1975. 				asyncBlock.chunkGroup.removeParent(iteratedChunk);

  1976. 				// Recurse

  1977. 				this.removeChunkFromDependencies(block, iteratedChunk);

  1978. 			}

  1979. 		}

  1980. 

  1981. 		if (block.dependencies) {

  1982. 			iterationOfArrayCallback(block.dependencies, iteratorDependency);

  1983. 		}

  1984. 

  1985. 		if (block.variables) {

  1986. 			iterationBlockVariable(block.variables, iteratorDependency);

  1987. 		}

  1988. 	}

  1989. 

  1990. 	applyModuleIds() {

  1991. 		const unusedIds = [];

  1992. 		let nextFreeModuleId = 0;

  1993. 		const usedIds = new Set();

  1994. 		if (this.usedModuleIds) {

  1995. 			for (const id of this.usedModuleIds) {

  1996. 				usedIds.add(id);

  1997. 			}

  1998. 		}

  1999. 

  2000. 		const modules1 = this.modules;

  2001. 		for (let indexModule1 = 0; indexModule1 < modules1.length; indexModule1++) {

  2002. 			const module1 = modules1[indexModule1];

  2003. 			if (module1.id !== null) {

  2004. 				usedIds.add(module1.id);

  2005. 			}

  2006. 		}

  2007. 

  2008. 		if (usedIds.size > 0) {

  2009. 			let usedIdMax = -1;

  2010. 			for (const usedIdKey of usedIds) {

  2011. 				if (typeof usedIdKey !== "number") {

  2012. 					continue;

  2013. 				}

  2014. 

  2015. 				usedIdMax = Math.max(usedIdMax, usedIdKey);

  2016. 			}

  2017. 

  2018. 			let lengthFreeModules = (nextFreeModuleId = usedIdMax + 1);

  2019. 

  2020. 			while (lengthFreeModules--) {

  2021. 				if (!usedIds.has(lengthFreeModules)) {

  2022. 					unusedIds.push(lengthFreeModules);

  2023. 				}

  2024. 			}

  2025. 		}

  2026. 

  2027. 		const modules2 = this.modules;

  2028. 		for (let indexModule2 = 0; indexModule2 < modules2.length; indexModule2++) {

  2029. 			const module2 = modules2[indexModule2];

  2030. 			if (module2.id === null) {

  2031. 				if (unusedIds.length > 0) {

  2032. 					module2.id = unusedIds.pop();

  2033. 				} else {

  2034. 					module2.id = nextFreeModuleId++;

  2035. 				}

  2036. 			}

  2037. 		}

  2038. 	}

  2039. 

  2040. 	applyChunkIds() {

  2041. 		/** @type {Set<number>} */

  2042. 		const usedIds = new Set();

  2043. 

  2044. 		// Get used ids from usedChunkIds property (i. e. from records)

  2045. 		if (this.usedChunkIds) {

  2046. 			for (const id of this.usedChunkIds) {

  2047. 				if (typeof id !== "number") {

  2048. 					continue;

  2049. 				}

  2050. 

  2051. 				usedIds.add(id);

  2052. 			}

  2053. 		}

  2054. 

  2055. 		// Get used ids from existing chunks

  2056. 		const chunks = this.chunks;

  2057. 		for (let indexChunk = 0; indexChunk < chunks.length; indexChunk++) {

  2058. 			const chunk = chunks[indexChunk];

  2059. 			const usedIdValue = chunk.id;

  2060. 

  2061. 			if (typeof usedIdValue !== "number") {

  2062. 				continue;

  2063. 			}

  2064. 

  2065. 			usedIds.add(usedIdValue);

  2066. 		}

  2067. 

  2068. 		// Calculate maximum assigned chunk id

  2069. 		let nextFreeChunkId = -1;

  2070. 		for (const id of usedIds) {

  2071. 			nextFreeChunkId = Math.max(nextFreeChunkId, id);

  2072. 		}

  2073. 		nextFreeChunkId++;

  2074. 

  2075. 		// Determine free chunk ids from 0 to maximum

  2076. 		/** @type {number[]} */

  2077. 		const unusedIds = [];

  2078. 		if (nextFreeChunkId > 0) {

  2079. 			let index = nextFreeChunkId;

  2080. 			while (index--) {

  2081. 				if (!usedIds.has(index)) {

  2082. 					unusedIds.push(index);

  2083. 				}

  2084. 			}

  2085. 		}

  2086. 

  2087. 		// Assign ids to chunk which has no id

  2088. 		for (let indexChunk = 0; indexChunk < chunks.length; indexChunk++) {

  2089. 			const chunk = chunks[indexChunk];

  2090. 			if (chunk.id === null) {

  2091. 				if (unusedIds.length > 0) {

  2092. 					chunk.id = unusedIds.pop();

  2093. 				} else {

  2094. 					chunk.id = nextFreeChunkId++;

  2095. 				}

  2096. 			}

  2097. 			if (!chunk.ids) {

  2098. 				chunk.ids = [chunk.id];

  2099. 			}

  2100. 		}

  2101. 	}

  2102. 

  2103. 	sortItemsWithModuleIds() {

  2104. 		this.modules.sort(byIdOrIdentifier);

  2105. 

  2106. 		const modules = this.modules;

  2107. 		for (let indexModule = 0; indexModule < modules.length; indexModule++) {

  2108. 			modules[indexModule].sortItems(false);

  2109. 		}

  2110. 

  2111. 		const chunks = this.chunks;

  2112. 		for (let indexChunk = 0; indexChunk < chunks.length; indexChunk++) {

  2113. 			chunks[indexChunk].sortItems();

  2114. 		}

  2115. 	}

  2116. 

  2117. 	sortItemsWithChunkIds() {

  2118. 		for (const chunkGroup of this.chunkGroups) {

  2119. 			chunkGroup.sortItems();

  2120. 		}

  2121. 

  2122. 		this.chunks.sort(byId);

  2123. 

  2124. 		for (

  2125. 			let indexModule = 0;

  2126. 			indexModule < this.modules.length;

  2127. 			indexModule++

  2128. 		) {

  2129. 			this.modules[indexModule].sortItems(true);

  2130. 		}

  2131. 

  2132. 		const chunks = this.chunks;

  2133. 		for (let indexChunk = 0; indexChunk < chunks.length; indexChunk++) {

  2134. 			chunks[indexChunk].sortItems();

  2135. 		}

  2136. 

  2137. 		/**

  2138. 		 * Used to sort errors and warnings in compilation. this.warnings, and

  2139. 		 * this.errors contribute to the compilation hash and therefore should be

  2140. 		 * updated whenever other references (having a chunk id) are sorted. This preserves the hash

  2141. 		 * integrity

  2142. 		 *

  2143. 		 * @param {WebpackError} a first WebpackError instance (including subclasses)

  2144. 		 * @param {WebpackError} b second WebpackError instance (including subclasses)

  2145. 		 * @returns {-1|0|1} sort order index

  2146. 		 */

  2147. 		const byMessage = (a, b) => {

  2148. 			const ma = `${a.message}`;

  2149. 			const mb = `${b.message}`;

  2150. 			if (ma < mb) return -1;

  2151. 			if (mb < ma) return 1;

  2152. 			return 0;

  2153. 		};

  2154. 

  2155. 		this.errors.sort(byMessage);

  2156. 		this.warnings.sort(byMessage);

  2157. 		this.children.sort(byNameOrHash);

  2158. 	}

  2159. 

  2160. 	summarizeDependencies() {

  2161. 		this.fileDependencies = new SortableSet(this.compilationDependencies);

  2162. 		this.contextDependencies = new SortableSet();

  2163. 		this.missingDependencies = new SortableSet();

  2164. 

  2165. 		for (

  2166. 			let indexChildren = 0;

  2167. 			indexChildren < this.children.length;

  2168. 			indexChildren++

  2169. 		) {

  2170. 			const child = this.children[indexChildren];

  2171. 

  2172. 			addAllToSet(this.fileDependencies, child.fileDependencies);

  2173. 			addAllToSet(this.contextDependencies, child.contextDependencies);

  2174. 			addAllToSet(this.missingDependencies, child.missingDependencies);

  2175. 		}

  2176. 

  2177. 		for (

  2178. 			let indexModule = 0;

  2179. 			indexModule < this.modules.length;

  2180. 			indexModule++

  2181. 		) {

  2182. 			const module = this.modules[indexModule];

  2183. 

  2184. 			if (module.buildInfo.fileDependencies) {

  2185. 				addAllToSet(this.fileDependencies, module.buildInfo.fileDependencies);

  2186. 			}

  2187. 			if (module.buildInfo.contextDependencies) {

  2188. 				addAllToSet(

  2189. 					this.contextDependencies,

  2190. 					module.buildInfo.contextDependencies

  2191. 				);

  2192. 			}

  2193. 		}

  2194. 		for (const error of this.errors) {

  2195. 			if (

  2196. 				typeof error.missing === "object" &&

  2197. 				error.missing &&

  2198. 				error.missing[Symbol.iterator]

  2199. 			) {

  2200. 				addAllToSet(this.missingDependencies, error.missing);

  2201. 			}

  2202. 		}

  2203. 		this.fileDependencies.sort();

  2204. 		this.contextDependencies.sort();

  2205. 		this.missingDependencies.sort();

  2206. 	}

  2207. 

  2208. 	createHash() {

  2209. 		const outputOptions = this.outputOptions;

  2210. 		const hashFunction = outputOptions.hashFunction;

  2211. 		const hashDigest = outputOptions.hashDigest;

  2212. 		const hashDigestLength = outputOptions.hashDigestLength;

  2213. 		const hash = createHash(hashFunction);

  2214. 		if (outputOptions.hashSalt) {

  2215. 			hash.update(outputOptions.hashSalt);

  2216. 		}

  2217. 		this.mainTemplate.updateHash(hash);

  2218. 		this.chunkTemplate.updateHash(hash);

  2219. 		for (const key of Object.keys(this.moduleTemplates).sort()) {

  2220. 			this.moduleTemplates[key].updateHash(hash);

  2221. 		}

  2222. 		for (const child of this.children) {

  2223. 			hash.update(child.hash);

  2224. 		}

  2225. 		for (const warning of this.warnings) {

  2226. 			hash.update(`${warning.message}`);

  2227. 		}

  2228. 		for (const error of this.errors) {

  2229. 			hash.update(`${error.message}`);

  2230. 		}

  2231. 		const modules = this.modules;

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

  2233. 			const module = modules[i];

  2234. 			const moduleHash = createHash(hashFunction);

  2235. 			module.updateHash(moduleHash);

  2236. 			module.hash = moduleHash.digest(hashDigest);

  2237. 			module.renderedHash = module.hash.substr(0, hashDigestLength);

  2238. 		}

  2239. 		// clone needed as sort below is inplace mutation

  2240. 		const chunks = this.chunks.slice();

  2241. 		/**

  2242. 		 * sort here will bring all "falsy" values to the beginning

  2243. 		 * this is needed as the "hasRuntime()" chunks are dependent on the

  2244. 		 * hashes of the non-runtime chunks.

  2245. 		 */

  2246. 		chunks.sort((a, b) => {

  2247. 			const aEntry = a.hasRuntime();

  2248. 			const bEntry = b.hasRuntime();

  2249. 			if (aEntry && !bEntry) return 1;

  2250. 			if (!aEntry && bEntry) return -1;

  2251. 			return byId(a, b);

  2252. 		});

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

  2254. 			const chunk = chunks[i];

  2255. 			const chunkHash = createHash(hashFunction);

  2256. 			if (outputOptions.hashSalt) {

  2257. 				chunkHash.update(outputOptions.hashSalt);

  2258. 			}

  2259. 			chunk.updateHash(chunkHash);

  2260. 			const template = chunk.hasRuntime()

  2261. 				? this.mainTemplate

  2262. 				: this.chunkTemplate;

  2263. 			template.updateHashForChunk(

  2264. 				chunkHash,

  2265. 				chunk,

  2266. 				this.moduleTemplates.javascript,

  2267. 				this.dependencyTemplates

  2268. 			);

  2269. 			this.hooks.chunkHash.call(chunk, chunkHash);

  2270. 			chunk.hash = chunkHash.digest(hashDigest);

  2271. 			hash.update(chunk.hash);

  2272. 			chunk.renderedHash = chunk.hash.substr(0, hashDigestLength);

  2273. 			this.hooks.contentHash.call(chunk);

  2274. 		}

  2275. 		this.fullHash = hash.digest(hashDigest);

  2276. 		this.hash = this.fullHash.substr(0, hashDigestLength);

  2277. 	}

  2278. 

  2279. 	/**

  2280. 	 * @param {string} update extra information

  2281. 	 * @returns {void}

  2282. 	 */

  2283. 	modifyHash(update) {

  2284. 		const outputOptions = this.outputOptions;

  2285. 		const hashFunction = outputOptions.hashFunction;

  2286. 		const hashDigest = outputOptions.hashDigest;

  2287. 		const hashDigestLength = outputOptions.hashDigestLength;

  2288. 		const hash = createHash(hashFunction);

  2289. 		hash.update(this.fullHash);

  2290. 		hash.update(update);

  2291. 		this.fullHash = hash.digest(hashDigest);

  2292. 		this.hash = this.fullHash.substr(0, hashDigestLength);

  2293. 	}

  2294. 

  2295. 	createModuleAssets() {

  2296. 		for (let i = 0; i < this.modules.length; i++) {

  2297. 			const module = this.modules[i];

  2298. 			if (module.buildInfo.assets) {

  2299. 				for (const assetName of Object.keys(module.buildInfo.assets)) {

  2300. 					const fileName = this.getPath(assetName);

  2301. 					this.assets[fileName] = module.buildInfo.assets[assetName];

  2302. 					this.hooks.moduleAsset.call(module, fileName);

  2303. 				}

  2304. 			}

  2305. 		}

  2306. 	}

  2307. 

  2308. 	createChunkAssets() {

  2309. 		const outputOptions = this.outputOptions;

  2310. 		const cachedSourceMap = new Map();

  2311. 		/** @type {Map<string, {hash: string, source: Source, chunk: Chunk}>} */

  2312. 		const alreadyWrittenFiles = new Map();

  2313. 		for (let i = 0; i < this.chunks.length; i++) {

  2314. 			const chunk = this.chunks[i];

  2315. 			chunk.files = [];

  2316. 			let source;

  2317. 			let file;

  2318. 			let filenameTemplate;

  2319. 			try {

  2320. 				const template = chunk.hasRuntime()

  2321. 					? this.mainTemplate

  2322. 					: this.chunkTemplate;

  2323. 				const manifest = template.getRenderManifest({

  2324. 					chunk,

  2325. 					hash: this.hash,

  2326. 					fullHash: this.fullHash,

  2327. 					outputOptions,

  2328. 					moduleTemplates: this.moduleTemplates,

  2329. 					dependencyTemplates: this.dependencyTemplates

  2330. 				}); // [{ render(), filenameTemplate, pathOptions, identifier, hash }]

  2331. 				for (const fileManifest of manifest) {

  2332. 					const cacheName = fileManifest.identifier;

  2333. 					const usedHash = fileManifest.hash;

  2334. 					filenameTemplate = fileManifest.filenameTemplate;

  2335. 					file = this.getPath(filenameTemplate, fileManifest.pathOptions);

  2336. 

  2337. 					// check if the same filename was already written by another chunk

  2338. 					const alreadyWritten = alreadyWrittenFiles.get(file);

  2339. 					if (alreadyWritten !== undefined) {

  2340. 						if (alreadyWritten.hash === usedHash) {

  2341. 							if (this.cache) {

  2342. 								this.cache[cacheName] = {

  2343. 									hash: usedHash,

  2344. 									source: alreadyWritten.source

  2345. 								};

  2346. 							}

  2347. 							chunk.files.push(file);

  2348. 							this.hooks.chunkAsset.call(chunk, file);

  2349. 							continue;

  2350. 						} else {

  2351. 							throw new Error(

  2352. 								`Conflict: Multiple chunks emit assets to the same filename ${file}` +

  2353. 									` (chunks ${alreadyWritten.chunk.id} and ${chunk.id})`

  2354. 							);

  2355. 						}

  2356. 					}

  2357. 					if (

  2358. 						this.cache &&

  2359. 						this.cache[cacheName] &&

  2360. 						this.cache[cacheName].hash === usedHash

  2361. 					) {

  2362. 						source = this.cache[cacheName].source;

  2363. 					} else {

  2364. 						source = fileManifest.render();

  2365. 						// Ensure that source is a cached source to avoid additional cost because of repeated access

  2366. 						if (!(source instanceof CachedSource)) {

  2367. 							const cacheEntry = cachedSourceMap.get(source);

  2368. 							if (cacheEntry) {

  2369. 								source = cacheEntry;

  2370. 							} else {

  2371. 								const cachedSource = new CachedSource(source);

  2372. 								cachedSourceMap.set(source, cachedSource);

  2373. 								source = cachedSource;

  2374. 							}

  2375. 						}

  2376. 						if (this.cache) {

  2377. 							this.cache[cacheName] = {

  2378. 								hash: usedHash,

  2379. 								source

  2380. 							};

  2381. 						}

  2382. 					}

  2383. 					if (this.assets[file] && this.assets[file] !== source) {

  2384. 						throw new Error(

  2385. 							`Conflict: Multiple assets emit to the same filename ${file}`

  2386. 						);

  2387. 					}

  2388. 					this.assets[file] = source;

  2389. 					chunk.files.push(file);

  2390. 					this.hooks.chunkAsset.call(chunk, file);

  2391. 					alreadyWrittenFiles.set(file, {

  2392. 						hash: usedHash,

  2393. 						source,

  2394. 						chunk

  2395. 					});

  2396. 				}

  2397. 			} catch (err) {

  2398. 				this.errors.push(

  2399. 					new ChunkRenderError(chunk, file || filenameTemplate, err)

  2400. 				);

  2401. 			}

  2402. 		}

  2403. 	}

  2404. 

  2405. 	/**

  2406. 	 * @param {string} filename used to get asset path with hash

  2407. 	 * @param {TODO=} data // TODO: figure out this param type

  2408. 	 * @returns {string} interpolated path

  2409. 	 */

  2410. 	getPath(filename, data) {

  2411. 		data = data || {};

  2412. 		data.hash = data.hash || this.hash;

  2413. 		return this.mainTemplate.getAssetPath(filename, data);

  2414. 	}

  2415. 

  2416. 	/**

  2417. 	 * This function allows you to run another instance of webpack inside of webpack however as

  2418. 	 * a child with different settings and configurations (if desired) applied. It copies all hooks, plugins

  2419. 	 * from parent (or top level compiler) and creates a child Compilation

  2420. 	 *

  2421. 	 * @param {string} name name of the child compiler

  2422. 	 * @param {TODO} outputOptions // Need to convert config schema to types for this

  2423. 	 * @param {Plugin[]} plugins webpack plugins that will be applied

  2424. 	 * @returns {Compiler} creates a child Compiler instance

  2425. 	 */

  2426. 	createChildCompiler(name, outputOptions, plugins) {

  2427. 		const idx = this.childrenCounters[name] || 0;

  2428. 		this.childrenCounters[name] = idx + 1;

  2429. 		return this.compiler.createChildCompiler(

  2430. 			this,

  2431. 			name,

  2432. 			idx,

  2433. 			outputOptions,

  2434. 			plugins

  2435. 		);

  2436. 	}

  2437. 

  2438. 	checkConstraints() {

  2439. 		/** @type {Set<number|string>} */

  2440. 		const usedIds = new Set();

  2441. 

  2442. 		const modules = this.modules;

  2443. 		for (let indexModule = 0; indexModule < modules.length; indexModule++) {

  2444. 			const moduleId = modules[indexModule].id;

  2445. 			if (moduleId === null) continue;

  2446. 			if (usedIds.has(moduleId)) {

  2447. 				throw new Error(`checkConstraints: duplicate module id ${moduleId}`);

  2448. 			}

  2449. 			usedIds.add(moduleId);

  2450. 		}

  2451. 

  2452. 		const chunks = this.chunks;

  2453. 		for (let indexChunk = 0; indexChunk < chunks.length; indexChunk++) {

  2454. 			const chunk = chunks[indexChunk];

  2455. 			if (chunks.indexOf(chunk) !== indexChunk) {

  2456. 				throw new Error(

  2457. 					`checkConstraints: duplicate chunk in compilation ${chunk.debugId}`

  2458. 				);

  2459. 			}

  2460. 		}

  2461. 

  2462. 		for (const chunkGroup of this.chunkGroups) {

  2463. 			chunkGroup.checkConstraints();

  2464. 		}

  2465. 	}

  2466. }

  2467. 

  2468. // TODO remove in webpack 5

  2469. Compilation.prototype.applyPlugins = util.deprecate(

  2470. 	/**

  2471. 	 * @deprecated

  2472. 	 * @param {string} name Name

  2473. 	 * @param {any[]} args Other arguments

  2474. 	 * @returns {void}

  2475. 	 * @this {Compilation}

  2476. 	 */

  2477. 	function(name, ...args) {

  2478. 		this.hooks[

  2479. 			name.replace(/[- ]([a-z])/g, match => match[1].toUpperCase())

  2480. 		].call(...args);

  2481. 	},

  2482. 	"Compilation.applyPlugins is deprecated. Use new API on `.hooks` instead"

  2483. );

  2484. 

  2485. // TODO remove in webpack 5

  2486. Object.defineProperty(Compilation.prototype, "moduleTemplate", {

  2487. 	configurable: false,

  2488. 	get: util.deprecate(

  2489. 		/**

  2490. 		 * @deprecated

  2491. 		 * @this {Compilation}

  2492. 		 * @returns {TODO} module template

  2493. 		 */

  2494. 		function() {

  2495. 			return this.moduleTemplates.javascript;

  2496. 		},

  2497. 		"Compilation.moduleTemplate: Use Compilation.moduleTemplates.javascript instead"

  2498. 	),

  2499. 	set: util.deprecate(

  2500. 		/**

  2501. 		 * @deprecated

  2502. 		 * @param {ModuleTemplate} value Template value

  2503. 		 * @this {Compilation}

  2504. 		 * @returns {void}

  2505. 		 */

  2506. 		function(value) {

  2507. 			this.moduleTemplates.javascript = value;

  2508. 		},

  2509. 		"Compilation.moduleTemplate: Use Compilation.moduleTemplates.javascript instead."

  2510. 	)

  2511. });

  2512. 

  2513. module.exports = Compilation;