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

package/lib/dependencies/URLDependency.js

@@ -17,18 +17,25 @@ const {
 const { toJsStringLiteral } = require("../util/identifier");
 const makeSerializable = require("../util/makeSerializable");
 const memoize = require("../util/memoize");
+const {
+	PUBLIC_PATH_AUTO,
+	PUBLIC_PATH_FULL_HASH
+} = require("../util/publicPathPlaceholder");
 const ModuleDependency = require("./ModuleDependency");
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").GetConditionFn} GetConditionFn */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../optimize/InnerGraph").UsedByExports} UsedByExports */
+/** @import { ReplaceSource } from "webpack-sources" */
+/**
+ * @import Dependency, {
+ * 	GetConditionFn,
+ * 	UpdateHashContext
+ * } from "../Dependency"
+ */
+/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
+/** @import Module from "../Module" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import Hash from "../util/Hash" */
+/** @import { Range } from "../javascript/JavascriptParser" */
+/** @import { UsedByExports } from "../optimize/InnerGraph" */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Range, boolean, UsedByExports | undefined, true | undefined, true | undefined, ("high" | "low" | "auto" | undefined), string | undefined, string | undefined, string | undefined]>} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[Range, boolean, UsedByExports | undefined, true | undefined, true | undefined, ("high" | "low" | "auto" | undefined), string | undefined, string | undefined, string | undefined]>} ObjectSerializerContext */
 
@@ -57,41 +64,46 @@ const getAnalyzableUrlSpecifier = (dep, templateContext) => {
 		return null;
 	}
 	const urlData = codeGenerationResults.getData(assetModule, runtime, "url");
