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

package/lib/runtime/AsyncModuleRuntimeModule.js

@@ -57,7 +57,11 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 									`${cst} hasUnresolvedAsyncSubgraph = asyncDeps.some((id) => {`,
 									Template.indent([
 										`${cst} cache = __webpack_module_cache__[id];`,
-										"return !cache || cache[webpackDone] === false;"
+										"if (!cache) return true;",
+										// A cached entry no longer means finished, and a rejected
+										// one is done but its error must still reach the importer.
+										`${cst} deps = cache.exports;`,
+										"return deps[webpackDone] !== true || deps[webpackError] !== undefined;"
 									]),
 									"});",
 									"if (hasUnresolvedAsyncSubgraph) {",

package/lib/runtime/MakeDeferredNamespaceObjectRuntime.js

@@ -290,7 +290,17 @@ class MakeOptimizedDeferredNamespaceObjectRuntimeModule extends HelperRuntimeMod
 				]),
 				"};",
 				hasAsync
-					? `if(isAsync) obj[${RuntimeGlobals.deferredModuleAsyncTransitiveDependenciesSymbol}] = asyncDeps;`
+					? // `GatherAsynchronousTransitiveDependencies` skips a module that is
+						// already evaluating, and evaluates the rest right here.
+						`if(isAsync) obj[${RuntimeGlobals.deferredModuleAsyncTransitiveDependenciesSymbol}] = asyncDeps.filter(${runtimeTemplate.basicFunction(
+							"id",
+							[
+								`${cst} dep = __webpack_module_cache__[id];`,
+								"if (dep && (dep.evaluating || dep.evaluatingAsync)) return false;",
+								"r(id);",
+								"return true;"
+							]
+						)});`
 					: "",
 				"return obj;"
 			]),

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/serialization/FileMiddleware.js

@@ -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;

package/lib/typescript/TypeScriptPlugin.js

@@ -14,7 +14,7 @@ const {
 } = require("../ModuleTypeConstants");
 const NormalModule = require("../NormalModule");
 const memoize = require("../util/memoize");
