webpack 5.111.0 → 5.112.0

package/lib/serialization/AggregateErrorSerializer.js

@@ -8,7 +8,7 @@
 /** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext<ComplexSerializableType[]>} ObjectDeserializerContext */
 /** @typedef {import("./ObjectMiddleware").ObjectSerializerContext<ComplexSerializableType[]>} ObjectSerializerContext */
 
-/** @typedef {Error & { cause?: unknown, errors: EXPECTED_ANY[] }} AggregateError */
+/** @typedef {Error & { cause?: unknown, errors: ComplexSerializableType[] }} AggregateError */
 
 class AggregateErrorSerializer {
 	/**
@@ -29,7 +29,7 @@ class AggregateErrorSerializer {
 	 * @returns {AggregateError} error
 	 */
 	deserialize(context) {
-		const errors = /** @type {EXPECTED_ANY[]} */ (context.read());
+		const errors = /** @type {ComplexSerializableType[]} */ (context.read());
 		// eslint-disable-next-line n/no-unsupported-features/es-builtins, n/no-unsupported-features/es-syntax, unicorn/error-message
 		const err = new AggregateError(errors);
 

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");
@@ -26,31 +42,15 @@ const {
 	zstdDecompress
 } = require("zlib");
 const { DEFAULTS } = require("../config/defaults");
+const { dirname, join, mkdirp } = require("../fs/fs");
 const createHash = require("../util/createHash");
-const { dirname, join, mkdirp } = require("../util/fs");
 const memoize = require("../util/memoize");
 const SerializerMiddleware = require("./SerializerMiddleware");
 
 /** @import { HashFunction } from "../util/Hash" */
-/** @import { IStats, IntermediateFileSystem } from "../util/fs" */
+/** @import { IStats, IntermediateFileSystem } from "../fs/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;
@@ -1013,7 +1013,7 @@ const getReferencedFilenamesUncompressed = (fs, file) =>
 					// otherwise pointer reads land on wrong bytes and under-report
 					fs.stat(file, (err, stats) => {
 						if (err) return fail(err);
-						const stat = /** @type {import("../util/fs").IStats} */ (stats);
+						const stat = /** @type {import("../fs/fs").IStats} */ (stats);
 						if (stat.size !== position) {
 							return fail(
 								new Error(`Section table does not match size of ${file}`)

package/lib/serialization/ObjectMiddleware.js

@@ -2,6 +2,28 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 */
 
+/*
+
+Format:
+
+File -> Section*
+Section -> ObjectSection | ReferenceSection | EscapeSection | OtherSection
+
+ObjectSection -> ESCAPE (
+	number:relativeOffset (number > 0) |
+	string:request (string|null):export
+) Section:value* ESCAPE ESCAPE_END_OBJECT
+ReferenceSection -> ESCAPE number:relativeOffset (number < 0)
+EscapeSection -> ESCAPE ESCAPE_ESCAPE_VALUE (escaped value ESCAPE)
+EscapeSection -> ESCAPE ESCAPE_UNDEFINED (escaped value ESCAPE)
+OtherSection -> any (except ESCAPE)
+
+Why using null as escape value?
+Multiple null values can merged by the BinaryMiddleware, which makes it very efficient
+Technically any value can be used.
+
+*/
+
 "use strict";
 
 const { DEFAULTS } = require("../config/defaults");
@@ -19,7 +41,7 @@ const SetObjectSerializer = require("./SetObjectSerializer");
 
 /** @import { Logger } from "../logging/Logger" */
 /** @import { HashFunction } from "../util/Hash" */
-/** @import { LazyOptions } from "./SerializerMiddleware" */
+/** @import { LazyOptions, LazyTarget } from "./SerializerMiddleware" */
 /**
  * @import {
  * 	ComplexSerializableType,
@@ -29,28 +51,6 @@ const SetObjectSerializer = require("./SetObjectSerializer");
 
 /** @typedef {new (...params: EXPECTED_ANY[]) => EXPECTED_ANY} Constructor */
 
-/*
-
-Format:
-
-File -> Section*
-Section -> ObjectSection | ReferenceSection | EscapeSection | OtherSection
-
-ObjectSection -> ESCAPE (
-	number:relativeOffset (number > 0) |
-	string:request (string|null):export
-) Section:value* ESCAPE ESCAPE_END_OBJECT
-ReferenceSection -> ESCAPE number:relativeOffset (number < 0)
-EscapeSection -> ESCAPE ESCAPE_ESCAPE_VALUE (escaped value ESCAPE)
-EscapeSection -> ESCAPE ESCAPE_UNDEFINED (escaped value ESCAPE)
-OtherSection -> any (except ESCAPE)
-
-Why using null as escape value?
-Multiple null values can merged by the BinaryMiddleware, which makes it very efficient
-Technically any value can be used.
-
-*/
-
 /**
  * Defines the object serializer snapshot type used by this module.
  * @typedef {object} ObjectSerializerSnapshot
@@ -67,13 +67,13 @@ Technically any value can be used.
 /**
  * First tuple element; element type for an open array; `EXPECTED_ANY` once exhausted.
  * @template {readonly EXPECTED_ANY[]} T
- * @typedef {T extends readonly [infer H, ...EXPECTED_ANY[]] ? H : T extends readonly [] ? EXPECTED_ANY : T extends readonly (infer E)[] ? E : never} Head
+ * @typedef {T extends readonly [infer H, ...infer _Rest] ? H : T extends readonly [] ? EXPECTED_ANY : T extends readonly (infer E)[] ? E : never} Head
  */
 
 /**
  * Tuple without its first element; unchanged when `T` is an open array.
  * @template {readonly EXPECTED_ANY[]} T
- * @typedef {T extends readonly [EXPECTED_ANY, ...infer R] ? R : T} Tail
+ * @typedef {T extends readonly [infer _First, ...infer R] ? R : T} Tail
  */
 
 /**
@@ -85,8 +85,8 @@ Technically any value can be used.
  * @property {(value: ReferenceableItem) => void} setCircularReference
  * @property {() => ObjectSerializerSnapshot} snapshot
  * @property {(snapshot: ObjectSerializerSnapshot) => void} rollback
- * @property {((item: EXPECTED_ANY | (() => EXPECTED_ANY)) => void)=} writeLazy
- * @property {((item: (EXPECTED_ANY | (() => EXPECTED_ANY)), obj: LazyOptions | undefined) => import("./SerializerMiddleware").LazyFunction<EXPECTED_ANY, EXPECTED_ANY, EXPECTED_ANY, LazyOptions>)=} writeSeparate
+ * @property {((item: ComplexSerializableType) => void)=} writeLazy
+ * @property {((item: ComplexSerializableType, obj: LazyOptions | undefined) => import("./SerializerMiddleware").LazyFunction<EXPECTED_ANY, EXPECTED_ANY, LazyTarget, LazyOptions>)=} writeSeparate
  */
 
 /**
@@ -183,9 +183,8 @@ if (typeof AggregateError !== "undefined") {
 	);
 }
 
-// If in a sandboxed environment (e.g. jest), this escapes the sandbox and registers
-// real Object and Array types to. These types may occur in the wild too, e.g. when
-// using Structured Clone in postMessage.
+// In a sandboxed environment such as jest, this escapes the sandbox to register
+// the real Object and Array too, which reach us through a structured clone.
 // eslint-disable-next-line n/exports-style
 if (exports.constructor !== Object) {
 	// eslint-disable-next-line n/exports-style
@@ -224,7 +223,7 @@ const loaders = new Map();
 /** @typedef {PrimitiveSerializableType[]} SerializedType */
 /** @typedef {{ logger: Logger }} Context */
 
-/** @typedef {(context: ObjectSerializerContext<EXPECTED_ANY> | ObjectDeserializerContext<EXPECTED_ANY>) => void} ExtendContext */
+/** @typedef {(context: ObjectSerializerContext<ComplexSerializableType[]> | ObjectDeserializerContext<ComplexSerializableType[]>) => void} ExtendContext */
 
 /**
  * Represents ObjectMiddleware.
@@ -286,6 +285,37 @@ class ObjectMiddleware extends SerializerMiddleware {
 		serializerInversed.set(key, serializer);
 	}
 
+	/**
+	 * Accepts a historical request/name as an extra deserialization key for an
+	 * already registered constructor, so caches written before a move restore.
+	 * @param {Constructor} Constructor the constructor, already registered
+	 * @param {string} request the historical request
+	 * @param {(string | null)=} name the historical name
+	 * @returns {void}
+	 */
+	static registerLegacyRequest(Constructor, request, name = null) {
+		const config = serializers.get(Constructor);
+
+		if (config === undefined || config === NOT_SERIALIZABLE) {
+			throw new Error(
+				`ObjectMiddleware.registerLegacyRequest: serializer for ${Constructor.name} is not registered`
+			);
+		}
+
+		const key = `${request}/${name}`;
+
+		if (serializerInversed.has(key)) {
+			throw new Error(
+				`ObjectMiddleware.registerLegacyRequest: serializer for ${key} is already registered`
+			);
+		}
+
+		serializerInversed.set(
+			key,
+			/** @type {SerializerConfigWithSerializer} */ (config).serializer
+		);
+	}
+
 	/**
 	 * Register not serializable.
 	 * @param {Constructor} Constructor the constructor
@@ -303,7 +333,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 
 	/**
 	 * Gets serializer for.
-	 * @param {EXPECTED_ANY} object for serialization
+	 * @param {ComplexSerializableType} object for serialization
 	 * @returns {SerializerConfigWithSerializer} Serializer config
 	 */
 	static getSerializerFor(object) {
@@ -336,7 +366,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 	/**
 	 * Gets deserializer for.
 	 * @param {string} request request
-	 * @param {string} name name
+	 * @param {string | null} name name
 	 * @returns {ObjectSerializer} serializer
 	 */
 	static getDeserializerFor(request, name) {
@@ -353,7 +383,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 	/**
 	 * Get deserializer for without error.
 	 * @param {string} request request
-	 * @param {string} name name
+	 * @param {string | null} name name
 	 * @returns {ObjectSerializer | undefined} serializer
 	 */
 	static _getDeserializerForWithoutError(request, name) {
@@ -492,13 +522,13 @@ class ObjectMiddleware extends SerializerMiddleware {
 								return `Object { ${Object.keys(item).join(", ")} }`;
 							}
 							if (item.constructor === Map) {
-								return `Map { ${/** @type {Map<EXPECTED_ANY, EXPECTED_ANY>} */ (item).size} items }`;
+								return `Map { ${/** @type {Map<ComplexSerializableType, ComplexSerializableType>} */ (item).size} items }`;
 							}
 							if (item.constructor === Array) {
-								return `Array { ${/** @type {EXPECTED_ANY[]} */ (item).length} items }`;
+								return `Array { ${/** @type {ComplexSerializableType[]} */ (item).length} items }`;
 							}
 							if (item.constructor === Set) {
-								return `Set { ${/** @type {Set<EXPECTED_ANY>} */ (item).size} items }`;
+								return `Set { ${/** @type {Set<ComplexSerializableType>} */ (item).size} items }`;
 							}
 							if (item.constructor === RegExp) {
 								return /** @type {RegExp} */ (item).toString();
@@ -543,7 +573,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 		/**
 		 * Writes one item into the output; the context is returned so writes chain.
 		 * @param {ComplexSerializableType} item item to serialize
-		 * @returns {ObjectSerializerContext<EXPECTED_ANY>} context
+		 * @returns {ObjectSerializerContext<ComplexSerializableType[]>} context
 		 */
 		const process = (item) => {
 			switch (typeof item) {
@@ -724,7 +754,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 			}
 			return ctx;
 		};
-		/** @type {ObjectSerializerContext<EXPECTED_ANY>} */
+		/** @type {ObjectSerializerContext<ComplexSerializableType[]>} */
 		let ctx = {
 			write: process,
 			setCircularReference(ref) {
@@ -772,10 +802,9 @@ class ObjectMiddleware extends SerializerMiddleware {
 
 			throw err;
 		} finally {
-			// Get rid of these references to avoid leaking memory
-			// This happens because the optimized code v8 generates
-			// is optimized for our "ctx.write" method so it will reference
-			// it from e. g. Dependency.prototype.serialize -(IC)-> ctx.write
+			// Drop these references, which would otherwise leak: v8 optimizes the
+			// generated code for this `ctx.write`, so an inline cache on
+			// `Dependency.prototype.serialize` keeps pointing at it.
 			data =
 				result =
 				referenceable =
@@ -823,10 +852,10 @@ class ObjectMiddleware extends SerializerMiddleware {
 		let objectTypeLookup = [];
 		/** @type {ComplexSerializableType[]} */
 		let result = [];
-		/** @type {ObjectDeserializerContext<EXPECTED_ANY>} */
+		/** @type {ObjectDeserializerContext<ComplexSerializableType[]>} */
 		let ctx = {
 			read() {
-				return /** @type {EXPECTED_ANY} */ (decodeValue());
+				return decodeValue();
 			},
 			// type-only cursor advance; same object, retyped to the tuple tail
 			get rest() {
@@ -974,10 +1003,9 @@ class ObjectMiddleware extends SerializerMiddleware {
 			}
 			return result;
 		} finally {
-			// Get rid of these references to avoid leaking memory
-			// This happens because the optimized code v8 generates
-			// is optimized for our "ctx.read" method so it will reference
-			// it from e. g. Dependency.prototype.deserialize -(IC)-> ctx.read
+			// Drop these references, which would otherwise leak: v8 optimizes the
+			// generated code for this `ctx.read`, so an inline cache on
+			// `Dependency.prototype.deserialize` keeps pointing at it.
 			result =
 				referenceable =
 				data =

package/lib/serialization/SerializerMiddleware.js

@@ -10,7 +10,7 @@ const LAZY_TARGET = Symbol("lazy serialization target");
 const LAZY_SERIALIZED_VALUE = Symbol("lazy serialization data");
 
 /** @typedef {SerializerMiddleware<EXPECTED_ANY, EXPECTED_ANY, Record<string, EXPECTED_ANY>>} LazyTarget */
-/** @typedef {Record<string, EXPECTED_ANY>} LazyOptions */
+/** @typedef {{ name?: string, size?: number }} LazyOptions */
 
 /**
  * Defines the lazy function type used by this module.
@@ -102,7 +102,7 @@ class SerializerMiddleware {
 	 * @template TLazyInputValue
 	 * @template TLazyOutputValue
 	 * @template {LazyTarget} TLazyTarget
-	 * @template {Record<string, EXPECTED_ANY>} TLazyOptions
+	 * @template {LazyOptions} TLazyOptions
 	 * @param {LazyFunction<TLazyInputValue, TLazyOutputValue, TLazyTarget, TLazyOptions>} fn lazy function
 	 * @returns {LazyOptions | undefined} options
 	 */

package/lib/serialization/SingleItemMiddleware.js

@@ -6,8 +6,10 @@
 
 const SerializerMiddleware = require("./SerializerMiddleware");
 
-/** @typedef {EXPECTED_ANY} DeserializedType */
-/** @typedef {EXPECTED_ANY[]} SerializedType */
+/** @import { ComplexSerializableType } from "./types" */
+
+/** @typedef {ComplexSerializableType} DeserializedType */
+/** @typedef {ComplexSerializableType[]} SerializedType */
 /** @typedef {EXPECTED_OBJECT} Context */
 
 /**

package/lib/sharing/ConsumeSharedFallbackDependency.js

@@ -5,7 +5,9 @@
 
 "use strict";
 
-const ModuleDependency = require("../dependencies/ModuleDependency");
+/** @import { DependencyKinds } from "../graph/Dependency" */
+
+const ModuleDependency = require("../dependencies/core/ModuleDependency");
 const makeSerializable = require("../util/makeSerializable");
 
 class ConsumeSharedFallbackDependency extends ModuleDependency {
@@ -31,4 +33,10 @@ makeSerializable(
 	"webpack/lib/sharing/ConsumeSharedFallbackDependency"
 );
 
+/** @type {Set<keyof DependencyKinds>} */
+ConsumeSharedFallbackDependency.KINDS = new Set([
+	...ModuleDependency.KINDS,
+	"sharing-request"
+]);
+
 module.exports = ConsumeSharedFallbackDependency;

package/lib/sharing/ConsumeSharedModule.js

@@ -6,19 +6,19 @@
 "use strict";
 
 const { RawSource } = require("webpack-sources");
-const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
-const Module = require("../Module");
+const AsyncDependenciesBlock = require("../graph/AsyncDependenciesBlock");
+const Module = require("../module/Module");
 const {
 	CONSUME_SHARED_TYPES,
 	JAVASCRIPT_TYPES
-} = require("../ModuleSourceTypeConstants");
+} = require("../module/ModuleSourceTypeConstants");
 const {
 	WEBPACK_MODULE_TYPE_CONSUME_SHARED_MODULE
-} = require("../ModuleTypeConstants");
-const RuntimeGlobals = require("../RuntimeGlobals");
+} = require("../module/ModuleTypeConstants");
+const RuntimeGlobals = require("../runtime/RuntimeGlobals");
 const makeSerializable = require("../util/makeSerializable");
-const { rangeToString, stringifyHoley } = require("../util/semver");
 const ConsumeSharedFallbackDependency = require("./ConsumeSharedFallbackDependency");
+const { rangeToString, stringifyHoley } = require("./semver");
 
 /** @type {WeakMap<ModuleGraph, WeakMap<ConsumeSharedModule, Module | null>>} */
 const fallbackModuleCache = new WeakMap();
@@ -29,7 +29,7 @@ const fallbackModuleCache = new WeakMap();
  * } from "../config/defaults"
  */
 /** @import Compilation from "../Compilation" */
-/** @import { UpdateHashContext } from "../Dependency" */
+/** @import { UpdateHashContext } from "../graph/Dependency" */
 /**
  * @import {
  * 	BuildCallback,
@@ -42,17 +42,18 @@ const fallbackModuleCache = new WeakMap();
  * 	Sources,
  * 	SourceTypes,
  * 	ExportsType,
- * 	BasicSourceTypes
- * } from "../Module"
+ * 	BasicSourceTypes,
+ * 	ModuleKinds
+ * } from "../module/Module"
  */
-/** @import ModuleGraph from "../ModuleGraph" */
-/** @import RequestShortener from "../RequestShortener" */
-/** @import { ResolverWithOptions } from "../ResolverFactory" */
+/** @import ModuleGraph from "../graph/ModuleGraph" */
+/** @import RequestShortener from "../util/RequestShortener" */
+/** @import { ResolverWithOptions } from "../resolve/ResolverFactory" */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[ConsumeOptions]>} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[ConsumeOptions]>} ObjectSerializerContext */
 /** @import Hash from "../util/Hash" */
-/** @import { InputFileSystem } from "../util/fs" */
-/** @import { SemVerRange } from "../util/semver" */
+/** @import { InputFileSystem } from "../fs/fs" */
+/** @import { SemVerRange } from "./semver" */
 
 /**
  * Represents the consume shared module runtime component.
@@ -364,4 +365,7 @@ makeSerializable(
 	"webpack/lib/sharing/ConsumeSharedModule"
 );
 
+/** @type {Set<keyof ModuleKinds>} */
+ConsumeSharedModule.KINDS = new Set([...Module.KINDS, "consume-shared"]);
+
 module.exports = ConsumeSharedModule;