-	if (!urlData) return null;
-
-	const jsUrl = urlData[JAVASCRIPT_TYPE];
-	if (typeof jsUrl === "string") {
-		// The asset concatenates the runtime publicPath; rebuild a literal from the
-		// resolved filename. The base is the consuming chunk (`import.meta.url`).
-		if (jsUrl.includes(RuntimeGlobals.require)) {
-			const filename = codeGenerationResults.getData(
-				assetModule,
-				runtime,
-				"filename"
-			);
-			if (typeof filename !== "string") return null;
-			const { publicPath } = runtimeTemplate.outputOptions;
-			if (publicPath === "auto") {
-				const undo = runtimeTemplate._getModuleUndoPath(
-					consumingModule,
-					chunkGraph
-				);
-				return undo === null ? null : toJsStringLiteral(undo + filename);
-			}
-			if (typeof publicPath === "string" && !publicPath.includes("[")) {
-				return toJsStringLiteral(publicPath + filename);
-			}
-			return null;
-		}
+	const jsUrl = urlData && urlData[JAVASCRIPT_TYPE];
+	if (
+		typeof jsUrl === "string" &&
+		!jsUrl.includes(RuntimeGlobals.require) &&
+		// An analyzable wrapper is an expression, not a value — quoting it would nest
+		// one `new URL(…)` inside another. Its own literal is rebuilt below instead.
+		!jsUrl.includes(runtimeTemplate.outputOptions.importMetaName)
+	) {
 		// An already-quoted literal (generator `publicPath` / data: url) is used as-is;
 		// a raw value (external asset) is normalized to a quoted string.
 		return jsUrl.startsWith('"') ? jsUrl : toJsStringLiteral(jsUrl);
 	}
-
-	// Wrapper dropped: the asset is consumed as `asset-url` (absolute publicPath),
-	// so its resolved url is already a chunk-independent literal.
-	const assetUrl = urlData[ASSET_URL_TYPE];
-	return typeof assetUrl === "string" ? toJsStringLiteral(assetUrl) : null;
+	if (urlData && jsUrl === undefined) {
+		// Wrapper dropped for an `asset-url` consumer: an absolute public path resolves
+		// the same url from every chunk, so it is already a literal.
+		const assetUrl = urlData[ASSET_URL_TYPE];
+		// A css or html consumer drops the wrapper too, and its value carries a
+		// placeholder only those assets are rendered with — so use the name below.
+		if (
+			typeof assetUrl === "string" &&
+			!assetUrl.includes(PUBLIC_PATH_AUTO) &&
+			!assetUrl.includes(PUBLIC_PATH_FULL_HASH)
+		) {
+			return toJsStringLiteral(assetUrl);
+		}
+	}
+	// The wrapper concatenates the runtime public path, or was dropped as unread —
+	// either way the name is what the literal is built from.
+	const filename = codeGenerationResults.getData(
+		assetModule,
+		runtime,
+		"filename"
+	);
+	if (typeof filename !== "string") return null;
+	return runtimeTemplate.getAnalyzableAssetUrl(
+		consumingModule,
+		chunkGraph,
+		filename,
+		runtime
+	);
 };
 
 class URLDependency extends ModuleDependency {
@@ -124,6 +136,32 @@ class URLDependency extends ModuleDependency {
 		this.mediaAttribute = undefined;
 	}
 
+	/**
+	 * Updates the hash with the data contributed by this instance.
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		super.updateHash(hash, context);
+		const { runtimeTemplate, runtime } = context;
+		// Only a baked url reads the base; the runtime form is the same text under every
+		// base, so hashing one there would cost the code generation cache for nothing.
+		if (
+			runtimeTemplate === undefined ||
+			this.relative ||
+			!runtimeTemplate.analyzableUrlReadsBaseUri()
+		) {
+			return;
+		}
+		const base = runtimeTemplate.entryBaseUri(runtime);
+		// Disagreeing entries keep the runtime form, different code again from the
+		// base-less literal `undefined` bakes; an empty base must differ from both.
+		if (base === null) hash.update("|");
+		// Left out entirely where no entry sets one, so ordinary builds hash as before.
+		else if (typeof base === "string") hash.update(`=${base}`);
+	}
+
 	get type() {
 		return "new URL()";
 	}
@@ -210,6 +248,7 @@ URLDependency.Template = class URLDependencyTemplate extends (
 			moduleGraph,
 			runtimeRequirements,
 			runtimeTemplate,
+			codeGenerationResults,
 			runtime
 		} = templateContext;
 		const dep = /** @type {URLDependency} */ (dependency);
@@ -226,13 +265,16 @@ URLDependency.Template = class URLDependencyTemplate extends (
 
 		// For ESM module output, emit the analyzable `new URL("./asset", import.meta.url)`
 		// form (literal specifier, no runtime helpers) so other bundlers and webpack itself
-		// can statically follow the asset. `url: "relative"` and prefetch/preload hints
-		// (which need the runtime asset reference) keep the runtime form.
+		// can statically follow the asset. `url: "relative"` keeps the runtime form.
+		// A prefetch/preload hint doesn't force it: the `<link>` is emitted separately at
+		// chunk startup (`StartupAssetHintRuntimeModule`), independent of the call site.
 		if (
 			!dep.relative &&
-			!dep.prefetch &&
-			!dep.preload &&
-			runtimeTemplate.supportsAnalyzableEsm()
+			runtimeTemplate.supportsAnalyzable(
+				"url",
+				chunkGraph,
+				templateContext.module
+			)
 		) {
 			const specifier = getAnalyzableUrlSpecifier(dep, templateContext);
 			if (specifier !== null) {
@@ -245,25 +287,29 @@ URLDependency.Template = class URLDependencyTemplate extends (
 			}
 		}
 
-		runtimeRequirements.add(RuntimeGlobals.require);
-
 		const module = moduleGraph.getModule(dep);
-		const moduleRaw = runtimeTemplate.moduleRaw({
-			chunkGraph,
-			module,
-			request: dep.request,
-			runtimeRequirements,
-			weak: false
-		});
-
-		// Resource hints fire eagerly at chunk startup via the marker
-		// requirement / `StartupAssetHintRuntimeModule`; the call site stays
-		// a plain URL expression, so the browser is already prefetching by
-		// the time user code reaches this line.
-		if (dep.prefetch || dep.preload) {
-			runtimeRequirements.add(RuntimeGlobals.startupAssetHints);
-			if (dep.prefetch) runtimeRequirements.add(RuntimeGlobals.prefetchAsset);
-			if (dep.preload) runtimeRequirements.add(RuntimeGlobals.preloadAsset);
+		// A wrapper-less asset has no exports to require, so concatenate what the wrapper
+		// would have — `AssetModulesPlugin` emulates the same for build-time execution.
+		const wrapperLess =
+			module !== null && !module.getSourceTypes().has(JAVASCRIPT_TYPE);
+		const filename =
+			wrapperLess && codeGenerationResults.has(module, runtime)
+				? codeGenerationResults.getData(module, runtime, "filename")
+				: undefined;
+		let moduleRaw;
+		if (wrapperLess && typeof filename === "string") {
+			runtimeRequirements.add(RuntimeGlobals.publicPath);
+			moduleRaw = `${RuntimeGlobals.publicPath} + ${toJsStringLiteral(filename)}`;
+		} else {
+			runtimeRequirements.add(RuntimeGlobals.require);
+			if (wrapperLess) runtimeRequirements.add(RuntimeGlobals.publicPath);
+			moduleRaw = runtimeTemplate.moduleRaw({
+				chunkGraph,
+				module,
+				request: dep.request,
+				runtimeRequirements,
+				weak: false
+			});
 		}
 
 		if (dep.relative) {

package/lib/dependencies/URLPlugin.js

@@ -14,9 +14,13 @@ const URLContextDependency = require("../dependencies/URLContextDependency");
 const URLDependency = require("../dependencies/URLDependency");
 const URLParserPlugin = require("../url/URLParserPlugin");
 
-/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/**
+ * @import {
+ * 	JavascriptParserOptions
+ * } from "../../declarations/WebpackOptions"
+ */
+/** @import Compiler from "../Compiler" */
+/** @import JavascriptParser from "../javascript/JavascriptParser" */
 
 const PLUGIN_NAME = "URLPlugin";
 

package/lib/dependencies/UnsupportedDependency.js

@@ -8,10 +8,10 @@
 const makeSerializable = require("../util/makeSerializable");
 const NullDependency = require("./NullDependency");
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @import { ReplaceSource } from "webpack-sources" */
+/** @import Dependency from "../Dependency" */
+/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
+/** @import { Range } from "../javascript/JavascriptParser" */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[string, Range]>} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[string, Range]>} ObjectSerializerContext */
 

package/lib/dependencies/WebAssemblyExportImportedDependency.js

@@ -9,12 +9,11 @@ const Dependency = require("../Dependency");
 const makeSerializable = require("../util/makeSerializable");
 const ModuleDependency = require("./ModuleDependency");
 
-/** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
-/** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @import { ReferencedExports, TRANSITIVE } from "../Dependency" */
+/** @import ModuleGraph from "../ModuleGraph" */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[string, string, string]>} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[string, string, string]>} ObjectSerializerContext */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @import { RuntimeSpec } from "../util/runtime" */
 
 class WebAssemblyExportImportedDependency extends ModuleDependency {
 	/**

package/lib/dependencies/WebAssemblyImportDependency.js

@@ -9,13 +9,13 @@ const makeSerializable = require("../util/makeSerializable");
 const UnsupportedWebAssemblyFeatureError = require("../wasm-sync/UnsupportedWebAssemblyFeatureError");
 const ModuleDependency = require("./ModuleDependency");
 
-/** @typedef {import("@webassemblyjs/ast").ModuleImportDescription} ModuleImportDescription */
-/** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../errors/WebpackError")} WebpackError */
+/** @import { ModuleImportDescription } from "@webassemblyjs/ast" */
+/** @import { ReferencedExports } from "../Dependency" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import WebpackError from "../errors/WebpackError" */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[string, ModuleImportDescription, false | string]>} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[string, ModuleImportDescription, false | string]>} ObjectSerializerContext */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @import { RuntimeSpec } from "../util/runtime" */
 
 class WebAssemblyImportDependency extends ModuleDependency {
 	/**

package/lib/dependencies/WebpackIsIncludedDependency.js

@@ -10,12 +10,12 @@ const Template = require("../Template");
 const makeSerializable = require("../util/makeSerializable");
 const ModuleDependency = require("./ModuleDependency");
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @import { ReplaceSource } from "webpack-sources" */
+/** @import { ReferencedExports } from "../Dependency" */
+/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import { Range } from "../javascript/JavascriptParser" */
+/** @import { RuntimeSpec } from "../util/runtime" */
 
 class WebpackIsIncludedDependency extends ModuleDependency {
 	/**

package/lib/dependencies/WorkerAndWorkletPlugin.js

@@ -11,13 +11,12 @@ const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
 	JAVASCRIPT_MODULE_TYPE_ESM
 } = require("../ModuleTypeConstants");
-const CommentCompilationWarning = require("../errors/CommentCompilationWarning");
-const UnsupportedFeatureWarning = require("../errors/UnsupportedFeatureWarning");
 const EnableChunkLoadingPlugin = require("../javascript/EnableChunkLoadingPlugin");
 const parseResourceHintOptions = require("../prefetch/parseResourceHintOptions");
 const { equals } = require("../util/ArrayHelpers");
 const createHash = require("../util/createHash");
 const { contextify } = require("../util/identifier");
+const memoize = require("../util/memoize");
 const EnableWasmLoadingPlugin = require("../wasm/EnableWasmLoadingPlugin");
 const ConstDependency = require("./ConstDependency");
 const CreateScriptUrlDependency = require("./CreateScriptUrlDependency");
@@ -28,28 +27,47 @@ const { isImportMetaFieldEnabled } = require("./ImportMetaPlugin");
 const WorkerDependency = require("./WorkerDependency");
 const WorkletDependency = require("./WorkletDependency");
 
-/** @typedef {import("estree").CallExpression} CallExpression */
-/** @typedef {import("estree").Expression} Expression */
-/** @typedef {import("estree").MemberExpression} MemberExpression */
-/** @typedef {import("estree").ObjectExpression} ObjectExpression */
-/** @typedef {import("estree").Pattern} Pattern */
-/** @typedef {import("estree").Property} Property */
-/** @typedef {import("estree").SpreadElement} SpreadElement */
-/** @typedef {import("../../declarations/WebpackOptions").ChunkLoading} ChunkLoading */
-/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
-/** @typedef {import("../../declarations/WebpackOptions").OutputModule} OutputModule */
-/** @typedef {import("../../declarations/WebpackOptions").WasmLoading} WasmLoading */
-/** @typedef {import("../../declarations/WebpackOptions").WorkerPublicPath} WorkerPublicPath */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("../Entrypoint").EntryOptions} EntryOptions */
-/** @typedef {import("../NormalModule")} NormalModule */
-/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
-/** @typedef {import("../javascript/JavascriptParser")} Parser */
-/** @typedef {import("../javascript/JavascriptParser").JavascriptParserState} JavascriptParserState */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("./HarmonyImportDependencyParserPlugin").HarmonySettings} HarmonySettings */
-/** @typedef {import("./WorkerDependency").ResourceHint} ResourceHint */
+const getUnsupportedFeatureWarning = memoize(() =>
+	require("../errors/UnsupportedFeatureWarning")
+);
+
+const getCommentCompilationWarning = memoize(() =>
+	require("../errors/CommentCompilationWarning")
+);
+
+/**
+ * @import {
+ * 	CallExpression,
+ * 	Expression,
+ * 	MemberExpression,
+ * 	ObjectExpression,
+ * 	Pattern,
+ * 	Property,
+ * 	SpreadElement
+ * } from "estree"
+ */
+/**
+ * @import {
+ * 	ChunkLoading,
+ * 	JavascriptParserOptions,
+ * 	OutputModule,
+ * 	WasmLoading,
+ * 	WorkerPublicPath
+ * } from "../../declarations/WebpackOptions"
+ */
+/** @import Compiler from "../Compiler" */
+/** @import { DependencyLocation } from "../Dependency" */
+/** @import { EntryOptions } from "../Entrypoint" */
+/** @import NormalModule from "../NormalModule" */
+/**
+ * @import JavascriptParser, {
+ * 	JavascriptParserState,
+ * 	Range
+ * } from "../javascript/JavascriptParser"
+ */
+/** @import Parser from "../javascript/JavascriptParser" */
+/** @import { HarmonySettings } from "./HarmonyImportDependencyParserPlugin" */
+/** @import { ResourceHint } from "./WorkerDependency" */
 
 /**
  * Returns url.
@@ -352,7 +370,7 @@ class WorkerAndWorkletPlugin {
 							for (const e of commentErrors) {
 								const { comment } = e;
 								parser.state.module.addWarning(
-									new CommentCompilationWarning(
+									new (getCommentCompilationWarning())(
 										`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
 										parser.getLocation(comment)
 									)
@@ -367,7 +385,7 @@ class WorkerAndWorkletPlugin {
 							if (importOptions.webpackIgnore !== undefined) {
 								if (typeof importOptions.webpackIgnore !== "boolean") {
 									parser.state.module.addWarning(
-										new UnsupportedFeatureWarning(
+										new (getUnsupportedFeatureWarning())(
 											`\`webpackIgnore\` expected a boolean, but received: ${importOptions.webpackIgnore}.`,
 											parser.getLocation(expr)
 										)
@@ -382,7 +400,7 @@ class WorkerAndWorkletPlugin {
 									importOptions.webpackEntryOptions === null
 								) {
 									parser.state.module.addWarning(
-										new UnsupportedFeatureWarning(
+										new (getUnsupportedFeatureWarning())(
 											`\`webpackEntryOptions\` expected a object, but received: ${importOptions.webpackEntryOptions}.`,
 											parser.getLocation(expr)
 										)
@@ -411,7 +429,7 @@ class WorkerAndWorkletPlugin {
 							if (importOptions.webpackChunkName !== undefined) {
 								if (typeof importOptions.webpackChunkName !== "string") {
 									parser.state.module.addWarning(
-										new UnsupportedFeatureWarning(
+										new (getUnsupportedFeatureWarning())(
 											`\`webpackChunkName\` expected a string, but received: ${importOptions.webpackChunkName}.`,
 											parser.getLocation(expr)
 										)
@@ -735,6 +753,7 @@ class WorkerAndWorkletPlugin {
 										) {
 											return;
 										}
+										settings.used = true;
 										return handle(expr);
 									});
 							} else {

package/lib/dependencies/WorkerDependency.js

@@ -10,19 +10,17 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const makeSerializable = require("../util/makeSerializable");
 const ModuleDependency = require("./ModuleDependency");
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../AsyncDependenciesBlock")} AsyncDependenciesBlock */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../Entrypoint")} Entrypoint */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @import { ReplaceSource } from "webpack-sources" */
+/** @import AsyncDependenciesBlock from "../AsyncDependenciesBlock" */
+/** @import { ReferencedExports, UpdateHashContext } from "../Dependency" */
+/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
+/** @import Entrypoint from "../Entrypoint" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import { Range } from "../javascript/JavascriptParser" */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[WorkerDependencyOptions]>} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[WorkerDependencyOptions]>} ObjectSerializerContext */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @import Hash from "../util/Hash" */
+/** @import { RuntimeSpec } from "../util/runtime" */
 
 /**
  * @typedef {object} ResourceHint
@@ -135,19 +133,21 @@ WorkerDependency.Template = class WorkerDependencyTemplate extends (
 
 		// For ESM module output emit the analyzable `new URL("./worker.<name>.js",
 		// import.meta.url)` form (literal specifier, no runtime helpers) so other bundlers
-		// and webpack itself can statically follow the worker. Resource-hint workers keep
-		// the runtime form because the hint needs the runtime chunk reference.
-		const analyzableSpecifier =
-			!dep.options.resourceHint && runtimeTemplate.supportsAnalyzableEsm()
-				? runtimeTemplate._getAnalyzableChunkSpecifier(
-						dep.options.publicPath,
-						chunk,
-						templateContext.module,
-						chunkGraph
-					)
-				: null;
+		// and webpack itself can statically follow the worker. A resource hint doesn't
+		// block it: the `<link>` is emitted at chunk startup instead of wrapping the href,
+		// which would turn the specifier into a non-analyzable expression.
+		const analyzableSpecifier = runtimeTemplate.getAnalyzableWorkerUrl(
+			dep.options.publicPath,
+			chunk,
+			templateContext.module,
+			chunkGraph,
+			runtimeRequirements
+		);
 
 		if (analyzableSpecifier !== null) {
+			// No `<link>` helper is asked for here: this form emits no call, and
+			// `ResourceHintPlugin` — which spells the one that fires at startup —
+			// declares what that one reads while requirements are still open.
 			const urlArgs = `/* worker import */ ${analyzableSpecifier}, ${runtimeTemplate.outputOptions.importMetaName}.url`;
 			source.replace(
 				dep.range[0],

package/lib/dependencies/WorkletDependency.js

@@ -11,19 +11,17 @@ const Template = require("../Template");
 const makeSerializable = require("../util/makeSerializable");
 const ModuleDependency = require("./ModuleDependency");
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../AsyncDependenciesBlock")} AsyncDependenciesBlock */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../Entrypoint")} Entrypoint */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @import { ReplaceSource } from "webpack-sources" */
+/** @import AsyncDependenciesBlock from "../AsyncDependenciesBlock" */
+/** @import { ReferencedExports, UpdateHashContext } from "../Dependency" */
+/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
+/** @import Entrypoint from "../Entrypoint" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import { Range } from "../javascript/JavascriptParser" */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[WorkletDependencyOptions, Range]>} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[WorkletDependencyOptions, Range]>} ObjectSerializerContext */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @import Hash from "../util/Hash" */
+/** @import { RuntimeSpec } from "../util/runtime" */
 
 /**
  * @typedef {object} WorkletDependencyOptions
@@ -142,15 +140,13 @@ WorkletDependency.Template = class WorkletDependencyTemplate extends (
 		// import.meta.url)` form (literal specifier, no runtime helpers) so other bundlers
 		// and webpack itself can statically follow the worklet. The worklet chunk links its
 		// splits via native `import`, so only the entry chunk is referenced.