-const removeBOM = require("../util/removeBOM");
+const { removeBOMFromResult } = require("../util/removeBOM");
 
 const getModuleBuildError = memoize(() =>
 	require("../errors/ModuleBuildError")
@@ -133,15 +133,11 @@ const stripTypes = (input) => {
 };
 
 /**
- * Coerce a Buffer-or-string source to a UTF-8 string, dropping any BOM.
  * @param {string | Buffer} source raw source from the loader pipeline
- * @returns {string} UTF-8 string without BOM
+ * @returns {string} UTF-8 string
  */
-const toBomFreeString = (source) => {
-	const text = Buffer.isBuffer(source) ? source.toString("utf8") : source;
-	const stripped = removeBOM(text);
-	return typeof stripped === "string" ? stripped : stripped.toString("utf8");
-};
+const asString = (source) =>
+	Buffer.isBuffer(source) ? source.toString("utf8") : source;
 
 class TypeScriptPlugin {
 	/**
@@ -181,8 +177,10 @@ class TypeScriptPlugin {
 			throw new (getModuleBuildError())(new Error(NODE_API_MISSING));
 		}
 
-		const [rawSource, loaderSourceMap, ...rest] = result;
-		const preStripSource = toBomFreeString(rawSource);
+		// A BOM must be off the source before it is stripped of types, and its
+		// map moved with it.
+		const [rawSource, loaderSourceMap, ...rest] = removeBOMFromResult(result);
+		const preStripSource = asString(rawSource);
 		const strippedSource = stripTypes(preStripSource);
 
 		const needSourceMap = module.useSourceMap || module.useSimpleSourceMap;

package/lib/util/ArrayQueue.js

@@ -90,11 +90,11 @@ class ArrayQueue {
 	[Symbol.iterator]() {
 		return {
 			next: () => {
-				const item = this.dequeue();
-				if (item) {
+				// length, not truthiness: a queued `0`/`false`/`undefined` is a value
+				if (this.length > 0) {
 					return {
 						done: false,
-						value: item
+						value: /** @type {T} */ (this.dequeue())
 					};
 				}
 				return {

package/lib/util/SourceProcessor.js

@@ -99,6 +99,23 @@ const expandDeferredWrites = (text, resolve, infix) => {
 	return out + text.slice(from);
 };
 
+/**
+ * The text this print spells with every deferred write declined: each marker
+ * replaced by what would stand there had no renderer answered. What a print
+ * verifying itself by re-parsing has to read, since a marker otherwise parses
+ * as text where its node stood. `build` rather than `source` so a write inside
+ * an attribute comes back escaped for where it sits.
+ * @param {string} text the printed output, holding this print's markers
+ * @param {DeferredWrite[]} writes what the print deferred, indexed by id
+ * @returns {string} the text with every marker put back
+ */
+const declineDeferredWrites = (text, writes) =>
+	expandDeferredWrites(
+		text,
+		(id) => (id < writes.length ? writes[id].build(undefined) : undefined),
+		deferredInfix
+	);
+
 /**
  * Babel-style visitor map keyed by a numeric node-type discriminator; a bucket
  * is a function (enter-only) or `{ enter?, exit? }`.
@@ -389,16 +406,14 @@ class PrintContext {
 	_growStore(need) {
 		// From empty: a context that prints one inline `style=""` must not pay for
 		// a stylesheet's worth of columns.
-		const size = Math.max(need, this._storeText.length * 2, 16);
-		// Appended, which keeps the column packed for the read every composed child
-		// makes, and carries what it already holds across in the same pass.
-		const held = this._storeText;
-		const text = [];
-		for (let i = 0; i < held.length; i++) text.push(held[i]);
-		for (let i = held.length; i < size; i++) text.push("");
+		const text = this._storeText;
+		const size = Math.max(need, text.length * 2, 16);
+		// Appended in place: `push` keeps the column packed for the read every
+		// composed child makes, and what it already holds never moves — where
+		// filling a second array would copy every slot again at each growth.
+		for (let i = text.length; i < size; i++) text.push("");
 		const gen = new Int32Array(size);
 		gen.set(this._storeGen);
-		this._storeText = text;
 		this._storeGen = gen;
 	}
 
@@ -1142,4 +1157,5 @@ class SourceProcessor {
 SourceProcessor.PrintContext = PrintContext;
 
 module.exports = SourceProcessor;
+module.exports.declineDeferredWrites = declineDeferredWrites;
 module.exports.deferredWrite = deferredWrite;

package/lib/util/URLAbsoluteSpecifier.js

@@ -17,6 +17,7 @@ const _0CharCode = "0".charCodeAt(0);
 const _9CharCode = "9".charCodeAt(0);
 const plusCharCode = "+".charCodeAt(0);
 const hyphenCharCode = "-".charCodeAt(0);
+const dotCharCode = ".".charCodeAt(0);
 const colonCharCode = ":".charCodeAt(0);
 const hashCharCode = "#".charCodeAt(0);
 const queryCharCode = "?".charCodeAt(0);
@@ -46,7 +47,8 @@ function getScheme(specifier) {
 		(ch >= aUpperCaseCharCode && ch <= zUpperCaseCharCode) ||
 		(ch >= _0CharCode && ch <= _9CharCode) ||
 		ch === plusCharCode ||
-		ch === hyphenCharCode
+		ch === hyphenCharCode ||
+		ch === dotCharCode
 	) {
 		if (++i === specifier.length) return;
 		ch = specifier.charCodeAt(i);

package/lib/util/conventions.js

@@ -115,7 +115,11 @@ module.exports.cssExportConvention = (input, convention) => {
 	const set = new Set();
 	if (typeof convention === "function") {
 		const result = convention(input);
-		const validate = (/** @type {string} */ name) => {
+		/**
+		 * @param {string} name name returned by the convention function
+		 * @returns {void}
+		 */
+		const validate = (name) => {
 			if (typeof name !== "string" || name.length === 0) {
 				throw new Error(
 					`exportsConvention function must return a non-empty string or an array of non-empty strings, got ${safeStringify(result)}`

package/lib/util/createMappings.js

@@ -13,9 +13,9 @@
  * while richer call sites can pass arrays of segments.
  *
  * TODO move this encoder into `webpack-sources` and replace the body of this
- * file with re-exports. The public shape (`encodeVLQ`, `encodeMappings(lines)`,
- * `MappingSegment`, `LineMappings`) is intended to match what would land
- * upstream so call sites don't have to change.
+ * file with re-exports. The public shape (`encodeVLQ`, `decodeVLQ`,
+ * `encodeMappings(lines)`, `MappingSegment`, `LineMappings`) is intended to
+ * match what would land upstream so call sites don't have to change.
  */
 
 const VLQ_BASE64 =
@@ -38,6 +38,27 @@ const encodeVLQ = (value) => {
 	return result;
 };
 
+/**
+ * Decode one base64 VLQ value per the source-map V3 spec.
+ * @param {string} mappings a VLQ encoded `mappings` string
+ * @param {number} start index of the value's first character
+ * @returns {{ value: number, end: number }} the decoded value and the index just past it; `end` equals `start` when there is no valid value at `start`
+ */
+const decodeVLQ = (mappings, start) => {
+	let value = 0;
+	let shift = 0;
+	let index = start;
+	let digit;
+	do {
+		digit = index < mappings.length ? VLQ_BASE64.indexOf(mappings[index]) : -1;
+		if (digit < 0) return { value: 0, end: start };
+		value += (digit & 0x1f) << shift;
+		shift += 5;
+		index++;
+	} while (digit & 0x20);
+	return { value: value & 1 ? -(value >>> 1) : value >>> 1, end: index };
+};
+
 /**
  * @typedef {object} MappingSegment
  * @property {number=} generatedColumn 0-based generated column (defaults to 0)
@@ -114,5 +135,6 @@ const encodeMappings = (lines) => {
 	return encodedLines.join(";");
 };
 
+module.exports.decodeVLQ = decodeVLQ;
 module.exports.encodeMappings = encodeMappings;
 module.exports.encodeVLQ = encodeVLQ;

package/lib/util/internalSerializables.js

@@ -211,6 +211,8 @@ module.exports = {
 	"errors/EnvironmentNotSupportAsyncWarning": () =>
 		require("../errors/EnvironmentNotSupportAsyncWarning"),
 	"errors/HookWebpackError": () => require("../errors/HookWebpackError"),
+	"errors/ImportedBindingAssignmentError": () =>
+		require("../errors/ImportedBindingAssignmentError"),
 	"errors/InvalidDependenciesModuleWarning": () =>
 		require("../errors/InvalidDependenciesModuleWarning"),
 	"errors/JSONParseError": () => require("../errors/JSONParseError"),

package/lib/util/removeBOM.js

@@ -5,12 +5,17 @@
 
 "use strict";
 
+const { decodeVLQ, encodeVLQ } = require("./createMappings");
+
+/** @import { RawSourceMap } from "webpack-sources" */
+/** @import { Result } from "../NormalModule" */
+
 /**
  * Returns result without BOM.
  * @param {string | Buffer} strOrBuffer string or buffer
  * @returns {string | Buffer} result without BOM
  */
-module.exports = (strOrBuffer) => {
+const removeBOM = (strOrBuffer) => {
 	if (typeof strOrBuffer === "string" && strOrBuffer.charCodeAt(0) === 0xfeff) {
 		return strOrBuffer.slice(1);
 	} else if (
@@ -24,3 +29,79 @@ module.exports = (strOrBuffer) => {
 
 	return strOrBuffer;
 };
+
+/**
+ * A BOM occupies generated column 0 of the first line, so a map describing
+ * BOM-prefixed content starts that line at column 1 or later. Removing the BOM
+ * moves the line one column left; the segments after the first are encoded
+ * relative to it, so only the first is rewritten. A map already starting at
+ * column 0 describes the content without its BOM and is left alone.
+ * @param {string} mappings VLQ encoded `mappings` of a map for BOM-prefixed content
+ * @returns {string} `mappings` for the same content without its BOM
+ */
+const shiftMappings = (mappings) => {
+	const { value, end } = decodeVLQ(mappings, 0);
+	if (end === 0 || value <= 0) return mappings;
+	return encodeVLQ(value - 1) + mappings.slice(end);
+};
+
+/**
+ * Adjust a source map that accompanied BOM-prefixed content for the removal of
+ * that BOM. Anything without VLQ `mappings` is passed through untouched, as is
+ * a map declaring a version other than 3 — earlier versions spell `mappings`
+ * differently. A map that declares no version at all is taken as version 3.
+ * @param {(string | RawSourceMap)=} sourceMap the map, as an object or as JSON
+ * @returns {(string | RawSourceMap)=} the adjusted map
+ */
+const adjustSourceMapForRemovedBOM = (sourceMap) => {
+	if (!sourceMap) return sourceMap;
+
+	if (typeof sourceMap === "string") {
+		/** @type {RawSourceMap} */
+		let parsed;
+		try {
+			parsed = JSON.parse(sourceMap);
+		} catch (_err) {
+			return sourceMap;
+		}
+		const adjusted = adjustSourceMapForRemovedBOM(parsed);
+		return adjusted === parsed ? sourceMap : JSON.stringify(adjusted);
+	}
+
+	if (sourceMap.version !== undefined && sourceMap.version !== 3) {
+		return sourceMap;
+	}
+
+	if (typeof sourceMap.mappings !== "string") return sourceMap;
+
+	const mappings = shiftMappings(sourceMap.mappings);
+
+	return mappings === sourceMap.mappings
+		? sourceMap
+		: { ...sourceMap, mappings };
+};
+
+/**
+ * @param {Result} result a loader result: content, an optional source map, extra info
+ * @returns {Result} the result with a leading BOM removed from its content and its source map kept in sync
+ */
+const removeBOMFromResult = (result) => {
+	const content = result[0];
+	const withoutBOM = removeBOM(content);
+
+	if (withoutBOM === content) return result;
+
+	// Copied rather than rebuilt, so a result carrying no source map keeps its
+	// arity.
+	const adjusted = /** @type {Result} */ ([...result]);
+
+	adjusted[0] = withoutBOM;
+
+	if (adjusted[1]) adjusted[1] = adjustSourceMapForRemovedBOM(adjusted[1]);
+
+	return adjusted;
+};
+
+module.exports.adjustSourceMapForRemovedBOM = adjustSourceMapForRemovedBOM;
+module.exports.removeBOM = removeBOM;
+module.exports.removeBOMFromResult = removeBOMFromResult;

package/lib/wasm-async/AsyncWasmCompileRuntimeModule.js

@@ -11,11 +11,12 @@ const Template = require("../Template");
 const { fullHashPathData } = require("../wasm/wasmModuleFilename");
 
 /** @import Chunk from "../Chunk" */
+/** @import ChunkGraph from "../ChunkGraph" */
 /** @import Compilation from "../Compilation" */
 /** @import { RuntimeSpec } from "../util/runtime" */
 
 /** @typedef {(wasmModuleSrcPath: string) => string} GenerateBeforeLoadBinaryCode */
-/** @typedef {(wasmModuleSrcPath: string, runtime: RuntimeSpec) => string} GenerateLoadBinaryCode */
+/** @typedef {(wasmModuleSrcPath: string, runtime: RuntimeSpec, analyzable: boolean) => string} GenerateLoadBinaryCode */
 /** @typedef {() => string} GenerateBeforeCompileStreaming */
 
 /**
@@ -69,7 +70,7 @@ class AsyncWasmCompileRuntimeModule extends RuntimeModule {
 		// Analyzable output bakes the binary's URL into the call site instead.
 		const analyzable = runtimeTemplate.supportsAnalyzable(
 			"wasm",
-			undefined,
+			/** @type {ChunkGraph} */ (this.chunkGraph),
 			undefined,
 			chunk.runtime
 		);
@@ -92,7 +93,8 @@ class AsyncWasmCompileRuntimeModule extends RuntimeModule {
 
 		const loader = this.generateLoadBinaryCode(
 			wasmModuleSrcPath,
-			chunk.runtime
+			chunk.runtime,
+			analyzable
 		);
 
 		// Fallback path: fetch -> arrayBuffer -> WebAssembly.compile

package/lib/wasm-async/AsyncWasmLoadingRuntimeModule.js

@@ -11,11 +11,12 @@ const Template = require("../Template");
 const { fullHashPathData } = require("../wasm/wasmModuleFilename");
 
 /** @import Chunk from "../Chunk" */
+/** @import ChunkGraph from "../ChunkGraph" */
 /** @import Compilation from "../Compilation" */
 /** @import { RuntimeSpec } from "../util/runtime" */
 
 /** @typedef {(wasmModuleSrcPath: string) => string} GenerateBeforeLoadBinaryCode */
-/** @typedef {(wasmModuleSrcPath: string, runtime: RuntimeSpec) => string} GenerateLoadBinaryCode */
+/** @typedef {(wasmModuleSrcPath: string, runtime: RuntimeSpec, analyzable: boolean) => string} GenerateLoadBinaryCode */
 /** @typedef {() => string} GenerateBeforeInstantiateStreaming */
 
 /**
@@ -70,7 +71,7 @@ class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
 		// Analyzable output bakes the binary's URL into the call site instead.
 		const analyzable = runtimeTemplate.supportsAnalyzable(
 			"wasm",
-			undefined,
+			/** @type {ChunkGraph} */ (this.chunkGraph),
 			undefined,
 			chunk.runtime
 		);
@@ -93,7 +94,8 @@ class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
 
 		const loader = this.generateLoadBinaryCode(
 			wasmModuleSrcPath,
-			chunk.runtime
+			chunk.runtime,
+			analyzable
 		);
 		const fallback = [
 			`.then(${runtimeTemplate.returningFunction("x.arrayBuffer()", "x")})`,

package/lib/wasm-async/UniversalCompileAsyncWasmPlugin.js

@@ -67,31 +67,26 @@ class UniversalCompileAsyncWasmPlugin {
 			// per call: it depends on parse results, so it is not settled while the plugin
 			// is being applied.
 			/**
-			 * @param {RuntimeSpec} runtime the runtime this loader serves
+			 * @param {boolean} analyzable whether the call site bakes a complete URL
 			 * @returns {string} the argument to hand the reader
 			 */
-			const wasmUrlArg = (runtime) =>
-				compilation.runtimeTemplate.supportsAnalyzable(
-					"wasm",
-					undefined,
-					undefined,
-					runtime
-				)
+			const wasmUrlArg = (analyzable) =>
+				analyzable
 					? "wasmUrl"
 					: compilation.runtimeTemplate.importMetaUrl("wasmUrl");
 			/**
 			 * Generates the runtime expression that fetches the binary in browsers
 			 * or reads it from the filesystem in Node.js.
-			 * @type {(path: string, runtime: RuntimeSpec) => string}
+			 * @type {(path: string, runtime: RuntimeSpec, analyzable: boolean) => string}
 			 */
-			const generateLoadBinaryCode = (path, runtime) =>
+			const generateLoadBinaryCode = (path, runtime, analyzable) =>
 				Template.asString([
 					"(useFetch",
-					Template.indent([`? fetch(${wasmUrlArg(runtime)})`]),
+					Template.indent([`? fetch(${wasmUrlArg(analyzable)})`]),
 					Template.indent([
 						": Promise.all([import('fs'), import('url')]).then(([{ readFile }, { URL }]) => new Promise((resolve, reject) => {",
 						Template.indent([
-							`readFile(${wasmUrlArg(runtime)}, (err, buffer) => {`,
+							`readFile(${wasmUrlArg(analyzable)}, (err, buffer) => {`,
 							Template.indent([
 								"if (err) return reject(err);",
 								"",

package/lib/web/FetchCompileAsyncWasmPlugin.js

@@ -91,12 +91,14 @@ class FetchCompileAsyncWasmPlugin {
 					}
 					const baked = compilation.runtimeTemplate.supportsAnalyzable(
 						"wasm",
-						undefined,
+						chunkGraph,
 						undefined,
 						chunk.runtime
 					);
-					const analyzable =
-						compilation.runtimeTemplate.supportsAnalyzable("wasm-relative");
+					const analyzable = compilation.runtimeTemplate.supportsAnalyzable(
+						"wasm-relative",
+						chunkGraph
+					);
 					// A baked URL carries the public path already, and a settled one is written
 					// out below; only a path nothing but the global knows asks for it.
 					const constant =
@@ -151,12 +153,14 @@ class FetchCompileAsyncWasmPlugin {
 					}
 					const baked = compilation.runtimeTemplate.supportsAnalyzable(
 						"wasm",
-						undefined,
+						chunkGraph,
 						undefined,
 						chunk.runtime
 					);
-					const analyzable =
-						compilation.runtimeTemplate.supportsAnalyzable("wasm-relative");
+					const analyzable = compilation.runtimeTemplate.supportsAnalyzable(
+						"wasm-relative",
+						chunkGraph
+					);
 					// A baked URL carries the public path already, and a settled one is written
 					// out below; only a path nothing but the global knows asks for it.
 					const constant =

package/lib/web/FetchCompileWasmPlugin.js

@@ -99,8 +99,10 @@ class FetchCompileWasmPlugin {
 						return;
 					}
 					set.add(RuntimeGlobals.moduleCache);
-					const analyzable =
-						compilation.runtimeTemplate.supportsAnalyzable("wasm-relative");
+					const analyzable = compilation.runtimeTemplate.supportsAnalyzable(
+						"wasm-relative",
+						chunkGraph
+					);
 					const constant = analyzable
 						? undefined
 						: compilation.runtimeTemplate.constantPublicPath();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@depup/webpack",
-  "version": "5.110.1-depup.0",
+  "version": "5.110.3-depup.0",
   "description": "Packs ECMAScript/CommonJs/AMD modules for the browser. Allows you to split your codebase into multiple bundles, which can be loaded on demand. Supports loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff. (with updated dependencies)",
   "homepage": "https://github.com/webpack/webpack",
   "bugs": "https://github.com/webpack/webpack/issues",
@@ -109,14 +109,14 @@
     "@webassemblyjs/wasm-edit": "^1.14.1",
     "@webassemblyjs/wasm-parser": "^1.14.1",
     "acorn": "^8.18.0",
-    "browserslist": "^4.28.8",
+    "browserslist": "^4.28.9",
     "chrome-trace-event": "^1.0.4",
     "enhanced-resolve": "^5.24.5",
     "es-module-lexer": "^2.3.2",
     "events": "^3.3.0",
     "graceful-fs": "^4.2.11",
     "mime-db": "^1.54.0",
-    "minimizer-webpack-plugin": "^5.8.0",
+    "minimizer-webpack-plugin": "^5.9.0",
     "neo-async": "^2.6.2",
     "schema-utils": "^4.3.3",
     "tapable": "^2.3.3",
@@ -249,7 +249,7 @@
       },
       "browserslist": {
         "from": "^4.28.1",
-        "to": "^4.28.8"
+        "to": "^4.28.9"
       },
       "chrome-trace-event": {
         "from": "^1.0.2",
@@ -269,7 +269,7 @@
       },
       "minimizer-webpack-plugin": {
         "from": "^5.7.0",
-        "to": "^5.8.0"
+        "to": "^5.9.0"
       },
       "tapable": {
         "from": "^2.3.0",
@@ -278,8 +278,8 @@
     },
     "depsUpdated": 9,
     "originalPackage": "webpack",
-    "originalVersion": "5.110.1",
-    "processedAt": "2026-08-30T01:01:33.378Z",
+    "originalVersion": "5.110.3",
+    "processedAt": "2026-09-06T01:01:07.553Z",
     "smokeTest": "passed"
   }
 }