webpack 5.76.1 → 5.88.0

package/lib/wasm-sync/WebAssemblyModulesPlugin.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const Generator = require("../Generator");
+const { WEBASSEMBLY_MODULE_TYPE_SYNC } = require("../ModuleTypeConstants");
 const WebAssemblyExportImportedDependency = require("../dependencies/WebAssemblyExportImportedDependency");
 const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
 const { compareModulesByIdentifier } = require("../util/comparators");
@@ -13,6 +14,7 @@ const memoize = require("../util/memoize");
 const WebAssemblyInInitialChunkError = require("./WebAssemblyInInitialChunkError");
 
 /** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} OutputOptions */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../ModuleTemplate")} ModuleTemplate */
@@ -26,7 +28,17 @@ const getWebAssemblyJavascriptGenerator = memoize(() =>
 );
 const getWebAssemblyParser = memoize(() => require("./WebAssemblyParser"));
 
+const PLUGIN_NAME = "WebAssemblyModulesPlugin";
+
+/**
+ * @typedef {Object} WebAssemblyModulesPluginOptions
+ * @property {boolean} [mangleImports] mangle imports
+ */
+
 class WebAssemblyModulesPlugin {
+	/**
+	 * @param {WebAssemblyModulesPluginOptions} options options
+	 */
 	constructor(options) {
 		this.options = options;
 	}
@@ -38,7 +50,7 @@ class WebAssemblyModulesPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"WebAssemblyModulesPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				compilation.dependencyFactories.set(
 					WebAssemblyImportDependency,
@@ -51,16 +63,16 @@ class WebAssemblyModulesPlugin {
 				);
 
 				normalModuleFactory.hooks.createParser
-					.for("webassembly/sync")
-					.tap("WebAssemblyModulesPlugin", () => {
+					.for(WEBASSEMBLY_MODULE_TYPE_SYNC)
+					.tap(PLUGIN_NAME, () => {
 						const WebAssemblyParser = getWebAssemblyParser();
 
 						return new WebAssemblyParser();
 					});
 
 				normalModuleFactory.hooks.createGenerator
-					.for("webassembly/sync")
-					.tap("WebAssemblyModulesPlugin", () => {
+					.for(WEBASSEMBLY_MODULE_TYPE_SYNC)
+					.tap(PLUGIN_NAME, () => {
 						const WebAssemblyJavascriptGenerator =
 							getWebAssemblyJavascriptGenerator();
 						const WebAssemblyGenerator = getWebAssemblyGenerator();
@@ -71,53 +83,51 @@ class WebAssemblyModulesPlugin {
 						});
 					});
 
-				compilation.hooks.renderManifest.tap(
-					"WebAssemblyModulesPlugin",
-					(result, options) => {
-						const { chunkGraph } = compilation;
-						const { chunk, outputOptions, codeGenerationResults } = options;
-
-						for (const module of chunkGraph.getOrderedChunkModulesIterable(
-							chunk,
-							compareModulesByIdentifier
-						)) {
-							if (module.type === "webassembly/sync") {
-								const filenameTemplate =
-									outputOptions.webassemblyModuleFilename;
-
-								result.push({
-									render: () =>
-										codeGenerationResults.getSource(
-											module,
-											chunk.runtime,
-											"webassembly"
-										),
-									filenameTemplate,
-									pathOptions: {
+				compilation.hooks.renderManifest.tap(PLUGIN_NAME, (result, options) => {
+					const { chunkGraph } = compilation;
+					const { chunk, outputOptions, codeGenerationResults } = options;
+
+					for (const module of chunkGraph.getOrderedChunkModulesIterable(
+						chunk,
+						compareModulesByIdentifier
+					)) {
+						if (module.type === WEBASSEMBLY_MODULE_TYPE_SYNC) {
+							const filenameTemplate =
+								/** @type {NonNullable<OutputOptions["webassemblyModuleFilename"]>} */
+								(outputOptions.webassemblyModuleFilename);
+
+							result.push({
+								render: () =>
+									codeGenerationResults.getSource(
 										module,
-										runtime: chunk.runtime,
-										chunkGraph
-									},
-									auxiliary: true,
-									identifier: `webassemblyModule${chunkGraph.getModuleId(
-										module
-									)}`,
-									hash: chunkGraph.getModuleHash(module, chunk.runtime)
-								});
-							}
+										chunk.runtime,
+										"webassembly"
+									),
+								filenameTemplate,
+								pathOptions: {
+									module,
+									runtime: chunk.runtime,
+									chunkGraph
+								},
+								auxiliary: true,
+								identifier: `webassemblyModule${chunkGraph.getModuleId(
+									module
+								)}`,
+								hash: chunkGraph.getModuleHash(module, chunk.runtime)
+							});
 						}
-
-						return result;
 					}
-				);
 
-				compilation.hooks.afterChunks.tap("WebAssemblyModulesPlugin", () => {
+					return result;
+				});
+
+				compilation.hooks.afterChunks.tap(PLUGIN_NAME, () => {
 					const chunkGraph = compilation.chunkGraph;
 					const initialWasmModules = new Set();
 					for (const chunk of compilation.chunks) {
 						if (chunk.canBeInitial()) {
 							for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
-								if (module.type === "webassembly/sync") {
+								if (module.type === WEBASSEMBLY_MODULE_TYPE_SYNC) {
 									initialWasmModules.add(module);
 								}
 							}

package/lib/wasm-sync/WebAssemblyParser.js

@@ -14,6 +14,8 @@ const WebAssemblyExportImportedDependency = require("../dependencies/WebAssembly
 const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
 
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../Parser").ParserState} ParserState */
 /** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
 
@@ -61,6 +63,9 @@ const decoderOpts = {
 };
 
 class WebAssemblyParser extends Parser {
+	/**
+	 * @param {{}=} options parser options
+	 */
 	constructor(options) {
 		super();
 		this.hooks = Object.freeze({});
@@ -78,8 +83,10 @@ class WebAssemblyParser extends Parser {
 		}
 
 		// flag it as ESM
-		state.module.buildInfo.strict = true;
-		state.module.buildMeta.exportsType = "namespace";
+		/** @type {BuildInfo} */
+		(state.module.buildInfo).strict = true;
+		/** @type {BuildMeta} */
+		(state.module.buildMeta).exportsType = "namespace";
 
 		// parse it
 		const program = decode(source, decoderOpts);
@@ -88,10 +95,12 @@ class WebAssemblyParser extends Parser {
 		const moduleContext = moduleContextFromModuleAST(module);
 
 		// extract imports and exports
+		/** @type {string[]} */
 		const exports = [];
 		let jsIncompatibleExports = (state.module.buildMeta.jsIncompatibleExports =
 			undefined);
 
+		/** @type {TODO[]} */
 		const importedGlobals = [];
 		t.traverse(module, {
 			ModuleExport({ node }) {
@@ -157,12 +166,14 @@ class WebAssemblyParser extends Parser {
 				} else if (t.isTable(node.descr) === true) {
 					onlyDirectImport = "Table";
 				} else if (t.isFuncImportDescr(node.descr) === true) {
-					const incompatibleType = getJsIncompatibleType(node.descr.signature);
+					const incompatibleType = getJsIncompatibleType(
+						/** @type {t.Signature} */ (node.descr.signature)
+					);
 					if (incompatibleType) {
 						onlyDirectImport = `Non-JS-compatible Func Signature (${incompatibleType})`;
 					}
 				} else if (t.isGlobalType(node.descr) === true) {
-					const type = node.descr.valtype;
+					const type = /** @type {string} */ (node.descr.valtype);
 					if (!JS_COMPAT_TYPES.has(type)) {
 						onlyDirectImport = `Non-JS-compatible Global Type (${type})`;
 					}

package/lib/wasm-sync/WebAssemblyUtils.js

@@ -22,7 +22,7 @@ const MANGLED_MODULE = "a";
 /**
  * @param {ModuleGraph} moduleGraph the module graph
  * @param {Module} module the module
- * @param {boolean} mangle mangle module and export names
+ * @param {boolean | undefined} mangle mangle module and export names
  * @returns {UsedWasmDependency[]} used dependencies and (mangled) name
  */
 const getUsedDependencies = (moduleGraph, module, mangle) => {

package/lib/web/FetchCompileAsyncWasmPlugin.js

@@ -5,9 +5,11 @@
 
 "use strict";
 
+const { WEBASSEMBLY_MODULE_TYPE_ASYNC } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const AsyncWasmLoadingRuntimeModule = require("../wasm-async/AsyncWasmLoadingRuntimeModule");
 
+/** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
 
 class FetchCompileAsyncWasmPlugin {
@@ -21,6 +23,10 @@ class FetchCompileAsyncWasmPlugin {
 			"FetchCompileAsyncWasmPlugin",
 			compilation => {
 				const globalWasmLoading = compilation.outputOptions.wasmLoading;
+				/**
+				 * @param {Chunk} chunk chunk
+				 * @returns {boolean} true, if wasm loading is enabled for the chunk
+				 */
 				const isEnabledForChunk = chunk => {
 					const options = chunk.getEntryOptions();
 					const wasmLoading =
@@ -29,6 +35,10 @@ class FetchCompileAsyncWasmPlugin {
 							: globalWasmLoading;
 					return wasmLoading === "fetch";
 				};
+				/**
+				 * @param {string} path path to the wasm file
+				 * @returns {string} code to load the wasm file
+				 */
 				const generateLoadBinaryCode = path =>
 					`fetch(${RuntimeGlobals.publicPath} + ${path})`;
 
@@ -40,7 +50,7 @@ class FetchCompileAsyncWasmPlugin {
 						if (
 							!chunkGraph.hasModuleInGraph(
 								chunk,
-								m => m.type === "webassembly/async"
+								m => m.type === WEBASSEMBLY_MODULE_TYPE_ASYNC
 							)
 						) {
 							return;

package/lib/web/FetchCompileWasmPlugin.js

@@ -5,16 +5,28 @@
 
 "use strict";
 
+const { WEBASSEMBLY_MODULE_TYPE_SYNC } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const WasmChunkLoadingRuntimeModule = require("../wasm-sync/WasmChunkLoadingRuntimeModule");
 
+/** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
 
 // TODO webpack 6 remove
 
+const PLUGIN_NAME = "FetchCompileWasmPlugin";
+
+/**
+ * @typedef {Object} FetchCompileWasmPluginOptions
+ * @property {boolean} [mangleImports] mangle imports
+ */
+
 class FetchCompileWasmPlugin {
-	constructor(options) {
-		this.options = options || {};
+	/**
+	 * @param {FetchCompileWasmPluginOptions} [options] options
+	 */
+	constructor(options = {}) {
+		this.options = options;
 	}
 
 	/**
@@ -23,48 +35,53 @@ class FetchCompileWasmPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(
-			"FetchCompileWasmPlugin",
-			compilation => {
-				const globalWasmLoading = compilation.outputOptions.wasmLoading;
-				const isEnabledForChunk = chunk => {
-					const options = chunk.getEntryOptions();
-					const wasmLoading =
-						options && options.wasmLoading !== undefined
-							? options.wasmLoading
-							: globalWasmLoading;
-					return wasmLoading === "fetch";
-				};
-				const generateLoadBinaryCode = path =>
-					`fetch(${RuntimeGlobals.publicPath} + ${path})`;
+		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, compilation => {
+			const globalWasmLoading = compilation.outputOptions.wasmLoading;
+			/**
+			 * @param {Chunk} chunk chunk
+			 * @returns {boolean} true, if wasm loading is enabled for the chunk
+			 */
+			const isEnabledForChunk = chunk => {
+				const options = chunk.getEntryOptions();
+				const wasmLoading =
+					options && options.wasmLoading !== undefined
+						? options.wasmLoading
+						: globalWasmLoading;
+				return wasmLoading === "fetch";
+			};
+			/**
+			 * @param {string} path path to the wasm file
+			 * @returns {string} code to load the wasm file
+			 */
+			const generateLoadBinaryCode = path =>
+				`fetch(${RuntimeGlobals.publicPath} + ${path})`;
 
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.ensureChunkHandlers)
-					.tap("FetchCompileWasmPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						const chunkGraph = compilation.chunkGraph;
-						if (
-							!chunkGraph.hasModuleInGraph(
-								chunk,
-								m => m.type === "webassembly/sync"
-							)
-						) {
-							return;
-						}
-						set.add(RuntimeGlobals.moduleCache);
-						set.add(RuntimeGlobals.publicPath);
-						compilation.addRuntimeModule(
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.ensureChunkHandlers)
+				.tap(PLUGIN_NAME, (chunk, set) => {
+					if (!isEnabledForChunk(chunk)) return;
+					const chunkGraph = compilation.chunkGraph;
+					if (
+						!chunkGraph.hasModuleInGraph(
 							chunk,
-							new WasmChunkLoadingRuntimeModule({
-								generateLoadBinaryCode,
-								supportsStreaming: true,
-								mangleImports: this.options.mangleImports,
-								runtimeRequirements: set
-							})
-						);
-					});
-			}
-		);
+							m => m.type === WEBASSEMBLY_MODULE_TYPE_SYNC
+						)
+					) {
+						return;
+					}
+					set.add(RuntimeGlobals.moduleCache);
+					set.add(RuntimeGlobals.publicPath);
+					compilation.addRuntimeModule(
+						chunk,
+						new WasmChunkLoadingRuntimeModule({
+							generateLoadBinaryCode,
+							supportsStreaming: true,
+							mangleImports: this.options.mangleImports,
+							runtimeRequirements: set
+						})
+					);
+				});
+		});
 	}
 }
 

package/lib/web/JsonpChunkLoadingPlugin.js

@@ -8,6 +8,7 @@
 const RuntimeGlobals = require("../RuntimeGlobals");
 const JsonpChunkLoadingRuntimeModule = require("./JsonpChunkLoadingRuntimeModule");
 
+/** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
 
 class JsonpChunkLoadingPlugin {
@@ -21,6 +22,10 @@ class JsonpChunkLoadingPlugin {
 			"JsonpChunkLoadingPlugin",
 			compilation => {
 				const globalChunkLoading = compilation.outputOptions.chunkLoading;
+				/**
+				 * @param {Chunk} chunk chunk
+				 * @returns {boolean} true, if wasm loading is enabled for the chunk
+				 */
 				const isEnabledForChunk = chunk => {
 					const options = chunk.getEntryOptions();
 					const chunkLoading =
@@ -30,6 +35,10 @@ class JsonpChunkLoadingPlugin {
 					return chunkLoading === "jsonp";
 				};
 				const onceForChunkSet = new WeakSet();
+				/**
+				 * @param {Chunk} chunk chunk
+				 * @param {Set<string>} set runtime requirements
+				 */
 				const handler = (chunk, set) => {
 					if (onceForChunkSet.has(chunk)) return;
 					onceForChunkSet.add(chunk);

package/lib/web/JsonpChunkLoadingRuntimeModule.js

@@ -14,6 +14,7 @@ const { getInitialChunkIds } = require("../javascript/StartupHelpers");
 const compileBooleanMatcher = require("../util/compileBooleanMatcher");
 
 /** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
 
 /**
  * @typedef {Object} JsonpCompilationPluginHooks
@@ -46,6 +47,9 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 		return hooks;
 	}
 
+	/**
+	 * @param {Set<string>} runtimeRequirements runtime requirements
+	 */
 	constructor(runtimeRequirements) {
 		super("jsonp chunk loading", RuntimeModule.STAGE_ATTACH);
 		this._runtimeRequirements = runtimeRequirements;
@@ -66,10 +70,10 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { chunkGraph, compilation, chunk } = this;
+		const compilation = /** @type {Compilation} */ (this.compilation);
 		const {
 			runtimeTemplate,
 			outputOptions: {
@@ -105,9 +109,14 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 		const withPreload = this._runtimeRequirements.has(
 			RuntimeGlobals.preloadChunkHandlers
 		);
+		const withFetchPriority = this._runtimeRequirements.has(
+			RuntimeGlobals.hasFetchPriority
+		);
 		const chunkLoadingGlobalExpr = `${globalObject}[${JSON.stringify(
 			chunkLoadingGlobal
 		)}]`;
+		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
+		const chunk = /** @type {Chunk} */ (this.chunk);
 		const conditionMap = chunkGraph.getChunkConditionMap(chunk, chunkHasJs);
 		const hasJsMatcher = compileBooleanMatcher(conditionMap);
 		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
@@ -135,7 +144,7 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 			withLoading
 				? Template.asString([
 						`${fn}.j = ${runtimeTemplate.basicFunction(
-							"chunkId, promises",
+							`chunkId, promises${withFetchPriority ? ", fetchPriority" : ""}`,
 							hasJsMatcher !== false
 								? Template.indent([
 										"// JSONP chunk loading for javascript",
@@ -187,9 +196,15 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 															"}"
 														]
 													)};`,
-													`${RuntimeGlobals.loadScript}(url, loadingEnded, "chunk-" + chunkId, chunkId);`
+													`${
+														RuntimeGlobals.loadScript
+													}(url, loadingEnded, "chunk-" + chunkId, chunkId${
+														withFetchPriority ? ", fetchPriority" : ""
+													});`
 												]),
-												"} else installedChunks[chunkId] = 0;"
+												hasJsMatcher === true
+													? "}"
+													: "} else installedChunks[chunkId] = 0;"
 											]),
 											"}"
 										]),
@@ -250,7 +265,7 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 							linkPreload.call(
 								Template.asString([
 									"var link = document.createElement('link');",
-									scriptType
+									scriptType && scriptType !== "module"
 										? `link.type = ${JSON.stringify(scriptType)};`
 										: "",
 									"link.charset = 'utf-8';",
@@ -259,8 +274,10 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 										`link.setAttribute("nonce", ${RuntimeGlobals.scriptNonce});`
 									),
 									"}",
-									'link.rel = "preload";',
-									'link.as = "script";',
+									scriptType === "module"
+										? 'link.rel = "modulepreload";'
+										: 'link.rel = "preload";',
+									scriptType === "module" ? "" : 'link.as = "script";',
 									`link.href = ${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(chunkId);`,
 									crossOriginLoading
 										? crossOriginLoading === "use-credentials"
@@ -422,7 +439,7 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 										"}"
 									]),
 									"}",
-									"if(runtime) var result = runtime(__webpack_require__);"
+									`if(runtime) var result = runtime(${RuntimeGlobals.require});`
 								]),
 								"}",
 								"if(parentChunkLoadingFunction) parentChunkLoadingFunction(data);",

package/lib/webpack.js

@@ -61,7 +61,10 @@ const createMultiCompiler = (childOptions, options) => {
 const createCompiler = rawOptions => {
 	const options = getNormalizedWebpackOptions(rawOptions);
 	applyWebpackOptionsBaseDefaults(options);
-	const compiler = new Compiler(options.context, options);
+	const compiler = new Compiler(
+		/** @type {string} */ (options.context),
+		options
+	);
 	new NodeEnvironmentPlugin({
 		infrastructureLogging: options.infrastructureLogging
 	}).apply(compiler);
@@ -69,7 +72,7 @@ const createCompiler = rawOptions => {
 		for (const plugin of options.plugins) {
 			if (typeof plugin === "function") {
 				plugin.call(compiler, compiler);
-			} else {
+			} else if (plugin) {
 				plugin.apply(compiler);
 			}
 		}
@@ -96,6 +99,11 @@ const createCompiler = rawOptions => {
  * @returns {MultiCompiler} the multi compiler object
  */
 
+/**
+ * @template T
+ * @param {Array<T> | T} options options
+ * @returns {Array<T>} array of options
+ */
 const asArray = options =>
 	Array.isArray(options) ? Array.from(options) : [options];
 
@@ -103,7 +111,7 @@ const webpack = /** @type {WebpackFunctionSingle & WebpackFunctionMulti} */ (
 	/**
 	 * @param {WebpackOptions | (ReadonlyArray<WebpackOptions> & MultiCompilerOptions)} options options
 	 * @param {Callback<Stats> & Callback<MultiStats>=} callback callback
-	 * @returns {Compiler | MultiCompiler}
+	 * @returns {Compiler | MultiCompiler} Compiler or MultiCompiler
 	 */
 	(options, callback) => {
 		const create = () => {
@@ -117,6 +125,7 @@ const webpack = /** @type {WebpackFunctionSingle & WebpackFunctionMulti} */ (
 			}
 			/** @type {MultiCompiler|Compiler} */
 			let compiler;
+			/** @type {boolean | undefined} */
 			let watch = false;
 			/** @type {WatchOptions|WatchOptions[]} */
 			let watchOptions;

package/lib/webworker/ImportScriptsChunkLoadingPlugin.js

@@ -9,6 +9,7 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const StartupChunkDependenciesPlugin = require("../runtime/StartupChunkDependenciesPlugin");
 const ImportScriptsChunkLoadingRuntimeModule = require("./ImportScriptsChunkLoadingRuntimeModule");
 
+/** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
 
 class ImportScriptsChunkLoadingPlugin {
@@ -26,6 +27,10 @@ class ImportScriptsChunkLoadingPlugin {
 			"ImportScriptsChunkLoadingPlugin",
 			compilation => {
 				const globalChunkLoading = compilation.outputOptions.chunkLoading;
+				/**
+				 * @param {Chunk} chunk chunk
+				 * @returns {boolean} true, if wasm loading is enabled for the chunk
+				 */
 				const isEnabledForChunk = chunk => {
 					const options = chunk.getEntryOptions();
 					const chunkLoading =
@@ -35,6 +40,10 @@ class ImportScriptsChunkLoadingPlugin {
 					return chunkLoading === "import-scripts";
 				};
 				const onceForChunkSet = new WeakSet();
+				/**
+				 * @param {Chunk} chunk chunk
+				 * @param {Set<string>} set runtime requirements
+				 */
 				const handler = (chunk, set) => {
 					if (onceForChunkSet.has(chunk)) return;
 					onceForChunkSet.add(chunk);