-		const analyzableSpecifier =
-			runtimeTemplate.supportsAnalyzableEsm() && entryChunk.id !== null
-				? runtimeTemplate._getAnalyzableChunkSpecifier(
-						dep.options.publicPath,
-						entryChunk,
-						module,
-						chunkGraph
-					)
-				: null;
+		const analyzableSpecifier = runtimeTemplate.getAnalyzableWorkerUrl(
+			dep.options.publicPath,
+			entryChunk,
+			module,
+			chunkGraph,
+			runtimeRequirements
+		);
 		if (analyzableSpecifier !== null) {
 			source.replace(
 				dep.callRange[0],
@@ -274,5 +270,6 @@ makeSerializable(
 	"webpack/lib/dependencies/WorkletDependency"
 );
 
+WorkletDependency.WORKLET_MODULE = WORKLET_MODULE;
+
 module.exports = WorkletDependency;
-module.exports.WORKLET_MODULE = WORKLET_MODULE;

package/lib/dependencies/getFunctionExpression.js

@@ -5,10 +5,14 @@
 
 "use strict";
 
-/** @typedef {import("estree").ArrowFunctionExpression} ArrowFunctionExpression */
-/** @typedef {import("estree").Expression} Expression */
-/** @typedef {import("estree").FunctionExpression} FunctionExpression */
-/** @typedef {import("estree").SpreadElement} SpreadElement */
+/**
+ * @import {
+ * 	ArrowFunctionExpression,
+ * 	Expression,
+ * 	FunctionExpression,
+ * 	SpreadElement
+ * } from "estree"
+ */
 
 /** @typedef {{ fn: FunctionExpression | ArrowFunctionExpression, expressions: (Expression | SpreadElement)[], needThis: boolean | undefined }} FunctionExpressionResult */
 

package/lib/dependencies/importOptionsCheck.js

@@ -0,0 +1,47 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const Template = require("../Template");
+
+/** @import RuntimeTemplate from "../RuntimeTemplate" */
+
+/**
+ * Wraps an import so its arguments evaluate in source order and the options are
+ * checked, rejecting rather than throwing. The last parameter holds them.
+ * @param {RuntimeTemplate} runtimeTemplate the runtime template
+ * @param {string[]} parameters parameter names, the options one last
+ * @param {string} content the import expression to return once the check passes
+ * @returns {string} the wrapping function
+ */
+const importOptionsCheck = (runtimeTemplate, parameters, content) => {
+	const options = parameters[parameters.length - 1];
+	return runtimeTemplate.basicFunction(parameters.join(", "), [
+		"try {",
+		Template.indent([
+			`if (${options} !== undefined) {`,
+			Template.indent([
+				`if ((typeof ${options} !== "object" && typeof ${options} !== "function") || ${options} === null) throw new TypeError("The second argument to import() must be an object");`,
+				`var a = ${options}["with"];`,
+				"if (a !== undefined) {",
+				Template.indent([
+					'if ((typeof a !== "object" && typeof a !== "function") || a === null) throw new TypeError("The \'with\' option must be an object");',
+					"for (var k = Object.keys(a), i = 0; i < k.length; i++) {",
+					Template.indent([
+						'if (typeof a[k[i]] !== "string") throw new TypeError("Import attribute values must be strings");'
+					]),
+					"}"
+				]),
+				"}"
+			]),
+			"}"
+		]),
+		"} catch (e) { return Promise.reject(e); }",
+		`return ${content};`
+	]);
+};
+
+module.exports = importOptionsCheck;