@depup/webpack 5.111.1-depup.2 → 5.112.0-depup.0

package/lib/LazyBarrel.js

@@ -1,388 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Haijie Xie @hai-x
-*/
-
-"use strict";
-
-const Dependency = require("./Dependency");
-
-/** @import Compilation, { DependencyConstructor } from "./Compilation" */
-/** @import Module from "./Module" */
-/** @import ModuleFactory from "./ModuleFactory" */
-
-/**
- * Defines the deferred request group type used by this module.
- * @typedef {object} DependencyGroup
- * @property {ModuleFactory} factory factory for the request
- * @property {Dependency[]} dependencies deferred dependencies of the request
- * @property {string | undefined} context request context
- */
-
-/**
- * Defines the lazy barrel state type used by this module.
- * @typedef {object} LazyBarrelState
- * @property {Set<string> | true} forwardedIds export names requested so far, true for all
- * @property {LazyBarrelInfo | undefined} lazyBarrelInfo deferred dependencies, undefined until classified
- */
-
-/**
- * Defines the lazy barrel unlazy item type used by this module.
- * @typedef {object} UnlazyDependencyInfo
- * @property {ModuleFactory} factory factory for the request
- * @property {Dependency[]} dependencies deferred dependencies of the request
- * @property {string | undefined} context request context
- * @property {Module} originModule the lazy barrel module
- */
-
-/**
- * Collects the export names a dependency group requests from its target.
- * @param {Dependency[]} dependencies dependency group resolving to one module
- * @returns {Set<string> | true} requested export names, true for all
- */
-function getForwardedIds(dependencies) {
-	/** @type {Set<string>} */
-	const ids = new Set();
-	for (const dependency of dependencies) {
-		// TODO remove in webpack 6
-		// It may be missing on custom dependency types not extending the base Dependency
-		if (!("getForwardId" in dependency)) continue;
-
-		const id = dependency.getForwardId();
-		if (id === true) return true;
-		if (id !== null) ids.add(id);
-	}
-	return ids;
-}
-
-/**
- * Tracks the deferred (not yet factorized/built) dependencies of a
- * side-effect-free barrel module and which export names resolve to them.
- */
-class LazyBarrelInfo {
-	constructor() {
-		/** @type {Map<string, string>} forward id -> request key */
-		this._forwardIdToRequest = new Map();
-		/** @type {Map<string, DependencyGroup>} request key -> still-deferred group */
-		this._requestToDepGroup = new Map();
-		/** @type {Set<string> | undefined} locally provided export names */
-		this._terminalIds = undefined;
-		/** @type {Set<string> | undefined} requests of star re-exports */
-		this._fallbackRequests = undefined;
-	}
-
-	/**
-	 * Records a deferred dependency under its request key.
-	 * @param {string} requestKey request key
-	 * @param {Dependency} dependency dependency to defer
-	 * @param {ModuleFactory} factory factory for the request
-	 * @param {string | undefined} context request context
-	 */
-	addLazy(requestKey, dependency, factory, context) {
-		let group = this._requestToDepGroup.get(requestKey);
-		if (group === undefined) {
-			group = { factory, dependencies: [], context };
-			this._requestToDepGroup.set(requestKey, group);
-		}
-		group.dependencies.push(dependency);
-	}
-
-	/**
-	 * Maps an export name to the request providing it.
-	 * @param {string} id export name
-	 * @param {string} requestKey request key
-	 */
-	addForwardId(id, requestKey) {
-		this._forwardIdToRequest.set(id, requestKey);
-	}
-
-	/**
-	 * Registers a locally provided export name.
-	 * @param {string} id export name
-	 */
-	addTerminal(id) {
-		if (this._terminalIds === undefined) this._terminalIds = new Set();
-		this._terminalIds.add(id);
-	}
-
-	/**
-	 * Registers a star re-export request key.
-	 * @param {string} requestKey request key
-	 */
-	addFallback(requestKey) {
-		if (this._fallbackRequests === undefined) {
-			this._fallbackRequests = new Set();
-		}
-		this._fallbackRequests.add(requestKey);
-	}
-
-	/**
-	 * Returns whether nothing is deferred.
-	 * @returns {boolean} true, when no dependency is deferred
-	 */
-	isEmpty() {
-		return this._requestToDepGroup.size === 0;
-	}
-
-	/**
-	 * Returns the requests of the still-lazy groups.
-	 * @returns {Iterable<string>} still-lazy requests
-	 */
-	getLazyRequests() {
-		return this._requestToDepGroup.keys();
-	}
-
-	/**
-	 * Drops the export-name lookups once no group stays deferred; they only serve
-	 * to find still-deferred groups, so keeping them per module wastes memory.
-	 */
-	_release() {
-		this._forwardIdToRequest.clear();
-		this._terminalIds = undefined;
-		this._fallbackRequests = undefined;
-	}
-
-	/**
-	 * Removes and returns the groups needed to provide the requested export names.
-	 * @param {Set<string> | true} forwardedIds requested export names, true for all
-	 * @returns {DependencyGroup[]} groups that must be processed now
-	 */
-	request(forwardedIds) {
-		/** @type {DependencyGroup[]} */
-		const result = [];
-		/**
-		 * @param {DependencyGroup} group taken group
-		 */
-		const unlazy = (group) => {
-			for (const dependency of group.dependencies) {
-				dependency.setLazy(false);
-			}
-			result.push(group);
-		};
-		if (forwardedIds === true) {
-			for (const group of this._requestToDepGroup.values()) unlazy(group);
-			this._requestToDepGroup.clear();
-			this._release();
-			return result;
-		}
-		/**
-		 * @param {string} requestKey request key to take
-		 */
-		const take = (requestKey) => {
-			const group = this._requestToDepGroup.get(requestKey);
-			if (group === undefined) return;
-			this._requestToDepGroup.delete(requestKey);
-			unlazy(group);
-		};
-		for (const id of forwardedIds) {
-			if (this._terminalIds !== undefined && this._terminalIds.has(id)) {
-				continue;
-			}
-			const requestKey = this._forwardIdToRequest.get(id);
-			if (requestKey !== undefined) {
-				take(requestKey);
-			} else if (this._fallbackRequests !== undefined) {
-				// unknown name: any star re-export may provide it
-				for (const fallbackKey of this._fallbackRequests) take(fallbackKey);
-			}
-		}
-		if (this._requestToDepGroup.size === 0) this._release();
-		return result;
-	}
-}
-
-const esmDependencyCategory = "esm";
-
-/**
- * Owns the per side-effect-free module lazy barrel state for a `Compilation`,
- * keeping the deferral bookkeeping out of `Compilation` itself.
- */
-class LazyBarrelController {
-	/**
-	 * @param {Compilation} compilation the owning compilation
-	 */
-	constructor(compilation) {
-		/** @type {Compilation} */
-		this._compilation = compilation;
-		/** @type {WeakMap<Module, LazyBarrelState>} */
-		this._modules = new WeakMap();
-	}
-
-	/**
-	 * Releases all per-module deferral state. The last consumer is
-	 * `FlagDependencyExportsPlugin`'s cache key during `finishModules`, so the
-	 * bookkeeping is dead weight once sealing starts.
-	 */
-	clear() {
-		this._modules = new WeakMap();
-	}
-
-	/**
-	 * requests of the re-export targets `module` still keeps lazy.
-	 * `FlagDependencyExportsPlugin` folds them into its provided-exports cache
-	 * key, so a barrel whose built targets differ from a cached run does not
-	 * reuse that run's stale exports.
-	 * @param {Module} module the module
-	 * @returns {Iterable<string> | undefined} still-lazy requests, if any
-	 */
-	getLazyRequests(module) {
-		const factoryMeta = module.factoryMeta;
-		if (factoryMeta === undefined || !factoryMeta.sideEffectFree) return;
-		const state = this._modules.get(module);
-		if (state === undefined) return;
-		const info = state.lazyBarrelInfo;
-		if (info === undefined || info.isEmpty()) return;
-		return info.getLazyRequests();
-	}
-
-	/**
-	 * Classifies the re-export dependencies of a side-effect-free module (lazy barrel)
-	 * into deferrable groups and marks the deferred ones.
-	 * @param {Module} module the module whose dependencies are processed
-	 * @returns {boolean} true, when some dependencies were deferred
-	 */
-	classify(module) {
-		const modules = this._modules;
-		const factoryMeta = module.factoryMeta;
-		if (factoryMeta === undefined || !factoryMeta.sideEffectFree) {
-			return false;
-		}
-		const dependencies = module.dependencies;
-		const dependencyFactories = this._compilation.dependencyFactories;
-		/** @type {LazyBarrelInfo | undefined} */
-		let info;
-		let hasFallback = false;
-		for (const dep of dependencies) {
-			// TODO remove in webpack 6
-			// It may be missing on custom dependency types not extending the base Dependency
-			if (!("getLazyUntil" in dep)) continue;
-
-			const until = dep.getLazyUntil();
-			// null (eager) and LAZY_UNTIL_LOCAL (terminal) defer nothing; terminals are
-			// only consulted alongside a star re-export, so they are recorded below
-			if (until === null || until === Dependency.LAZY_UNTIL_LOCAL) continue;
-			// deferrable: setLazy is needed to toggle its deferred state
-			if (!("setLazy" in dep)) continue;
-			const resourceIdent = dep.getResourceIdentifier();
-			if (resourceIdent === null) continue;
-			const factory = dependencyFactories.get(
-				/** @type {DependencyConstructor} */ (dep.constructor)
-			);
-			if (factory === undefined) continue;
-			const category = dep.category;
-			// Match the request grouping key of `processDependencyForResolving`
-			const requestKey =
-				category === esmDependencyCategory
-					? resourceIdent
-					: `${category}${resourceIdent}`;
-			if (info === undefined) info = new LazyBarrelInfo();
-			if (dep.isLazy()) {
-				info.addLazy(requestKey, dep, factory, dep.getContext());
-			}
-			if (until === Dependency.LAZY_UNTIL_ID) {
-				info.addForwardId(
-					/** @type {string} */ (dep.getLazyName()),
-					requestKey
-				);
-			} else if (until === Dependency.LAZY_UNTIL_FALLBACK) {
-				info.addFallback(requestKey);
-				hasFallback = true;
-			}
-		}
-		const state = modules.get(module);
-		// info is only created once a deferrable target exists, so it is never empty here
-		if (info === undefined) {
-			if (state !== undefined) modules.delete(module);
-			return false;
-		}
-		// terminals only matter together with a star re-export (to avoid building it
-		// for a locally-provided name); skip the extra pass otherwise
-		if (hasFallback) {
-			for (const dep of dependencies) {
-				if (
-					"getLazyUntil" in dep &&
-					dep.getLazyUntil() === Dependency.LAZY_UNTIL_LOCAL
-				) {
-					info.addTerminal(/** @type {string} */ (dep.getLazyName()));
-				}
-			}
-		}
-		if (state !== undefined) {
-			// barrel classified after its targets were already requested: replay the
-			// recorded ids so processDependency un-lazies and builds those targets now
-			info.request(state.forwardedIds);
-			// stay lazy only while some targets remain deferred
-			if (info.isEmpty()) return false;
-			state.lazyBarrelInfo = info;
-			return true;
-		}
-
-		modules.set(module, {
-			forwardedIds: new Set(),
-			lazyBarrelInfo: info
-		});
-
-		return true;
-	}
-
-	/**
-	 * Requests the export names that `dependencies` need from a lazy barrel and
-	 * returns the deferred re-export targets that must be built now. Records the
-	 * request when the barrel's dependencies were not classified yet.
-	 * @param {Module} module the resolved module
-	 * @param {Dependency[]} dependencies the dependencies that resolved to the module
-	 * @returns {UnlazyDependencyInfo[] | undefined} items to process, if any
-	 */
-	request(module, dependencies) {
-		// state only exists for side-effect-free modules, so a non-side-effect-free
-		// module never has state — skip the WeakMap lookup entirely for it
-		const factoryMeta = module.factoryMeta;
-		if (factoryMeta === undefined || !factoryMeta.sideEffectFree) return;
-		const modules = this._modules;
-		const state = modules.get(module);
-
-		if (state === undefined) {
-			const forwardedIds = getForwardedIds(dependencies);
-			if (forwardedIds !== true && forwardedIds.size === 0) return;
-			modules.set(module, {
-				forwardedIds,
-				lazyBarrelInfo: undefined
-			});
-			return;
-		}
-
-		const forwardedIds = getForwardedIds(dependencies);
-		if (forwardedIds !== true && forwardedIds.size === 0) return;
-		if (state.forwardedIds !== true) {
-			if (forwardedIds === true) state.forwardedIds = true;
-			else for (const id of forwardedIds) state.forwardedIds.add(id);
-		}
-		const info = state.lazyBarrelInfo;
-		// Pending requests will be replayed during `classify` later
-		if (info === undefined) return;
-		const groups = info.request(forwardedIds);
-		// drop the per-module state once every deferred target has been built
-		if (info.isEmpty()) state.lazyBarrelInfo = undefined;
-		if (groups.length === 0) return;
-		return groups.map((group) => ({
-			factory: group.factory,
-			dependencies: group.dependencies,
-			context: group.context,
-			originModule: module
-		}));
-	}
-
-	/**
-	 * Queues the deferred dependency groups of a lazy barrel requested by a single dependency.
-	 * @param {Module} module the resolved module of the dependency
-	 * @param {Dependency} dependency the requesting dependency
-	 * @param {{ factory: ModuleFactory, dependencies: Dependency[], context: string | undefined, originModule: Module | null }[]} sortedDependencies item list to append to
-	 */
-	unlazyForDependency(module, dependency, sortedDependencies) {
-		const unlazyItems = this.request(module, [dependency]);
-		if (unlazyItems === undefined) return;
-		for (const item of unlazyItems) sortedDependencies.push(item);
-	}
-}
-
-module.exports = LazyBarrelController;

