Method seal

lib/Compilation.js:3495–3879

* Processes the provided callback. * @param {Callback} callback signals when the call finishes * @returns {void}

(callback)

	 * @returns {void}
	 */
	seal(callback) {
		/**
		 * Processes the provided err.
		 * @param {WebpackError=} err err
		 * @returns {void}
		 */
		const finalCallback = (err) => {
			this.factorizeQueue.clear();
			this.buildQueue.clear();
			this.rebuildQueue.clear();
			this.processDependenciesQueue.clear();
			this.addModuleQueue.clear();
			// lazy barrel only acts during make; release its bookkeeping now
			this._lazyBarrelController.clear();
			return callback(err);
		};

		if (this._backCompat) {
			for (const module of this.modules) {
				ChunkGraph.setChunkGraphForModule(module, this.chunkGraph);
			}
		}

		this.hooks.seal.call();

		this.logger.time("optimize dependencies");
		while (this.hooks.optimizeDependencies.call(this.modules)) {
			/* empty */
		}
		this.hooks.afterOptimizeDependencies.call(this.modules);
		this.logger.timeEnd("optimize dependencies");

		this.logger.time("create chunks");
		this.hooks.beforeChunks.call();
		this.moduleGraph.freeze("seal");
		/** @type {Map<Entrypoint, Module[]>} */
		const chunkGraphInit = new Map();
		for (const [name, { dependencies, includeDependencies, options }] of this
			.entries) {
			const chunk = this.addChunk(name);
			if (options.filename) {
				chunk.filenameTemplate = options.filename;
			}
			const entrypoint = new Entrypoint(options);
			if (!options.dependOn && !options.runtime) {
				entrypoint.setRuntimeChunk(chunk);
			}
			entrypoint.setEntrypointChunk(chunk);
			this.namedChunkGroups.set(name, entrypoint);
			this.entrypoints.set(name, entrypoint);
			this.chunkGroups.push(entrypoint);

			if (entrypoint.pushChunk(chunk)) {
				chunk.addGroup(entrypoint);
			}

			/** @type {Set<Module>} */
			const entryModules = new Set();