@depup/webpack 5.110.1-depup.0 → 5.111.1-depup.0

package/lib/runtime/OnChunksLoadedRuntimeModule.js

@@ -7,12 +7,31 @@
 const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
+const { getOnlyHandlerKey } = require("../util/handlerKeys");
+const { propertyAccess } = require("../util/property");
 
 /** @import Compilation from "../Compilation" */
+/** @import { ReadOnlyRuntimeRequirements } from "../Module" */
 
 class OnChunksLoadedRuntimeModule extends RuntimeModule {
-	constructor() {
+	/**
+	 * @param {ReadOnlyRuntimeRequirements} runtimeRequirements runtime requirements
+	 */
+	constructor(runtimeRequirements) {
 		super("chunk loaded");
+		/** @type {ReadOnlyRuntimeRequirements} */
+		this.runtimeRequirements = runtimeRequirements;
+	}
+
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		// Reads a map rather than installing onto one, so reading its code back would
+		// render it in a cycle.
+		return RuntimeModule.NO_CHUNK_HANDLERS;
 	}
 
 	/**
@@ -22,24 +41,38 @@ class OnChunksLoadedRuntimeModule extends RuntimeModule {
 	generate() {
 		const compilation = /** @type {Compilation} */ (this.compilation);
 		const { runtimeTemplate } = compilation;
+		// Only a prefetch startup callback is queued behind a priority, so without one
+		// the queue keeps insertion order and nothing has to hold the lowest seen.
+		const withPriority = this.runtimeRequirements.has(
+			RuntimeGlobals.hasChunkPriority
+		);
+		const only = getOnlyHandlerKey(this, RuntimeGlobals.onChunksLoaded);
 		return Template.asString([
 			`${runtimeTemplate.renderConst()} deferred = [];`,
 			`${RuntimeGlobals.onChunksLoaded} = ${runtimeTemplate.basicFunction(
-				"result, chunkIds, fn, priority",
+				`result, chunkIds, fn${withPriority ? ", priority" : ""}`,
 				[
 					"if(chunkIds) {",
-					Template.indent([
-						`${runtimeTemplate.assignOr("priority", "0")};`,
-						"for(var i = deferred.length; i > 0 && deferred[i - 1][2] > priority; i--) deferred[i] = deferred[i - 1];",
-						"deferred[i] = [chunkIds, fn, priority];",
-						"return;"
-					]),
+					Template.indent(
+						withPriority
+							? [
+									`${runtimeTemplate.assignOr("priority", "0")};`,
+									"for(var i = deferred.length; i > 0 && deferred[i - 1][2] > priority; i--) deferred[i] = deferred[i - 1];",
+									"deferred[i] = [chunkIds, fn, priority];",
+									"return;"
+								]
+							: ["deferred.push([chunkIds, fn]);", "return;"]
+					),
 					"}",
-					`${runtimeTemplate.renderLet()} notFulfilled = Infinity;`,
+					...(withPriority
+						? [`${runtimeTemplate.renderLet()} notFulfilled = Infinity;`]
+						: []),
 					"for (var i = 0; i < deferred.length; i++) {",
 					Template.indent([
 						runtimeTemplate.destructureArray(
-							["chunkIds", "fn", "priority"],
+							withPriority
+								? ["chunkIds", "fn", "priority"]
+								: ["chunkIds", "fn"],
 							"deferred[i]"
 						),
 						`${runtimeTemplate.renderLet()} fulfilled = true;`,
@@ -47,18 +80,32 @@ class OnChunksLoadedRuntimeModule extends RuntimeModule {
 						Template.indent([
 							// Parenthesized: `&` binds looser than `===`, so `priority & 1 === 0`
 							// is `priority & false` and gates every priority, not just the odd ones.
-							`if (((priority & 1) === 0 || notFulfilled >= priority) && Object.keys(${
-								RuntimeGlobals.onChunksLoaded
-							}).every(${runtimeTemplate.returningFunction(
-								`${RuntimeGlobals.onChunksLoaded}[key](chunkIds[j])`,
-								"key"
-							)})) {`,
+							`if (${
+								withPriority
+									? "((priority & 1) === 0 || notFulfilled >= priority) && "
+									: ""
+							}${
+								only === null
+									? `Object.keys(${
+											RuntimeGlobals.onChunksLoaded
+										}).every(${runtimeTemplate.returningFunction(
+											`${RuntimeGlobals.onChunksLoaded}[key](chunkIds[j])`,
+											"key"
+										)})`
+									: `${RuntimeGlobals.onChunksLoaded}${propertyAccess([
+											only
+										])}(chunkIds[j])`
+							}) {`,
 							Template.indent(["chunkIds.splice(j--, 1);"]),
 							"} else {",
-							Template.indent([
-								"fulfilled = false;",
-								"if(priority < notFulfilled) notFulfilled = priority;"
-							]),
+							Template.indent(
+								withPriority
+									? [
+											"fulfilled = false;",
+											"if(priority < notFulfilled) notFulfilled = priority;"
+										]
+									: ["fulfilled = false;"]
+							),
 							"}"
 						]),
 						"}",

package/lib/runtime/PublicPathRuntimeModule.js

@@ -30,6 +30,15 @@ class PublicPathRuntimeModule extends RuntimeModule {
 		this.publicPath = publicPath;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/runtime/RuntimeIdRuntimeModule.js

@@ -25,6 +25,15 @@ class RuntimeIdRuntimeModule extends RuntimeModule {
 		return false;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/runtime/SpecNamespaceObjectRuntimeModule.js

@@ -0,0 +1,90 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const Template = require("../Template");
+const HelperRuntimeModule = require("./HelperRuntimeModule");
+
+/** @import Compilation from "../Compilation" */
+
+class SpecNamespaceObjectRuntimeModule extends HelperRuntimeModule {
+	constructor() {
+		super("spec namespace object");
+	}
+
+	/**
+	 * Generates runtime code for this runtime module.
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate } = compilation;
+		const cst = runtimeTemplate.renderConst();
+		const lt = runtimeTemplate.renderLet();
+		const fn = RuntimeGlobals.specNamespaceObject;
+		return Template.asString([
+			`${fn} = ${runtimeTemplate.basicFunction("exports, record, mode", [
+				// One namespace per module: a module's own exports object identifies it,
+				// while a synthesized one is fresh per site, so its record identifies it.
+				`${cst} owner = record || exports;`,
+				`${lt} slots = ${fn}.c.get(owner);`,
+				`if (!slots) ${fn}.c.set(owner, (slots = { __proto__: null }));`,
+				// A synthesized namespace carries different names per mode, so one
+				// module can owe its importers more than one namespace.
+				`${cst} cached = slots[mode];`,
+				"if (cached) return cached;",
+				// The exports object keeps the live bindings; the sealed target
+				// carries only their names, so the traps stay invariant-safe.
+				`${cst} names = Object.getOwnPropertyNames(exports).filter(${runtimeTemplate.returningFunction(
+					"name !== '__esModule'",
+					"name"
+				)}).sort();`,
+				`${cst} target = { __proto__: null };`,
+				"for (var i = 0; i < names.length; i++) Object.defineProperty(target, names[i], { value: undefined, writable: true, enumerable: true, configurable: false });",
+				"Object.defineProperty(target, Symbol.toStringTag, { value: 'Module' });",
+				"Object.preventExtensions(target);",
+				`${cst} own = ${runtimeTemplate.returningFunction(
+					"typeof name === 'string' && Object.prototype.hasOwnProperty.call(target, name)",
+					"name"
+				)};`,
+				`${cst} ns = new Proxy(target, {`,
+				Template.indent([
+					"__proto__: null,",
+					"getPrototypeOf: function() { return null; },",
+					"setPrototypeOf: function(_, proto) { return proto === null; },",
+					"isExtensible: function() { return false; },",
+					"preventExtensions: function() { return true; },",
+					"get: function(_, name, receiver) { return own(name) ? exports[name] : Reflect.get(target, name, receiver); },",
+					"has: function(_, name) { return own(name) || Reflect.has(target, name); },",
+					"ownKeys: function() { return Reflect.ownKeys(target); },",
+					"getOwnPropertyDescriptor: function(_, name) { return own(name) ? { value: exports[name], writable: true, enumerable: true, configurable: false } : Reflect.getOwnPropertyDescriptor(target, name); },",
+					"set: function() { return false; },",
+					// A namespace may only be redefined to the descriptor it
+					// already reports, so anything else is rejected.
+					"defineProperty: function(_, name, descriptor) {",
+					Template.indent([
+						// Symbol keys are ordinary, so redefining Symbol.toStringTag
+						// to the descriptor it already has must still succeed.
+						"if (typeof name === 'symbol') return Reflect.defineProperty(target, name, descriptor);",
+						"if (!own(name) || 'get' in descriptor || 'set' in descriptor) return false;",
+						"if (descriptor.configurable === true || descriptor.enumerable === false || descriptor.writable === false) return false;",
+						"return !('value' in descriptor) || Object.is(descriptor.value, exports[name]);"
+					]),
+					"},",
+					"deleteProperty: function(_, name) { return !own(name) && !Reflect.has(target, name); }"
+				]),
+				"});",
+				"slots[mode] = ns;",
+				"return ns;"
+			])};`,
+			// The same owner must always yield the same namespace.
+			`${fn}.c = new WeakMap();`
+		]);
+	}
+}
+
+module.exports = SpecNamespaceObjectRuntimeModule;

package/lib/runtime/StartupChunkDependenciesRuntimeModule.js

@@ -23,6 +23,15 @@ class StartupChunkDependenciesRuntimeModule extends RuntimeModule {
 		this.asyncChunkLoading = asyncChunkLoading;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/runtime/StartupEntrypointRuntimeModule.js

@@ -31,6 +31,15 @@ class StartupEntrypointRuntimeModule extends RuntimeModule {
 		this.asyncChunkLoading = asyncChunkLoading;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/runtime/SystemContextRuntimeModule.js

@@ -22,6 +22,15 @@ class SystemContextRuntimeModule extends RuntimeModule {
 		return false;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/runtime/ToBinaryRuntimeModule.js

@@ -16,6 +16,15 @@ class ToBinaryRuntimeModule extends RuntimeModule {
 		super("to binary");
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/schemes/DataUriPlugin.js

@@ -34,12 +34,9 @@ class DataUriPlugin {
 							);
 							resourceData.data.encodedContent = match[4] || "";
 						}
-						// Inherit the issuer's resolution context so any nested
-						// dependencies discovered while parsing the data URI's body
-						// (e.g. `url(...)` / `@import` inside an inline CSS data
-						// URI) resolve relative to where the URI was referenced
-						// from, instead of against the synthetic `data:.../` path
-						// that `getContext("data:…")` would otherwise infer.
+						// Inherit the issuer's resolution context, so a dependency found
+						// inside the data URI's body resolves against where the URI was
+						// referenced, not the synthetic `data:…` path.
 						if (
 							resourceData.context === undefined &&
 							resolveData.context !== undefined

package/lib/schemes/HttpUriPlugin.js

@@ -149,7 +149,8 @@ const verifyIntegrity = (content, integrity) => {
 };
 
 /**
- * Parses key value pairs.
+ * Parses key value pairs. Keys are lower-cased because HTTP directive names are
+ * case-insensitive; values are kept verbatim (they may be quoted field lists).
  * @param {string} str input
  * @returns {Record<string, string>} parsed
  */
@@ -159,11 +160,11 @@ const parseKeyValuePairs = (str) => {
 	for (const item of str.split(",")) {
 		const i = item.indexOf("=");
 		if (i >= 0) {
-			const key = item.slice(0, i).trim();
+			const key = item.slice(0, i).trim().toLowerCase();
 			const value = item.slice(i + 1).trim();
 			result[key] = value;
 		} else {
-			const key = item.trim();
+			const key = item.trim().toLowerCase();
 			if (!key) continue;
 			result[key] = key;
 		}
@@ -186,7 +187,9 @@ const parseCacheControl = (cacheControl, requestTime) => {
 	let validUntil = 0;
 	if (cacheControl) {
 		const parsed = parseKeyValuePairs(cacheControl);
-		if (parsed["no-cache"]) storeCache = storeLock = false;
+		if (parsed["no-cache"] || parsed["no-store"]) {
+			storeCache = storeLock = false;
+		}
 		if (parsed["max-age"] && !Number.isNaN(Number(parsed["max-age"]))) {
 			validUntil = requestTime + Number(parsed["max-age"]) * 1000;
 		}
@@ -984,7 +987,11 @@ class HttpUriPlugin {
 							/** @type {Buffer[]} */
 							const bufferArr = [];
 
-							const contentEncoding = res.headers["content-encoding"];
+							// content codings are case-insensitive tokens
+							const contentEncodingHeader = res.headers["content-encoding"];
+							const contentEncoding =
+								contentEncodingHeader &&
+								contentEncodingHeader.trim().toLowerCase();
 							/** @type {Readable} */
 							let stream = res;
 							if (contentEncoding === "gzip") {
@@ -994,6 +1001,16 @@ class HttpUriPlugin {
 							} else if (contentEncoding === "deflate") {
 								stream = stream.pipe(createInflate());
 							}
+							if (stream !== res) {
+								// a decompressor error never reaches the request's handler
+								stream.once("error", (err) => {
+									logger.log(
+										`GET ${url} [${res.statusCode}] (invalid encoding)`
+									);
+									err.message += `\nwhile decompressing ${url}`;
+									callback(err);
+								});
+							}
 
 							stream.on(
 								"data",

package/lib/schemes/VirtualUrlPlugin.js

@@ -36,7 +36,7 @@ const PLUGIN_NAME = "VirtualUrlPlugin";
 /**
  * Defines the loader context type used by this module.
  * @template T
- * @typedef {import("../../declarations/LoaderContext").LoaderContext<T>} LoaderContext
+ * @typedef {import("../NormalModule").LoaderContext<T>} LoaderContext
  */
 
 /**

package/lib/serialization/BinaryMiddleware.js

@@ -2,15 +2,6 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 */
 
-"use strict";
-
-const { deserialize: v8Deserialize, serialize: v8Serialize } = require("v8");
-const memoize = require("../util/memoize");
-const SerializerMiddleware = require("./SerializerMiddleware");
-
-/** @typedef {import("./types").PrimitiveSerializableType} PrimitiveSerializableType */
-/** @import { BufferSerializableType } from "./types" */
-
 /*
 Format:
 
@@ -28,6 +19,15 @@ ValuesHeaderByte -> 0xf1
 LazyHeaderByte -> 0xf2
 */
 
+"use strict";
+
+const { deserialize: v8Deserialize, serialize: v8Serialize } = require("v8");
+const memoize = require("../util/memoize");
+const SerializerMiddleware = require("./SerializerMiddleware");
+
+/** @typedef {import("./types").PrimitiveSerializableType} PrimitiveSerializableType */
+/** @import { BufferSerializableType } from "./types" */
+
 const VALUES_HEADER = 0xf1;
 const LAZY_HEADER = 0xf2;
 

package/lib/serialization/FileMiddleware.js

@@ -2,6 +2,22 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 */
 
+/*
+Format:
+
+File -> Header Section*
+
+Version -> u32
+AmountOfSections -> u32
+SectionSize -> i32 (if less than zero represents lazy value)
+
+Header -> Version AmountOfSections SectionSize*
+
+Buffer -> n bytes
+Section -> Buffer
+
+*/
+
 "use strict";
 
 const { constants } = require("buffer");
@@ -35,22 +51,6 @@ const SerializerMiddleware = require("./SerializerMiddleware");
 /** @import { IStats, IntermediateFileSystem } from "../util/fs" */
 /** @import { BufferSerializableType } from "./types" */
 
-/*
-Format:
-
-File -> Header Section*
-
-Version -> u32
-AmountOfSections -> u32
-SectionSize -> i32 (if less than zero represents lazy value)
-
-Header -> Version AmountOfSections SectionSize*
-
-Buffer -> n bytes
-Section -> Buffer
-
-*/
-
 // "wpc" + 1 in little-endian
 const VERSION = 0x01637077;
 const WRITE_LIMIT_TOTAL = 0x7fff0000;
@@ -549,9 +549,13 @@ class FileMiddleware extends SerializerMiddleware {
 								});
 							}
 							if (compression) {
-								pipeline(compression, stream, reject);
+								// resolve on the pipeline, not on the transform's "finish":
+								// the latter fires before the destination has flushed
+								pipeline(compression, stream, (err) => {
+									if (err) return reject(err);
+									resolve();
+								});
 								stream = compression;
-								stream.on("finish", () => resolve());
 							} else {
 								stream.on("error", (err) => reject(err));
 								stream.on("finish", () => resolve());
@@ -793,6 +797,15 @@ class FileMiddleware extends SerializerMiddleware {
 										});
 										return;
 									}
+									// a file truncated after `stat` reads 0 bytes forever
+									if (bytesRead === 0 && remaining > 0) {
+										this.fs.close(fd, (err) => {
+											reject(
+												err || new Error(`Unexpected end of file ${file}`)
+											);
+										});
+										return;
+									}
 									/** @type {number} */
 									(currentBufferUsed) += bytesRead;
 									remaining -= bytesRead;