package/lib/dependencies/HarmonyAcceptImportDependency.js

@@ -1,39 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-"use strict";
-
-const makeSerializable = require("../util/makeSerializable");
-const HarmonyImportDependency = require("./HarmonyImportDependency");
-const { ImportPhase } = require("./ImportPhase");
-const NullDependency = require("./NullDependency");
-
-class HarmonyAcceptImportDependency extends HarmonyImportDependency {
-	/**
-	 * Creates an instance of HarmonyAcceptImportDependency.
-	 * @param {string} request the request string
-	 */
-	constructor(request) {
-		super(request, Infinity, ImportPhase.Evaluation);
-		/** @type {boolean} */
-		this.weak = true;
-	}
-
-	get type() {
-		return "harmony accept";
-	}
-}
-
-makeSerializable(
-	HarmonyAcceptImportDependency,
-	"webpack/lib/dependencies/HarmonyAcceptImportDependency"
-);
-
-HarmonyAcceptImportDependency.Template =
-	/** @type {typeof HarmonyImportDependency.Template} */ (
-		NullDependency.Template
-	);
-
-module.exports = HarmonyAcceptImportDependency;

package/lib/dependencies/HarmonyModulesPlugin.js

@@ -1,192 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-
-"use strict";
-
-const {
-	JAVASCRIPT_MODULE_TYPE_AUTO,
-	JAVASCRIPT_MODULE_TYPE_ESM
-} = require("../ModuleTypeConstants");
-const CreateRequireParserPlugin = require("./CreateRequireParserPlugin");
-const HarmonyAcceptDependency = require("./HarmonyAcceptDependency");
-const HarmonyAcceptImportDependency = require("./HarmonyAcceptImportDependency");
-const HarmonyCompatibilityDependency = require("./HarmonyCompatibilityDependency");
-const HarmonyDetectionParserPlugin = require("./HarmonyDetectionParserPlugin");
-const HarmonyEvaluatedImportSpecifierDependency = require("./HarmonyEvaluatedImportSpecifierDependency");
-const HarmonyExportDependencyParserPlugin = require("./HarmonyExportDependencyParserPlugin");
-const HarmonyExportExpressionDependency = require("./HarmonyExportExpressionDependency");
-const HarmonyExportHeaderDependency = require("./HarmonyExportHeaderDependency");
-const HarmonyExportImportedSpecifierDependency = require("./HarmonyExportImportedSpecifierDependency");
-const HarmonyExportSpecifierDependency = require("./HarmonyExportSpecifierDependency");
-const HarmonyImportBareSideEffectDependency = require("./HarmonyImportBareSideEffectDependency");
-const HarmonyImportDependencyParserPlugin = require("./HarmonyImportDependencyParserPlugin");
-const HarmonyImportSideEffectDependency = require("./HarmonyImportSideEffectDependency");
-const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDependency");
-
-const HarmonyTopLevelThisParserPlugin = require("./HarmonyTopLevelThisParserPlugin");
-const TopLevelAwaitDependency = require("./TopLevelAwaitDependency");
-
-/**
- * @import {
- * 	JavascriptParserOptions
- * } from "../../declarations/WebpackOptions"
- */
-/** @import Compiler from "../Compiler" */
-/** @import Parser from "../javascript/JavascriptParser" */
-/** @import { BuildInfo } from "../Module" */
-
-/**
- * Defines the harmony modules plugin options type used by this module.
- * @typedef {object} HarmonyModulesPluginOptions
- * @property {boolean=} deferImport
- */
-
-const PLUGIN_NAME = "HarmonyModulesPlugin";
-
-class HarmonyModulesPlugin {
-	/**
-	 * Creates an instance of HarmonyModulesPlugin.
-	 * @param {HarmonyModulesPluginOptions} options options
-	 */
-	constructor(options) {
-		/** @type {HarmonyModulesPluginOptions} */
-		this.options = options;
-	}
-
-	/**
-	 * Applies the plugin by registering its hooks on the compiler.
-	 * @param {Compiler} compiler the compiler instance
-	 * @returns {void}
-	 */
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			PLUGIN_NAME,
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyTemplates.set(
-					HarmonyCompatibilityDependency,
-					new HarmonyCompatibilityDependency.Template()
-				);
-
-				compilation.dependencyTemplates.set(
-					TopLevelAwaitDependency,
-					new TopLevelAwaitDependency.Template()
-				);
-
-				compilation.dependencyFactories.set(
-					HarmonyImportSideEffectDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					HarmonyImportSideEffectDependency,
-					new HarmonyImportSideEffectDependency.Template()
-				);
-
-				compilation.dependencyFactories.set(
-					HarmonyImportBareSideEffectDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					HarmonyImportBareSideEffectDependency,
-					new HarmonyImportBareSideEffectDependency.Template()
-				);
-
-				compilation.dependencyFactories.set(
-					HarmonyImportSpecifierDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					HarmonyImportSpecifierDependency,
-					new HarmonyImportSpecifierDependency.Template()
-				);
-
-				compilation.dependencyFactories.set(
-					HarmonyEvaluatedImportSpecifierDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					HarmonyEvaluatedImportSpecifierDependency,
-					new HarmonyEvaluatedImportSpecifierDependency.Template()
-				);
-
-				compilation.dependencyTemplates.set(
-					HarmonyExportHeaderDependency,
-					new HarmonyExportHeaderDependency.Template()
-				);
-
-				compilation.dependencyTemplates.set(
-					HarmonyExportExpressionDependency,
-					new HarmonyExportExpressionDependency.Template()
-				);
-
-				compilation.dependencyTemplates.set(
-					HarmonyExportSpecifierDependency,
-					new HarmonyExportSpecifierDependency.Template()
-				);
-
-				compilation.dependencyFactories.set(
-					HarmonyExportImportedSpecifierDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					HarmonyExportImportedSpecifierDependency,
-					new HarmonyExportImportedSpecifierDependency.Template()
-				);
-
-				compilation.dependencyTemplates.set(
-					HarmonyAcceptDependency,
-					new HarmonyAcceptDependency.Template()
-				);
-
-				compilation.dependencyFactories.set(
-					HarmonyAcceptImportDependency,
-					normalModuleFactory
-				);
-				compilation.dependencyTemplates.set(
-					HarmonyAcceptImportDependency,
-					new HarmonyAcceptImportDependency.Template()
-				);
-
-				/**
-				 * Handles the hook callback for this code path.
-				 * @param {Parser} parser parser parser
-				 * @param {JavascriptParserOptions} parserOptions parserOptions
-				 * @returns {void}
-				 */
-				const handler = (parser, parserOptions) => {
-					// TODO webpack 6: rename harmony to esm or module
-					if (parserOptions.harmony !== undefined && !parserOptions.harmony) {
-						return;
-					}
-
-					if (parserOptions.specNamespaceObject) {
-						// Recorded on the module, because an importer asks the module it
-						// imports whether its namespace is a spec exotic object.
-						parser.hooks.program.tap(PLUGIN_NAME, () => {
-							/** @type {BuildInfo} */
-							(parser.state.module.buildInfo).specNamespaceObject = true;
-						});
-					}
-
-					new HarmonyDetectionParserPlugin().apply(parser);
-					new HarmonyImportDependencyParserPlugin(parserOptions).apply(parser);
-					new HarmonyExportDependencyParserPlugin(parserOptions).apply(parser);
-					new HarmonyTopLevelThisParserPlugin().apply(parser);
-					if (parserOptions.createRequire) {
-						new CreateRequireParserPlugin(parserOptions).apply(parser);
-					}
-				};
-
-				normalModuleFactory.hooks.parser
-					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
-					.tap(PLUGIN_NAME, handler);
-				normalModuleFactory.hooks.parser
-					.for(JAVASCRIPT_MODULE_TYPE_ESM)
-					.tap(PLUGIN_NAME, handler);
-			}
-		);
-	}
-}
-
-module.exports = HarmonyModulesPlugin;

