webpack 5.107.2 → 5.108.0

package/lib/util/deterministicGrouping.js

@@ -81,7 +81,7 @@ const getName = (a, b, usedNames) => {
  * @returns {void}
  */
 const addSizeTo = (total, size) => {
-	for (const key of Object.keys(size)) {
+	for (const key in size) {
 		total[key] = (total[key] || 0) + size[key];
 	}
 };
@@ -93,7 +93,7 @@ const addSizeTo = (total, size) => {
  * @returns {void}
  */
 const subtractSizeFrom = (total, size) => {
-	for (const key of Object.keys(size)) {
+	for (const key in size) {
 		total[key] -= size[key];
 	}
 };
@@ -101,14 +101,15 @@ const subtractSizeFrom = (total, size) => {
 /**
  * Returns total size.
  * @template T
- * @param {Iterable<Node<T>>} nodes some nodes
+ * @param {Node<T>[]} nodes some nodes
+ * @param {number=} start start index
  * @returns {Sizes} total size
  */
-const sumSize = (nodes) => {
+const sumSize = (nodes, start) => {
 	/** @type {Sizes} */
 	const sum = Object.create(null);
-	for (const node of nodes) {
-		addSizeTo(sum, node.size);
+	for (let i = start || 0; i < nodes.length; i++) {
+		addSizeTo(sum, nodes[i].size);
 	}
 	return sum;
 };
@@ -120,7 +121,7 @@ const sumSize = (nodes) => {
  * @returns {boolean} true, when size is too big
  */
 const isTooBig = (size, maxSize) => {
-	for (const key of Object.keys(size)) {
+	for (const key in size) {
 		const s = size[key];
 		if (s === 0) continue;
 		const maxSizeValue = maxSize[key];
@@ -136,7 +137,7 @@ const isTooBig = (size, maxSize) => {
  * @returns {boolean} true, when size is too small
  */
 const isTooSmall = (size, minSize) => {
-	for (const key of Object.keys(size)) {
+	for (const key in size) {
 		const s = size[key];
 		if (s === 0) continue;
 		const minSizeValue = minSize[key];
@@ -156,7 +157,7 @@ const isTooSmall = (size, minSize) => {
 const getTooSmallTypes = (size, minSize) => {
 	/** @type {Types} */
 	const types = new Set();
-	for (const key of Object.keys(size)) {
+	for (const key in size) {
 		const s = size[key];
 		if (s === 0) continue;
 		const minSizeValue = minSize[key];
@@ -174,7 +175,7 @@ const getTooSmallTypes = (size, minSize) => {
  */
 const getNumberOfMatchingSizeTypes = (size, types) => {
 	let i = 0;
-	for (const key of Object.keys(size)) {
+	for (const key in size) {
 		if (size[/** @type {keyof T} */ (key)] !== 0 && types.has(key)) i++;
 	}
 	return i;
@@ -188,7 +189,7 @@ const getNumberOfMatchingSizeTypes = (size, types) => {
  */
 const selectiveSizeSum = (size, types) => {
 	let sum = 0;
-	for (const key of Object.keys(size)) {
+	for (const key in size) {
 		if (size[key] !== 0 && types.has(key)) sum += size[key];
 	}
 	return sum;
@@ -206,8 +207,11 @@ class Node {
 	 * @param {Sizes} size size
 	 */
 	constructor(item, key, size) {
+		/** @type {T} */
 		this.item = item;
+		/** @type {string} */
 		this.key = key;
+		/** @type {Sizes} */
 		this.size = size;
 	}
 }
@@ -226,8 +230,11 @@ class Group {
 	 * @param {Sizes=} size size of the group
 	 */
 	constructor(nodes, similarities, size) {
+		/** @type {Node<T>[]} */
 		this.nodes = nodes;
+		/** @type {Similarities | null} */
 		this.similarities = similarities;
+		/** @type {Sizes} */
 		this.size = size || sumSize(nodes);
 		/** @type {string | undefined} */
 		this.key = undefined;
@@ -483,7 +490,7 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 					let best = -1;
 					let bestSimilarity = Infinity;
 					let pos = left;
-					const rightSize = sumSize(group.nodes.slice(pos));
+					const rightSize = sumSize(group.nodes, pos);
 
 					//       pos v   v right
 					// [ O O O ] O O O [ O O O ]

package/lib/util/extractSourceMap.js

@@ -92,7 +92,7 @@ function getAbsolutePath(context, request, sourceRoot) {
  * @returns {boolean} true if value is a URL
  */
 function isURL(value) {
-	return validProtocolPattern.test(value) && !path.win32.isAbsolute(value);
+	return validProtocolPattern.test(value) && !isAbsolute(value);
 }
 
 /**

package/lib/util/findGraphRoots.js

@@ -26,6 +26,7 @@ class Node {
 	 * @param {T} item the value of the node
 	 */
 	constructor(item) {
+		/** @type {T} */
 		this.item = item;
 		/** @type {Nodes<T>} */
 		this.dependencies = new Set();
@@ -46,6 +47,7 @@ class SCC {
 	constructor() {
 		/** @type {Nodes<T>} */
 		this.nodes = new Set();
+		/** @type {number} */
 		this.marker = NO_MARKER;
 	}
 }

package/lib/util/fs.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const path = require("path");
+const { ABSOLUTE_PATH_REGEXP } = require("./identifier");
 
 /** @typedef {import("../../declarations/WebpackOptions").WatchOptions} WatchOptions */
 /** @typedef {import("watchpack").Entry} Entry */
@@ -610,7 +611,9 @@ const mkdirp = (fs, p, callback) => {
 					}
 					fs.mkdir(p, (err) => {
 						if (err) {
-							if (err.code === "EEXIST") {
+							// EEXIST: parent already created it; EISDIR: memfs/BSD for an
+							// existing dir such as the root "/" (#10544)
+							if (err.code === "EEXIST" || err.code === "EISDIR") {
 								callback();
 								return;
 							}
@@ -621,7 +624,7 @@ const mkdirp = (fs, p, callback) => {
 					});
 				});
 				return;
-			} else if (err.code === "EEXIST") {
+			} else if (err.code === "EEXIST" || err.code === "EISDIR") {
 				callback();
 				return;
 			}
@@ -651,7 +654,10 @@ const mkdirpSync = (fs, p) => {
 				mkdirpSync(fs, dir);
 				fs.mkdirSync(p);
 				return;
-			} else if (/** @type {NodeJS.ErrnoException} */ (err).code === "EEXIST") {
+			} else if (
+				/** @type {NodeJS.ErrnoException} */ (err).code === "EEXIST" ||
+				/** @type {NodeJS.ErrnoException} */ (err).code === "EISDIR"
+			) {
 				return;
 			}
 			throw err;
@@ -730,8 +736,7 @@ const lstatReadlinkAbsolute = (fs, p, callback) => {
  * @param {string} pathname a path
  * @returns {boolean} is absolute
  */
-const isAbsolute = (pathname) =>
-	path.posix.isAbsolute(pathname) || path.win32.isAbsolute(pathname);
+const isAbsolute = (pathname) => ABSOLUTE_PATH_REGEXP.test(pathname);
 
 module.exports.dirname = dirname;
 module.exports.isAbsolute = isAbsolute;

package/lib/util/hash/DebugHash.js

@@ -13,6 +13,7 @@ const Hash = require("../Hash");
 class DebugHash extends Hash {
 	constructor() {
 		super();
+		/** @type {string} */
 		this.string = "";
 	}
 

package/lib/util/hash/hash-digest.js

@@ -42,7 +42,13 @@ const FF = BigInt("0xff");
  */
 const encode = (buffer, base) => {
 	if (buffer.length === 0) return "";
-	const bigIntBase = BigInt(ENCODE_TABLE[base].length);
+	const alphabet = ENCODE_TABLE[base];
+	const bigIntBase = BigInt(alphabet.length);
+	// Leading zero bytes are not significant in the BigInt below, so they would be
+	// lost; Base58Check-style, re-emit each as one leading alphabet[0] char. Keeps
+	// the encoding reversible and its length tracking the input (prefix-stable slices).
+	let zeros = 0;
+	while (zeros < buffer.length && buffer[zeros] === 0) zeros++;
 	// Convert buffer to BigInt efficiently using bitwise operations
 	let value = ZERO;
 	for (let i = 0; i < buffer.length; i++) {
@@ -51,12 +57,13 @@ const encode = (buffer, base) => {
 	// Convert to baseX string efficiently using array
 	/** @type {string[]} */
 	const digits = [];
-	if (value === ZERO) return ENCODE_TABLE[base][0];
 	while (value > ZERO) {
 		const remainder = Number(value % bigIntBase);
-		digits.push(ENCODE_TABLE[base][remainder]);
+		digits.push(alphabet[remainder]);
 		value /= bigIntBase;
 	}
+	// Pushed last so they land first after the reverse below.
+	for (let i = 0; i < zeros; i++) digits.push(alphabet[0]);
 	return digits.reverse().join("");
 };
 
@@ -68,30 +75,32 @@ const encode = (buffer, base) => {
  */
 const decode = (data, base) => {
 	if (data.length === 0) return Buffer.from("");
-	const bigIntBase = BigInt(ENCODE_TABLE[base].length);
+	const alphabet = ENCODE_TABLE[base];
+	const bigIntBase = BigInt(alphabet.length);
+	// Leading alphabet[0] chars decode back to leading zero bytes (inverse of encode).
+	const zeroChar = alphabet[0];
+	let zeros = 0;
+	while (zeros < data.length && data[zeros] === zeroChar) zeros++;
 	// Convert the baseX string to a BigInt value
 	let value = ZERO;
 	for (let i = 0; i < data.length; i++) {
-		const digit = ENCODE_TABLE[base].indexOf(data[i]);
+		const digit = alphabet.indexOf(data[i]);
 		if (digit === -1) {
 			throw new Error(`Invalid character at position ${i}: ${data[i]}`);
 		}
 		value = value * bigIntBase + BigInt(digit);
 	}
-	// If value is 0, return a single-byte buffer with value 0
-	if (value === ZERO) {
-		return Buffer.alloc(1);
-	}
-	// Determine buffer size efficiently by counting bytes
+	// Significant byte count of the numeric part (excludes the leading zeros above)
 	let temp = value;
-	let byteLength = 0;
+	let numLength = 0;
 	while (temp > ZERO) {
 		temp >>= EIGHT;
-		byteLength++;
+		numLength++;
 	}
-	// Create buffer and fill it from right to left
-	const buffer = Buffer.alloc(byteLength);
-	for (let i = byteLength - 1; i >= 0; i--) {
+	// Create buffer and fill the numeric part from right to left, leaving the
+	// leading `zeros` bytes as 0.
+	const buffer = Buffer.alloc(zeros + numLength);
+	for (let i = zeros + numLength - 1; i >= zeros; i--) {
 		buffer[i] = Number(value & FF);
 		value >>= EIGHT;
 	}

package/lib/util/identifier.js

@@ -6,6 +6,11 @@
 
 const path = require("path");
 
+// Any absolute path: POSIX (/foo) and every Windows form — drive-letter (C:\,
+// C:/), UNC (\\, //), rooted (\, /); equals posix||win32 isAbsolute.
+const ABSOLUTE_PATH_REGEXP = /^(?:[a-z]:)?[\\/]/i;
+// Windows drive-letter absolute path only (C:\ or C:/), where a leading "/" is
+// NOT absolute — used where POSIX paths must stay relative to a base.
 const WINDOWS_ABS_PATH_REGEXP = /^[a-z]:[\\/]/i;
 const SEGMENTS_SPLIT_REGEXP = /([|!])/;
 const WINDOWS_PATH_SEPARATOR_REGEXP = /\\/g;
@@ -525,6 +530,8 @@ const escapeHashInPathRequest = (request) => {
 	return pathPart.replace(HASH_REGEXP, "\0#") + request.slice(lastSep);
 };
 
+module.exports.ABSOLUTE_PATH_REGEXP = ABSOLUTE_PATH_REGEXP;
+module.exports.WINDOWS_ABS_PATH_REGEXP = WINDOWS_ABS_PATH_REGEXP;
 module.exports.absolutify = absolutify;
 module.exports.contextify = contextify;
 module.exports.escapeHashInPathRequest = escapeHashInPathRequest;

package/lib/util/internalSerializables.js

@@ -13,6 +13,7 @@
 module.exports = {
 	AsyncDependenciesBlock: () => require("../AsyncDependenciesBlock"),
 	ContextModule: () => require("../ContextModule"),
+	"asset/AssetModule": () => require("../asset/AssetModule"),
 	"cache/PackFileCacheStrategy": () =>
 		require("../cache/PackFileCacheStrategy"),
 	"cache/ResolverCachePlugin": () => require("../cache/ResolverCachePlugin"),
@@ -108,12 +109,14 @@ module.exports = {
 		require("../dependencies/HarmonyImportSpecifierDependency"),
 	"dependencies/HarmonyEvaluatedImportSpecifierDependency": () =>
 		require("../dependencies/HarmonyEvaluatedImportSpecifierDependency"),
+	"dependencies/HtmlInlineHtmlDependency": () =>
+		require("../dependencies/HtmlInlineHtmlDependency"),
 	"dependencies/HtmlInlineScriptDependency": () =>
 		require("../dependencies/HtmlInlineScriptDependency"),
 	"dependencies/HtmlInlineStyleDependency": () =>
 		require("../dependencies/HtmlInlineStyleDependency"),
-	"dependencies/HtmlScriptSrcDependency": () =>
-		require("../dependencies/HtmlScriptSrcDependency"),
+	"dependencies/HtmlEntryDependency": () =>
+		require("../dependencies/HtmlEntryDependency"),
 	"dependencies/HtmlSourceDependency": () =>
 		require("../dependencies/HtmlSourceDependency"),
 	"dependencies/ImportContextDependency": () =>
@@ -183,9 +186,15 @@ module.exports = {
 		require("../dependencies/WebpackIsIncludedDependency"),
 	"dependencies/WorkerDependency": () =>
 		require("../dependencies/WorkerDependency"),
+	"html/HtmlModule": () => require("../html/HtmlModule"),
+	"javascript/JavascriptModule": () =>
+		require("../javascript/JavascriptModule"),
 	"json/JsonData": () => require("../json/JsonData"),
+	"json/JsonModule": () => require("../json/JsonModule"),
 	"optimize/ConcatenatedModule": () =>
 		require("../optimize/ConcatenatedModule"),
+	"wasm-async/AsyncWasmModule": () => require("../wasm-async/AsyncWasmModule"),
+	"wasm-sync/SyncWasmModule": () => require("../wasm-sync/SyncWasmModule"),
 
 	DependenciesBlock: () => require("../DependenciesBlock"),
 	ExternalModule: () => require("../ExternalModule"),

package/lib/util/magicComment.js

@@ -24,6 +24,48 @@ module.exports.createMagicCommentContext = () =>
 		codeGeneration: { strings: false, wasm: false }
 	});
 
+// Whole-comment `webpackXxx: <bool|number|null>` pair — parsed without `vm`.
+const MAGIC_COMMENT_FAST_PATH =
+	/^\s*(webpack[A-Z][A-Za-z]+)\s*:\s*(true|false|null|-?\d+(?:\.\d+)?)\s*$/;
+
+/**
+ * Parse one magic comment's text into its options object. Values are detached
+ * from the vm context (RegExps recreated, other objects JSON-cloned). Throws
+ * when the comment body fails to evaluate.
+ * @param {string} value comment text (should already match `webpackCommentRegExp`)
+ * @param {import("vm").Context} context context from `createMagicCommentContext`
+ * @returns {Record<string, EXPECTED_ANY>} parsed options
+ */
+module.exports.parseMagicComment = (value, context) => {
+	const fast = MAGIC_COMMENT_FAST_PATH.exec(value);
+	if (fast !== null) {
+		const raw = fast[2];
+		return {
+			[fast[1]]:
+				raw === "true"
+					? true
+					: raw === "false"
+						? false
+						: raw === "null"
+							? null
+							: Number(raw)
+		};
+	}
+	/** @type {Record<string, EXPECTED_ANY>} */
+	const options = {};
+	for (let [key, val] of Object.entries(
+		getVm().runInContext(`(function(){return {${value}};})()`, context)
+	)) {
+		if (typeof val === "object" && val !== null) {
+			val =
+				val.constructor.name === "RegExp"
+					? new RegExp(val)
+					: JSON.parse(JSON.stringify(val));
+		}
+		options[key] = val;
+	}
+	return options;
+};
 module.exports.webpackCommentRegExp = new RegExp(
 	/(^|\W)webpack[A-Z][A-Za-z]+:/
 );

package/lib/util/makeSerializable.js

@@ -27,6 +27,7 @@ class ClassSerializer {
 	 * @param {SerializableClassConstructor<T>} Constructor constructor
 	 */
 	constructor(Constructor) {
+		/** @type {SerializableClassConstructor<T>} */
 		this.Constructor = Constructor;
 	}
 

package/lib/util/nonNumericOnlyHash.js

@@ -5,6 +5,8 @@
 
 "use strict";
 
+/** @typedef {import("./Hash")} Hash */
+
 const A_CODE = "a".charCodeAt(0);
 
 /**
@@ -13,7 +15,7 @@ const A_CODE = "a".charCodeAt(0);
  * @param {number} hashLength hash length
  * @returns {string} returns hash that has at least one non numeric char
  */
-module.exports = (hash, hashLength) => {
+const nonNumericOnlyHash = (hash, hashLength) => {
 	if (hashLength < 1) return "";
 	const slice = hash.slice(0, hashLength);
 	if (/[^\d]/.test(slice)) return slice;
@@ -21,3 +23,30 @@ module.exports = (hash, hashLength) => {
 		A_CODE + (Number.parseInt(hash[0], 10) % 6)
 	)}${slice.slice(1)}`;
 };
+
+/**
+ * Digests a hash and truncates it to a content-hash string (non-numeric first char).
+ * @param {Hash} hash hash
+ * @param {string} hashDigest digest encoding
+ * @param {number} hashDigestLength hash length
+ * @returns {string} content hash string
+ */
+const digestNonNumericOnly = (hash, hashDigest, hashDigestLength) =>
+	nonNumericOnlyHash(hash.digest(hashDigest), hashDigestLength);
+
+/**
+ * Digests a hash, returning both the truncated content-hash string and the full
+ * (untruncated) digest, so `[contenthash:<digest>]` can re-encode from full entropy.
+ * @param {Hash} hash hash
+ * @param {string} hashDigest digest encoding
+ * @param {number} hashDigestLength hash length
+ * @returns {[string, string]} content hash string and full digest
+ */
+const digestNonNumericOnlyWithFull = (hash, hashDigest, hashDigestLength) => {
+	const full = /** @type {string} */ (hash.digest(hashDigest));
+	return [nonNumericOnlyHash(full, hashDigestLength), full];
+};
+
+module.exports = nonNumericOnlyHash;
+module.exports.digestNonNumericOnly = digestNonNumericOnly;
+module.exports.digestNonNumericOnlyWithFull = digestNonNumericOnlyWithFull;

package/lib/util/property.js

@@ -83,7 +83,13 @@ const propertyAccess = (properties, start = 0) => {
 	let str = "";
 	for (let i = start; i < properties.length; i++) {
 		const p = properties[i];
-		if (`${Number(p)}` === p) {
+		// Only first chars 0-9, "-", "N", "I" can begin a canonical numeric form
+		// (number, NaN, Infinity); skip the Number() round-trip otherwise.
+		const c = p.charCodeAt(0);
+		if (
+			((c >= 48 && c <= 57) || c === 45 || c === 78 || c === 73) &&
+			`${Number(p)}` === p
+		) {
 			str += `[${p}]`;
 		} else if (SAFE_IDENTIFIER.test(p) && !RESERVED_IDENTIFIER.has(p)) {
 			str += `.${p}`;

package/lib/util/publicPathPlaceholder.js

@@ -0,0 +1,64 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+// Placeholders embedded into asset `url()` / HTML chunk URLs at code-generation
+// time, when the final public path can't be resolved yet, then substituted
+// later once the information is available:
+// - PUBLIC_PATH_AUTO    — stands in for `output.publicPath: "auto"`; replaced
+//   with the per-output-file undo path (relative `../` segments back to the
+//   output root) during chunk/asset render.
+// - PUBLIC_PATH_FULL_HASH — stands in for `[fullhash]`/`[hash]` in a public
+//   path before the compilation hash exists. Form: `<prefix><len>__`, where
+//   `<len>` is the requested hash length (`0` means the full hash). Replaced
+//   with the real hash (build-time, e.g. CSS `.css` files) or a runtime
+//   `__webpack_require__.h()` expression (inlined CSS in JS).
+const PUBLIC_PATH_AUTO = "__WEBPACK_CSS_PUBLIC_PATH_AUTO__";
+const PUBLIC_PATH_FULL_HASH = "__WEBPACK_CSS_PUBLIC_PATH_FULL_HASH_";
+
+/**
+ * Scan `content` for `PUBLIC_PATH_FULL_HASH` placeholders and invoke `onMatch`
+ * once per well-formed occurrence. The placeholder spans the half-open range
+ * `[start, end)` and encodes the requested hash length (`0` means the full
+ * hash). Callers substitute the build-time hash or a runtime expression
+ * depending on context.
+ * @param {string} content text to scan
+ * @param {(start: number, end: number, length: number) => void} onMatch placeholder callback
+ * @returns {void}
+ */
+const walkFullHashPlaceholders = (content, onMatch) => {
+	const prefix = PUBLIC_PATH_FULL_HASH;
+	const prefixLen = prefix.length;
+	const len = content.length;
+	let idx = content.indexOf(prefix);
+	while (idx !== -1) {
+		let digitEnd = idx + prefixLen;
+		while (digitEnd < len) {
+			const cc = content.charCodeAt(digitEnd);
+			if (cc < 48 || cc > 57) break;
+			digitEnd++;
+		}
+		// Well-formed placeholder: at least one digit followed by `__`.
+		if (
+			digitEnd > idx + prefixLen &&
+			digitEnd + 1 < len &&
+			content.charCodeAt(digitEnd) === 95 &&
+			content.charCodeAt(digitEnd + 1) === 95
+		) {
+			const length = Number.parseInt(
+				content.slice(idx + prefixLen, digitEnd),
+				10
+			);
+			onMatch(idx, digitEnd + 2, length);
+			idx = content.indexOf(prefix, digitEnd + 2);
+		} else {
+			idx = content.indexOf(prefix, idx + prefixLen);
+		}
+	}
+};
+
+module.exports.PUBLIC_PATH_AUTO = PUBLIC_PATH_AUTO;
+module.exports.PUBLIC_PATH_FULL_HASH = PUBLIC_PATH_FULL_HASH;
+module.exports.walkFullHashPlaceholders = walkFullHashPlaceholders;

package/lib/util/registerExternalSerializer.js

@@ -234,7 +234,7 @@ register(
 		/**
 		 * Serializes this instance into the provided serializer context.
 		 * @param {SourceLocation} loc the location to be serialized
-		 * @param {ObjectSerializerContext} context context
+		 * @param {import("../serialization/ObjectMiddleware").ObjectSerializerContext<number[]>} context context
 		 * @returns {void}
 		 */
 		serialize(loc, { write }) {
@@ -246,7 +246,7 @@ register(
 
 		/**
 		 * Restores this instance from the provided deserializer context.
-		 * @param {ObjectDeserializerContext} context context
+		 * @param {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<number[]>} context context
 		 * @returns {RealDependencyLocation} location
 		 */
 		deserialize({ read }) {
@@ -272,7 +272,7 @@ register(
 		/**
 		 * Serializes this instance into the provided serializer context.
 		 * @param {Position} pos the position to be serialized
-		 * @param {ObjectSerializerContext} context context
+		 * @param {import("../serialization/ObjectMiddleware").ObjectSerializerContext<number[]>} context context
 		 * @returns {void}
 		 */
 		serialize(pos, { write }) {
@@ -282,7 +282,7 @@ register(
 
 		/**
 		 * Restores this instance from the provided deserializer context.
-		 * @param {ObjectDeserializerContext} context context
+		 * @param {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<number[]>} context context
 		 * @returns {SourcePosition} position
 		 */
 		deserialize({ read }) {

package/lib/wasm-async/AsyncWasmModule.js

@@ -0,0 +1,77 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const NormalModule = require("../NormalModule");
+const makeSerializable = require("../util/makeSerializable");
+
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../NormalModule").NormalModuleCreateData} NormalModuleCreateData */
+/** @typedef {import("../dependencies/ImportPhase").ImportPhaseName} ImportPhaseName */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[ImportPhaseName | undefined]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[ImportPhaseName | undefined]>} ObjectSerializerContext */
+
+/**
+ * Module class for `webassembly/async` modules. Wasm-specific properties should live here instead of `NormalModule`.
+ */
+class AsyncWasmModule extends NormalModule {
+	/**
+	 * @param {NormalModuleCreateData & { phase: ImportPhaseName | undefined }} options options object
+	 */
+	constructor(options) {
+		super(options);
+		/** @type {ImportPhaseName | undefined} */
+		this.phase = options.phase;
+	}
+
+	/**
+	 * Returns the unique identifier used to reference this module.
+	 * @returns {string} a unique identifier of the module
+	 */
+	identifier() {
+		let str = super.identifier();
+
+		if (this.phase) {
+			str = `${str}|${this.phase}`;
+		}
+
+		return str;
+	}
+
+	/**
+	 * Assuming this module is in the cache. Update the (cached) module with
+	 * the fresh module from the factory. Usually updates internal references
+	 * and properties.
+	 * @param {Module} module fresh module
+	 * @returns {void}
+	 */
+	updateCacheModule(module) {
+		super.updateCacheModule(module);
+		const m = /** @type {AsyncWasmModule} */ (module);
+		this.phase = m.phase;
+	}
+
+	/**
+	 * Serializes this instance into the provided serializer context.
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		context.write(this.phase);
+		super.serialize(context);
+	}
+
+	/**
+	 * Restores this instance from the provided deserializer context.
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		this.phase = context.read();
+		super.deserialize(context.rest);
+	}
+}
+
+makeSerializable(AsyncWasmModule, "webpack/lib/wasm-async/AsyncWasmModule");
+
+module.exports = AsyncWasmModule;

package/lib/wasm-async/AsyncWebAssemblyJavascriptGenerator.js

@@ -14,7 +14,7 @@ const Template = require("../Template");
 const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
 
 /** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("./AsyncWebAssemblyModulesPlugin").AsyncWasmModuleClass} AsyncWasmModule */
+/** @typedef {import("./AsyncWasmModule")} AsyncWasmModule */
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").SourceType} SourceType */