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

package/lib/javascript/JavascriptModulesPlugin.js

@@ -50,7 +50,7 @@ const {
 const createHash = require("../util/createHash");
 const createHooksRegistry = require("../util/createHooksRegistry");
 const { digestNonNumericOnlyWithFull } = require("../util/nonNumericOnlyHash");
-const removeBOM = require("../util/removeBOM");
+const { removeBOMFromResult } = require("../util/removeBOM");
 const { intersectRuntime } = require("../util/runtime");
 const { getAllChunks } = require("./ChunkHelpers");
 const JavascriptGenerator = require("./JavascriptGenerator");
@@ -528,15 +528,8 @@ class JavascriptModulesPlugin {
 
 					NormalModule.getCompilationHooks(compilation).processResult.tap(
 						PLUGIN_NAME,
-						(result, module) => {
-							if (module.type === type) {
-								const [source, ...rest] = result;
-
-								return [removeBOM(source), ...rest];
-							}
-
-							return result;
-						}
+						(result, module) =>
+							module.type === type ? removeBOMFromResult(result) : result
 					);
 				}
 
@@ -1687,6 +1680,8 @@ class JavascriptModulesPlugin {
 						continue;
 					}
 				}
+				// An async entry is not awaited here: that needs top-level `await`,
+				// gated on an option held back from the patch release (revert #21881).
 				let i = jsEntries.length;
 				for (const [entryModule, entrypoint] of jsEntries) {
 					const chunks =

package/lib/loaders/LoaderRunner.js

@@ -7,6 +7,7 @@
 
 const { readFile } = require("fs");
 const { parseResource } = require("../util/identifier");
+const { adjustSourceMapForRemovedBOM } = require("../util/removeBOM");
 const loadLoader = require("./loadLoader");
 
 // Set on a loader context to have each loader's own run measured. Absent
@@ -59,6 +60,8 @@ const HASH_ESCAPE_REGEXP = /#/g;
 const UTF8_BOM_0 = 0xef;
 const UTF8_BOM_1 = 0xbb;
 const UTF8_BOM_2 = 0xbf;
+// U+FEFF, the BOM once decoded
+const BOM_CHAR_CODE = 0xfeff;
 
 /**
  * @param {Buffer} buf buffer
@@ -76,6 +79,14 @@ function utf8BufferToString(buf) {
 	return buf.toString("utf8");
 }
 
+/**
+ * @param {string} str string
+ * @returns {string} string, with a leading BOM removed
+ */
+function stringWithoutBOM(str) {
+	return str.charCodeAt(0) === BOM_CHAR_CODE ? str.slice(1) : str;
+}
+
 /**
  * Escape `#` with a preceding `\0` byte; short-circuits when there is no `#`.
  * @param {string} str input string
@@ -292,9 +303,19 @@ function runSyncOrAsync(fn, context, args, callback) {
 /**
  * @param {EXPECTED_ANY[]} args arguments
  * @param {boolean | null=} raw whether the loader wants a Buffer
+ * @param {boolean=} fromLoader whether args came from a loader rather than the resource
  * @returns {void}
  */
-function convertArgs(args, raw) {
+function convertArgs(args, raw, fromLoader) {
+	// A BOM only means anything at the start of a file, so one a loader produced
+	// is content the next loader must not see. The resource keeps its own.
+	if (fromLoader && typeof args[0] === "string") {
+		const withoutBOM = stringWithoutBOM(args[0]);
+		if (withoutBOM !== args[0]) {
+			args[0] = withoutBOM;
+			if (args[1]) args[1] = adjustSourceMapForRemovedBOM(args[1]);
+		}
+	}
 	if (!raw && Buffer.isBuffer(args[0])) {
 		args[0] = utf8BufferToString(args[0]);
 	} else if (raw && typeof args[0] === "string") {
@@ -307,9 +328,16 @@ function convertArgs(args, raw) {
  * @param {LoaderContext} loaderContext the loader context
  * @param {EXPECTED_ANY[]} args arguments
  * @param {(err: Error | null, args?: EXPECTED_ANY[]) => void} callback callback
+ * @param {boolean=} fromLoader whether args came from a loader rather than the resource
  * @returns {void}
  */
-function iterateNormalLoaders(options, loaderContext, args, callback) {
+function iterateNormalLoaders(
+	options,
+	loaderContext,
+	args,
+	callback,
+	fromLoader
+) {
 	while (loaderContext.loaderIndex >= 0) {
 		const currentLoaderObject =
 			loaderContext.loaders[loaderContext.loaderIndex];
@@ -327,11 +355,11 @@ function iterateNormalLoaders(options, loaderContext, args, callback) {
 			continue;
 		}
 
-		convertArgs(args, currentLoaderObject.raw);
+		convertArgs(args, currentLoaderObject.raw, fromLoader);
 
 		return runSyncOrAsync(fn, loaderContext, args, (err, ...nextArgs) => {
 			if (err) return callback(err);
-			iterateNormalLoaders(options, loaderContext, nextArgs, callback);
+			iterateNormalLoaders(options, loaderContext, nextArgs, callback, true);
 		});
 	}
 
@@ -410,7 +438,7 @@ function iteratePitchingLoaders(options, loaderContext, callback) {
 					}
 					if (hasArg) {
 						loaderContext.loaderIndex--;
-						iterateNormalLoaders(options, loaderContext, args, callback);
+						iterateNormalLoaders(options, loaderContext, args, callback, true);
 					} else {
 						iteratePitchingLoaders(options, loaderContext, callback);
 					}

package/lib/node/ReadFileCompileAsyncWasmPlugin.js

@@ -62,27 +62,20 @@ class ReadFileCompileAsyncWasmPlugin {
 			// settled while the plugin is being applied.
 			/**
 			 * @param {string} path rendered path to the wasm file
-			 * @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 = (path, runtime) =>
-				compilation.runtimeTemplate.supportsAnalyzable(
-					"wasm",
-					undefined,
-					undefined,
-					runtime
-				)
-					? path
-					: compilation.runtimeTemplate.importMetaUrl(path);
+			const wasmUrlArg = (path, analyzable) =>
+				analyzable ? path : compilation.runtimeTemplate.importMetaUrl(path);
 			/**
-			 * @type {(path: string, runtime: RuntimeSpec) => string} callback to generate code to load the wasm file
+			 * @type {(path: string, runtime: RuntimeSpec, analyzable: boolean) => string} callback to generate code to load the wasm file
 			 */
 			const generateLoadBinaryCode = this._import
-				? (path, runtime) =>
+				? (path, runtime, analyzable) =>
 						Template.asString([
 							"Promise.all([import('fs'), import('url')]).then(([{ readFile }, { URL }]) => new Promise((resolve, reject) => {",
 							Template.indent([
-								`readFile(${wasmUrlArg(path, runtime)}, (err, buffer) => {`,
+								`readFile(${wasmUrlArg(path, analyzable)}, (err, buffer) => {`,
 								Template.indent([
 									"if (err) return reject(err);",
 									"",
@@ -154,7 +147,7 @@ class ReadFileCompileAsyncWasmPlugin {
 					if (
 						!compilation.runtimeTemplate.supportsAnalyzable(
 							"wasm",
-							undefined,
+							chunkGraph,
 							undefined,
 							chunk.runtime
 						) &&
@@ -196,7 +189,7 @@ class ReadFileCompileAsyncWasmPlugin {
 					if (
 						!compilation.runtimeTemplate.supportsAnalyzable(
 							"wasm",
-							undefined,
+							chunkGraph,
 							undefined,
 							chunk.runtime
 						) &&

package/lib/optimize/ConcatenatedModule.js

@@ -181,6 +181,7 @@ const findIdentifiers = (source) => {
  * @property {string=} comment
  * @property {ExportName} ids
  * @property {ExportName} exportName
+ * @property {boolean=} accessorCall the raw name is the wrapper accessor call itself, so it binds looser than the identifier it replaces
  */
 
 /**
@@ -494,11 +495,14 @@ const getFinalBinding = (
 				/** @type {NonNullable<ConcatenatedModuleInfo["namespaceObjectName"]>} */
 				(info.namespaceObjectName),
 			ids: /** @type {ExportName} */ (usedName),
-			exportName
+			exportName,
+			accessorCall: info.wrapped
 		};
 	}
 
-	if (exportName.length === 0) {
+	if (moduleExportsAccess) {
+		// Skip ESM interop when require() targets a module outside the concatenation
+	} else if (exportName.length === 0) {
 		switch (exportsType) {
 			case "default-only":
 				if (deferred) info.deferredNamespaceObjectUsed = true;
@@ -509,7 +513,8 @@ const getFinalBinding = (
 						? /** @type {string} */ (info.deferredNamespaceObjectName)
 						: getInteropExpr(info, info.interopNamespaceObject2Name),
 					ids: exportName,
-					exportName
+					exportName,
+					accessorCall: !deferred && info.wrapped
 				};
 			case "default-with-named":
 				if (deferred) info.deferredNamespaceObjectUsed = true;
@@ -520,7 +525,8 @@ const getFinalBinding = (
 						? /** @type {string} */ (info.deferredNamespaceObjectName)
 						: getInteropExpr(info, info.interopNamespaceObjectName),
 					ids: exportName,
-					exportName
+					exportName,
+					accessorCall: !deferred && info.wrapped
 				};
 			case "namespace":
 			case "dynamic":
@@ -611,7 +617,8 @@ const getFinalBinding = (
 								info,
 								rawName: getExternalModuleExpr(info),
 								ids: exportName,
-								exportName
+								exportName,
+								accessorCall: info.wrapped
 							};
 						}
 						info.interopDefaultAccessUsed = true;
@@ -657,7 +664,8 @@ const getFinalBinding = (
 						/** @type {NonNullable<ConcatenatedModuleInfo["namespaceObjectName"]>} */
 						(info.namespaceObjectName),
 					ids: exportName,
-					exportName
+					exportName,
+					accessorCall: info.wrapped
 				};
 			case "external":
 				if (deferred) {
@@ -673,7 +681,8 @@ const getFinalBinding = (
 					info,
 					rawName: getExternalModuleExpr(info),
 					ids: exportName,
-					exportName
+					exportName,
+					accessorCall: info.wrapped
 				};
 		}
 	}
@@ -938,9 +947,13 @@ const getFinalName = (
 		let reference;
 		/** @type {boolean} */
 		let isPropertyAccess;
+		// the raw name is the wrapper accessor call itself, so the reference binds
+		// looser than the identifier it stands in for
+		let accessorCall = false;
 		if ("rawName" in binding) {
 			reference = `${binding.rawName}${comment || ""}${propertyAccess(ids)}`;
 			isPropertyAccess = ids.length > 0;
+			accessorCall = binding.accessorCall === true;
 		} else {
 			const { info, name: exportId } = binding;
 			const name = info.internalNames.get(exportId);
@@ -970,6 +983,10 @@ const getFinalName = (
 			} else if (binding.info.wrapped) {
 				return asiSafe === false ? `;(${reference})` : `(${reference})`;
 			}
+		} else if (accessorCall && !asCall) {
+			// without parentheses `new X()` would construct the accessor rather
+			// than what it returns
+			return asiSafe === false ? `;(${reference})` : `(${reference})`;
 		}
 
 		return reference;
@@ -1415,10 +1432,18 @@ class ConcatenatedModule extends Module {
 					runtimeCondition,
 					runtime
 				);
+				const wasDeferredOnly = !entry.nonDeferAccess;
 				entry.nonDeferAccess = mergeNonDeferAccess(
 					entry.nonDeferAccess,
 					nonDeferAccess
 				);
+				// A deferred import does not evaluate, so the first eager reference
+				// fixes the position; insertion order is emit order.
+				if (wasDeferredOnly && nonDeferAccess) {
+					entry.connection = connection;
+					referencesMap.delete(module);
+					referencesMap.set(module, entry);
+				}
 			}
 			if (targets !== undefined) importConnections.set(module, targets);
 			return referencesMap.values();
@@ -1841,6 +1866,13 @@ class ConcatenatedModule extends Module {
 					for (const reference of ConcatenationScope.findModuleReferences(
 						/** @type {Source} */ (info.internalSource)
 					)) {
+						if (reference.leaked) {
+							throw new Error(
+								`Unsubstituted module reference "${reference.name}" in ${info.module.readableIdentifier(
+									requestShortener
+								)}`
+							);
+						}
 						if (visitedReferences.has(reference.name)) continue;
 						visitedReferences.add(reference.name);
 						const match = ConcatenationScope.matchModuleReference(
@@ -1934,6 +1966,13 @@ class ConcatenatedModule extends Module {
 									ignoredScopes
 								);
 							} else {
+								if (ConcatenationScope.isLeakedModuleReference(name)) {
+									throw new Error(
+										`Unsubstituted module reference "${name}" in ${info.module.readableIdentifier(
+											requestShortener
+										)}`
+									);
+								}
 								allUsedNames.add(name);
 								freeNames.add(name);
 							}

package/lib/optimize/ConstExportsPlugin.js

@@ -15,6 +15,7 @@ const { VariableInfoFlags } = require("../javascript/JavascriptParser");
 const {
 	InlinedUsedName,
 	enableInlineExports,
+	findModulesInCycles,
 	toInlinedValue
 } = require("./InlineExports");
 
@@ -162,11 +163,15 @@ class ConstExportsPlugin {
 
 				const moduleGraph = compilation.moduleGraph;
 				compilation.hooks.optimizeDependencies.tap(PLUGIN_NAME, (modules) => {
+					// A cycle peer may read an export during its temporal dead zone,
+					// where the binding must throw and a literal would answer.
+					const inCycle = findModulesInCycles(moduleGraph, modules);
 					/** @type {Set<ExportsInfo>} */
 					const visited = new Set();
 					/** @type {ExportsInfo[]} */
 					let queue = [];
 					for (const module of modules) {
+						if (inCycle.has(module)) continue;
 						queue.push(moduleGraph.getExportsInfo(module));
 					}
 					while (queue.length > 0) {

package/lib/optimize/InlineExports.js

@@ -172,10 +172,131 @@ const isExportInlined = (moduleGraph, module, ids, runtime) => {
 	return moduleGraph.getExportsInfo(module).hasInlinedUsedName(ids, runtime);
 };
 
+/**
+ * Collects, by an iterative Tarjan pass, the modules a cycle peer may read in
+ * their dead zone. A cycle of bare side-effect imports still inlines.
+ * @param {ModuleGraph} moduleGraph module graph
+ * @param {Iterable<Module>} modules all modules of the compilation
+ * @returns {Set<Module>} modules whose exports must not be inlined
+ */
+const findModulesInCycles = (moduleGraph, modules) => {
+	const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency");
+	const HarmonyImportSideEffectDependency = require("../dependencies/HarmonyImportSideEffectDependency");
+
+	/** @type {Set<Module>} */
+	const inCycle = new Set();
+	/** @type {[Module, Module][]} */
+	const bindingReads = [];
+	/** @type {Map<Module, number>} */
+	const componentOf = new Map();
+	let nextComponent = 0;
+	/** @type {Map<Module, number>} */
+	const index = new Map();
+	/** @type {Map<Module, number>} */
+	const low = new Map();
+	/** @type {Set<Module>} */
+	const onStack = new Set();
+	/** @type {Module[]} */
+	const componentStack = [];
+	let counter = 0;
+	/**
+	 * @param {Module} module the module
+	 * @returns {Module[]} modules it imports, self included when self-importing
+	 */
+	const targetsOf = (module) => {
+		const connections = moduleGraph.getOutgoingConnectionsByModule(module);
+		if (!connections) return [];
+		/** @type {Module[]} */
+		const targets = [];
+		for (const [target, moduleConnections] of connections) {
+			if (
+				!target ||
+				!moduleConnections.some(
+					(c) => c.dependency instanceof HarmonyImportDependency
+				)
+			) {
+				continue;
+			}
+			// Anything but a bare side-effect import may observe the binding.
+			if (
+				moduleConnections.some(
+					(c) =>
+						c.dependency instanceof HarmonyImportDependency &&
+						!(c.dependency instanceof HarmonyImportSideEffectDependency)
+				)
+			) {
+				bindingReads.push([module, target]);
+			}
+			targets.push(target);
+		}
+		return targets;
+	};
+	/** @type {{ node: Module, targets: Module[], i: number }[]} */
+	const work = [];
+	/**
+	 * @param {Module} node node to open
+	 */
+	const open = (node) => {
+		index.set(node, counter);
+		low.set(node, counter);
+		counter++;
+		componentStack.push(node);
+		onStack.add(node);
+		work.push({ node, targets: targetsOf(node), i: 0 });
+	};
+	for (const seed of modules) {
+		if (index.has(seed)) continue;
+		open(seed);
+		while (work.length > 0) {
+			const frame = work[work.length - 1];
+			if (frame.i < frame.targets.length) {
+				const next = frame.targets[frame.i++];
+				if (!index.has(next)) {
+					open(next);
+				} else if (onStack.has(next)) {
+					const nodeLow = /** @type {number} */ (low.get(frame.node));
+					const nextIndex = /** @type {number} */ (index.get(next));
+					if (nextIndex < nodeLow) low.set(frame.node, nextIndex);
+				}
+				continue;
+			}
+			work.pop();
+			const node = frame.node;
+			const nodeLow = /** @type {number} */ (low.get(node));
+			if (work.length > 0) {
+				const parent = work[work.length - 1].node;
+				if (nodeLow < /** @type {number} */ (low.get(parent))) {
+					low.set(parent, nodeLow);
+				}
+			}
+			if (nodeLow === index.get(node)) {
+				const id = nextComponent++;
+				let member;
+				do {
+					member = /** @type {Module} */ (componentStack.pop());
+					onStack.delete(member);
+					componentOf.set(member, id);
+				} while (member !== node);
+			}
+		}
+	}
+	// Reader and target evaluate together exactly when they share a component.
+	for (const [origin, target] of bindingReads) {
+		if (
+			origin === target ||
+			componentOf.get(origin) === componentOf.get(target)
+		) {
+			inCycle.add(target);
+		}
+	}
+	return inCycle;
+};
+
 module.exports.InlinedUsedName = InlinedUsedName;
 module.exports.InlinedValue = InlinedValue;
 module.exports.MAX_INLINE_BYTES = MAX_INLINE_BYTES;
 module.exports.enableInlineExports = enableInlineExports;
+module.exports.findModulesInCycles = findModulesInCycles;
 module.exports.isExportInlined = isExportInlined;
 module.exports.isInlineEnabled = isInlineEnabled;
 module.exports.isInlineExportsEnabled = isInlineExportsEnabled;

package/lib/optimize/RealContentHashPlugin.js

@@ -345,47 +345,68 @@ ${referencingAssets
 						}
 						return hashes;
 					};
+					// Tarjan: hashes naming each other come out as one group where a chain
+					// walk would never end, and groups arrive dependencies-first as needed.
+					/** @type {string[][]} */
+					const groupsInOrder = [];
+					/** @type {Map<string, number>} */
+					const indexOf = new Map();
+					/** @type {Map<string, number>} */
+					const lowOf = new Map();
+					/** @type {Set<string>} */
+					const onStack = new Set();
+					/** @type {string[]} */
+					const stack = [];
 					/**
-					 * Returns the hash info.
+					 * Visits one hash and everything its assets reference.
 					 * @param {string} hash the hash
-					 * @returns {string} the hash info
+					 * @returns {void}
 					 */
-					const hashInfo = (hash) => {
-						const assets = hashToAssets.get(hash);
-						return `${hash} (${Array.from(
-							/** @type {AssetInfoForRealContentHash[]} */ (assets),
-							(a) => a.name
-						)})`;
-					};
-					/** @type {Hashes} */
-					const hashesInOrder = new Set();
-					for (const hash of hashToAssets.keys()) {
-						/**
-						 * Processes the provided hash.
-						 * @param {string} hash the hash
-						 * @param {Set<string>} stack stack of hashes
-						 */
-						const add = (hash, stack) => {
-							const deps = getDependencies(hash);
-							if (!deps) return;
-							stack.add(hash);
+					const strongConnect = (hash) => {
+						const index = indexOf.size;
+						indexOf.set(hash, index);
+						lowOf.set(hash, index);
+						stack.push(hash);
+						onStack.add(hash);
+						// An unowned reference reports the caching problem and stays a leaf.
+						const deps = getDependencies(hash);
+						if (deps) {
 							for (const dep of deps) {
-								if (hashesInOrder.has(dep)) continue;
-								if (stack.has(dep)) {
-									throw new Error(
-										`Circular hash dependency ${Array.from(
-											stack,
-											hashInfo
-										).join(" -> ")} -> ${hashInfo(dep)}`
+								if (!indexOf.has(dep)) {
+									strongConnect(dep);
+									lowOf.set(
+										hash,
+										Math.min(
+											/** @type {number} */ (lowOf.get(hash)),
+											/** @type {number} */ (lowOf.get(dep))
+										)
+									);
+								} else if (onStack.has(dep)) {
+									lowOf.set(
+										hash,
+										Math.min(
+											/** @type {number} */ (lowOf.get(hash)),
+											/** @type {number} */ (indexOf.get(dep))
+										)
 									);
 								}
-								add(dep, stack);
 							}
-							hashesInOrder.add(hash);
-							stack.delete(hash);
-						};
-						if (hashesInOrder.has(hash)) continue;
-						add(hash, new Set());
+						}
+						if (lowOf.get(hash) === indexOf.get(hash)) {
+							/** @type {string[]} */
+							const group = [];
+							/** @type {string} */
+							let member;
+							do {
+								member = /** @type {string} */ (stack.pop());
+								onStack.delete(member);
+								if (hashToAssets.has(member)) group.push(member);
+							} while (member !== hash);
+							if (group.length > 0) groupsInOrder.push(group);
+						}
+					};
+					for (const hash of hashToAssets.keys()) {
+						if (!indexOf.has(hash)) strongConnect(hash);
 					}
 					/** @type {Map<string, string>} */
 					const hashToNewHash = new Map();
@@ -474,7 +495,62 @@ ${referencingAssets
 					};
 					/** @type {Comparator<AssetInfoForRealContentHash>} */
 					const comparator = compareSelect((a) => a.name, compareStrings);
-					for (const oldHash of hashesInOrder) {
+					for (const group of groupsInOrder) {
+						// A cycle is assigned as one group: members are told apart by stable
+						// markers, so the group hashes to a fixed point instead of chasing one.
+						if (group.length > 1) {
+							const members = group.sort();
+							/** @type {Map<string, string>} */
+							const markerOf = new Map(
+								members.map((hash, i) => [hash, `|webpack/scc/${i}|`])
+							);
+							for (let i = 0; i < members.length; i++) {
+								const oldHash = members[i];
+								const memberAssets =
+									/** @type {AssetInfoForRealContentHash[]} */
+									(hashToAssets.get(oldHash));
+								memberAssets.sort(comparator);
+								const hash = createHash(this._hashFunction);
+								if (compilation.outputOptions.hashSalt) {
+									hash.update(compilation.outputOptions.hashSalt);
+								}
+								// Two members can normalize to the same text; the position keeps
+								// their hashes apart, and sorting keeps the position stable.
+								hash.update(`${i}`);
+								for (const asset of memberAssets) {
+									if (Buffer.isBuffer(asset.content)) {
+										hash.update(asset.content);
+										continue;
+									}
+									const withoutOwn =
+										/** @type {Hashes} */
+										(asset.ownHashes).has(oldHash);
+									hash.update(
+										asset.content.replace(hashRegExp, (matched) => {
+											// Its own occurrences vanish, exactly as a lone hash's do.
+											if (
+												withoutOwn &&
+												/** @type {Hashes} */ (asset.ownHashes).has(matched)
+											) {
+												return "";
+											}
+											const marker = markerOf.get(matched);
+											if (marker !== undefined) return marker;
+											const mapped = hashToNewHash.get(matched);
+											return mapped === undefined ? matched : mapped;
+										})
+									);
+								}
+								const digest = hash.digest(
+									/** @type {HashDigest} */ (
+										hashToDigest.get(oldHash) || this._hashDigest
+									)
+								);
+								hashToNewHash.set(oldHash, digest.slice(0, oldHash.length));
+							}
+							continue;
+						}
+						const oldHash = group[0];
 						const assets =
 							/** @type {AssetInfoForRealContentHash[]} */
 							(hashToAssets.get(oldHash));

package/lib/prefetch/ResourceHintPlugin.js

@@ -300,7 +300,12 @@ const collectEntrypointHints = (compilation, entryName, hints) => {
 	const out = [];
 	/** @type {Set<string>} */
 	const seenKeys = new Set();
-	const push = (/** @type {EntrypointHint} */ h) => {
+	/**
+	 * Appends a hint, dropping one already emitted for the same rel + href.
+	 * @param {EntrypointHint} h hint to append
+	 * @returns {void}
+	 */
+	const push = (h) => {
 		const key = `${h.rel}\0${h.href}`;
 		if (seenKeys.has(key)) return;
 		seenKeys.add(key);
@@ -481,19 +486,13 @@ const collectStartupAssetHintLines = (
 				seenWorkerChunks.add(workerChunk.id);
 				// The same specifier the `new Worker(...)` call site bakes, asked of the
 				// same module, so the two agree on whether a literal is spellable.
-				const specifier = runtimeTemplate.supportsAnalyzable(
-					"url",
+				const specifier = runtimeTemplate.getAnalyzableWorkerUrl(
+					dep.options.publicPath,
+					workerChunk,
+					module,
 					chunkGraph,
-					module
-				)
-					? runtimeTemplate._getAnalyzableChunkSpecifier(
-							dep.options.publicPath,
-							workerChunk,
-							module,
-							chunkGraph,
-							set
-						)
-					: null;
+					set
+				);
 				// Without one the call site keeps the runtime form, where it wraps its own
 				// href — firing the `<link>` here too would emit the call twice.
 				if (specifier === null) continue;