package/lib/javascript/ChunkFormatHelpers.js

@@ -1,72 +0,0 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Natsu @xiaoxiaojx
-*/
-
-"use strict";
-
-const { updateHashForEntryStartup } = require("./StartupHelpers");
-
-/** @import ChunkGraph from "../ChunkGraph" */
-/** @import Module from "../Module" */
-/** @import Chunk from "../Chunk" */
-/** @import Entrypoint from "../Entrypoint" */
-/** @import Hash from "../util/Hash" */
-/** @import { ChunkHashContext } from "../Compilation" */
-
-/**
- * Returns } Object containing chunk entries and runtime chunk.
- * @param {Chunk} chunk The chunk to get information for
- * @param {ChunkGraph} chunkGraph The chunk graph containing the chunk
- * @returns {{ entries: [Module, Entrypoint | undefined][], runtimeChunk: Chunk | null }} Object containing chunk entries and runtime chunk
- */
-function getChunkInfo(chunk, chunkGraph) {
-	const entries = [
-		...chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
-	];
-	const runtimeChunk =
-		entries.length > 0
-			? /** @type {Entrypoint[][]} */
-				(entries)[0][1].getRuntimeChunk()
-			: null;
-
-	return {
-		entries,
-		runtimeChunk
-	};
-}
-
-/**
- * Creates a chunk hash handler
- * @param {string} name The name of the chunk
- * @returns {(chunk: Chunk, hash: Hash, { chunkGraph }: ChunkHashContext) => void} The chunk hash handler
- */
-function createChunkHashHandler(name) {
-	/**
-	 * Processes the provided chunk.
-	 * @param {Chunk} chunk The chunk to get information for
-	 * @param {Hash} hash The hash to update
-	 * @param {ChunkHashContext} chunkHashContext The chunk hash context
-	 * @returns {void}
-	 */
-	return (chunk, hash, { chunkGraph }) => {
-		if (chunk.hasRuntime()) return;
-		const { entries, runtimeChunk } = getChunkInfo(chunk, chunkGraph);
-		hash.update(name);
-		hash.update("1");
-		if (runtimeChunk && runtimeChunk.hash) {
-			// WHY: any change to the runtime chunk must move this hash, and its
-			// internal implementation is not ours to depend on or inspect — the import
-			// names its hashed filename:
-			// import __webpack_require__ from "./runtime-main.e9400aee33633a3973bd.js";
-			// https://github.com/webpack/webpack/issues/19439
-			hash.update(runtimeChunk.hash);
-		}
-		updateHashForEntryStartup(hash, chunkGraph, entries, chunk);
-	};
-}
-
-module.exports = {
-	createChunkHashHandler,
-	getChunkInfo
-};