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

package/lib/rules/RuleSetCompiler.js

@@ -12,14 +12,17 @@ const { SyncHook } = require("tapable");
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetUseItem} RuleSetUseItem */
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetLoaderOptions} RuleSetLoaderOptions */
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetConditionAbsolute} RuleSetConditionAbsolute */
 
 /** @typedef {(Falsy | RuleSetRule)[]} RuleSetRules */
 
 /**
+ * Defines the rule condition function type used by this module.
  * @typedef {(value: EffectData[keyof EffectData]) => boolean} RuleConditionFunction
  */
 
 /**
+ * Defines the rule condition type used by this module.
  * @typedef {object} RuleCondition
  * @property {string | string[]} property
  * @property {boolean} matchWhenEmpty
@@ -27,12 +30,14 @@ const { SyncHook } = require("tapable");
  */
 
 /**
+ * Defines the condition type used by this module.
  * @typedef {object} Condition
  * @property {boolean} matchWhenEmpty
  * @property {RuleConditionFunction} fn
  */
 
 /**
+ * Defines the effect data type used by this module.
  * @typedef {object} EffectData
  * @property {string=} resource
  * @property {string=} realResource
@@ -50,6 +55,7 @@ const { SyncHook } = require("tapable");
  */
 
 /**
+ * Defines the compiled rule type used by this module.
  * @typedef {object} CompiledRule
  * @property {RuleCondition[]} conditions
  * @property {(Effect | ((effectData: EffectData) => Effect[]))[]} effects
@@ -60,12 +66,14 @@ const { SyncHook } = require("tapable");
 /** @typedef {"use" | "use-pre" | "use-post"} EffectUseType */
 
 /**
+ * Defines the effect use type used by this module.
  * @typedef {object} EffectUse
  * @property {EffectUseType} type
  * @property {{ loader: string, options?: string | null | Record<string, EXPECTED_ANY>, ident?: string }} value
  */
 
 /**
+ * Defines the effect basic type used by this module.
  * @typedef {object} EffectBasic
  * @property {string} type
  * @property {EXPECTED_ANY} value
@@ -76,12 +84,14 @@ const { SyncHook } = require("tapable");
 /** @typedef {Map<string, RuleSetLoaderOptions>} References */
 
 /**
+ * Defines the rule set type used by this module.
  * @typedef {object} RuleSet
  * @property {References} references map of references in the rule set (may grow over time)
  * @property {(effectData: EffectData) => Effect[]} exec execute the rule set
  */
 
 /**
+ * Defines the keys of types type used by this module.
  * @template T
  * @template {T[keyof T]} V
  * @typedef {({ [key in keyof Required<T>]: Required<T>[key] extends V ? key : never })[keyof T]} KeysOfTypes
@@ -96,6 +106,7 @@ const { SyncHook } = require("tapable");
 
 class RuleSetCompiler {
 	/**
+	 * Creates an instance of RuleSetCompiler.
 	 * @param {RuleSetPlugin[]} plugins plugins
 	 */
 	constructor(plugins) {
@@ -117,6 +128,7 @@ class RuleSetCompiler {
 	}
 
 	/**
+	 * Returns compiled RuleSet.
 	 * @param {RuleSetRules} ruleSet raw user provided rules
 	 * @returns {RuleSet} compiled RuleSet
 	 */
@@ -126,6 +138,7 @@ class RuleSetCompiler {
 		const rules = this.compileRules("ruleSet", ruleSet, refs);
 
 		/**
+		 * Returns true, if the rule has matched.
 		 * @param {EffectData} data data passed in
 		 * @param {CompiledRule} rule the compiled rule
 		 * @param {Effect[]} effects an array where effects are pushed to
@@ -203,6 +216,7 @@ class RuleSetCompiler {
 	}
 
 	/**
+	 * Returns rules.
 	 * @param {string} path current path
 	 * @param {RuleSetRules} rules the raw rules provided by user
 	 * @param {References} refs references
@@ -221,6 +235,7 @@ class RuleSetCompiler {
 	}
 
 	/**
+	 * Returns normalized and compiled rule for processing.
 	 * @param {string} path current path
 	 * @param {RuleSetRule} rule the raw rule provided by user
 	 * @param {References} refs references
@@ -274,6 +289,7 @@ class RuleSetCompiler {
 	}
 
 	/**
+	 * Returns compiled condition.
 	 * @param {string} path current path
 	 * @param {RuleSetLoaderOptions} condition user provided condition value
 	 * @returns {Condition} compiled condition
@@ -395,6 +411,7 @@ class RuleSetCompiler {
 	}
 
 	/**
+	 * Combine conditions or.
 	 * @param {Condition[]} conditions some conditions
 	 * @returns {Condition} merged condition
 	 */
@@ -414,6 +431,7 @@ class RuleSetCompiler {
 	}
 
 	/**
+	 * Combine conditions and.
 	 * @param {Condition[]} conditions some conditions
 	 * @returns {Condition} merged condition
 	 */
@@ -433,6 +451,7 @@ class RuleSetCompiler {
 	}
 
 	/**
+	 * Returns an error object.
 	 * @param {string} path current path
 	 * @param {EXPECTED_ANY} value value at the error location
 	 * @param {string} message message explaining the problem
@@ -443,6 +462,119 @@ class RuleSetCompiler {
 			`Compiling RuleSet failed: ${message} (at ${path}: ${value})`
 		);
 	}
+
+	/**
+	 * Best-effort detection of a user-registered loader (or explicit module type)
+	 * for a resource, without building the whole rule set. Used to resolve the
+	 * `experiments.css`/`experiments.html`/`experiments.asyncWebAssembly` "auto"
+	 * defaults: when the user already handles these files the built-in module type
+	 * stays off, so enabling it by default is non-breaking.
+	 *
+	 * `include`/`exclude` are treated leniently — a matching `test`/`resource`/
+	 * `include` with a loader counts even when another condition would narrow it —
+	 * so a loader scoped to e.g. `include: /src/` still keeps the built-in type off
+	 * and those files are not double-processed. `enforce: "pre"`/`"post"` loaders
+	 * are ignored: they don't establish the module type (e.g. a stylelint pre-loader
+	 * must not suppress the built-in css type). A `test` regexp that references the
+	 * extension (e.g. `/source\.css$/`) also counts even if the sample path itself
+	 * doesn't match, so a loader scoped to specific filenames is still detected.
+	 * @param {import("../../declarations/WebpackOptions").RuleSetRules | undefined} rules user `module.rules`
+	 * @param {string} resource sample resource path (e.g. `"/file.css"`)
+	 * @param {boolean=} inherited whether an enclosing rule already matched the resource
+	 * @returns {boolean} whether a rule assigns a loader or module type to the resource
+	 */
+	static hasRuleForResource(rules, resource, inherited = false) {
+		if (!rules) return false;
+		// `\.css` for `/file.css`, `\.wasm` for `/file.wasm`, …
+		const extProbe = `\\.${resource.slice(resource.lastIndexOf(".") + 1)}`;
+		for (const rule of rules) {
+			if (!rule || typeof rule !== "object") continue;
+			const matched =
+				inherited ||
+				matchesResource(rule.test, resource, extProbe) ||
+				matchesResource(rule.resource, resource, extProbe) ||
+				matchesResource(rule.include, resource, extProbe);
+			const establishesType =
+				rule.type !== undefined ||
+				((rule.use !== undefined || rule.loader !== undefined) &&
+					rule.enforce === undefined);
+			if (matched && establishesType) return true;
+			if (
+				rule.oneOf &&
+				RuleSetCompiler.hasRuleForResource(rule.oneOf, resource, matched)
+			) {
+				return true;
+			}
+			if (
+				rule.rules &&
+				RuleSetCompiler.hasRuleForResource(rule.rules, resource, matched)
+			) {
+				return true;
+			}
+		}
+		return false;
+	}
 }
 
+// Bare compiler reused to match single conditions via `compileCondition`
+// (no plugins needed); created lazily on first use.
+/** @type {RuleSetCompiler | undefined} */
+let conditionCompiler;
+
+/**
+ * Matches a single rule condition against a sample string, reusing the ruleset
+ * condition logic (string/regexp/function/array/and/or/not).
+ * @param {RuleSetConditionAbsolute | undefined} condition condition
+ * @param {string} resource sample resource path
+ * @returns {boolean} whether the condition matches
+ */
+const matchRuleSetCondition = (condition, resource) => {
+	if (condition === undefined) return false;
+	if (conditionCompiler === undefined) {
+		conditionCompiler = new RuleSetCompiler([]);
+	}
+	try {
+		return conditionCompiler
+			.compileCondition("ruleSet", condition)
+			.fn(resource);
+	} catch (_err) {
+		return false;
+	}
+};
+
+/**
+ * Whether any regexp in the condition references the extension probe (e.g.
+ * `\.css`), i.e. the rule clearly targets that extension even if the generic
+ * sample path doesn't match its (possibly filename-scoped) pattern.
+ * @param {EXPECTED_ANY} condition condition
+ * @param {string} extProbe escaped extension probe (e.g. `"\\.css"`)
+ * @returns {boolean} whether a regexp in the condition targets the extension
+ */
+const conditionReferencesExtension = (condition, extProbe) => {
+	if (condition instanceof RegExp) return condition.source.includes(extProbe);
+	if (Array.isArray(condition)) {
+		return condition.some((c) => conditionReferencesExtension(c, extProbe));
+	}
+	if (condition && typeof condition === "object") {
+		return (
+			conditionReferencesExtension(condition.and, extProbe) ||
+			conditionReferencesExtension(condition.or, extProbe)
+		);
+	}
+	return false;
+};
+
+/**
+ * A condition counts as targeting the resource if it matches the sample path or
+ * references the extension via a regexp.
+ * @param {RuleSetConditionAbsolute | undefined} condition condition
+ * @param {string} resource sample resource path
+ * @param {string} extProbe escaped extension probe (e.g. `"\\.css"`)
+ * @returns {boolean} whether the condition targets the resource's extension
+ */
+const matchesResource = (condition, resource, extProbe) =>
+	condition !== undefined &&
+	(matchRuleSetCondition(condition, resource) ||
+		conditionReferencesExtension(condition, extProbe));
+
 module.exports = RuleSetCompiler;

package/lib/rules/UseEffectRulePlugin.js

@@ -13,6 +13,7 @@ const util = require("util");
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetUse} RuleSetUse */
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetUseItem} RuleSetUseItem */
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetUseFunction} RuleSetUseFunction */
 /** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
 /** @typedef {import("./RuleSetCompiler").Effect} Effect */
 /** @typedef {import("./RuleSetCompiler").EffectData} EffectData */
@@ -22,6 +23,7 @@ const PLUGIN_NAME = "UseEffectRulePlugin";
 
 class UseEffectRulePlugin {
 	/**
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {RuleSetCompiler} ruleSetCompiler the rule set compiler
 	 * @returns {void}
 	 */
@@ -30,6 +32,7 @@ class UseEffectRulePlugin {
 			PLUGIN_NAME,
 			(path, rule, unhandledProperties, result, references) => {
 				/**
+				 * Processes the provided property.
 				 * @param {keyof RuleSetRule} property property
 				 * @param {string} correctProperty correct property
 				 */
@@ -58,6 +61,7 @@ class UseEffectRulePlugin {
 						(enforce ? `use-${enforce}` : "use");
 
 					/**
+					 * Returns effect.
 					 * @param {string} path options path
 					 * @param {string} defaultIdent default ident when none is provided
 					 * @param {RuleSetUseItem} item user provided use value
@@ -76,9 +80,10 @@ class UseEffectRulePlugin {
 					};
 
 					/**
+					 * Returns effect.
 					 * @param {string} path options path
 					 * @param {string} defaultIdent default ident when none is provided
-					 * @param {Exclude<NonNullable<RuleSetUseItem>, EXPECTED_FUNCTION>} item user provided use value
+					 * @param {Exclude<NonNullable<RuleSetUseItem>, RuleSetUseFunction>} item user provided use value
 					 * @returns {Effect} effect
 					 */
 					const useToEffectRaw = (path, defaultIdent, item) => {
@@ -117,6 +122,7 @@ class UseEffectRulePlugin {
 					};
 
 					/**
+					 * Use to effects without ident.
 					 * @param {string} path options path
 					 * @param {RuleSetUseItem | (Falsy | RuleSetUseItem)[]} items user provided use value
 					 * @returns {Effect[]} effects
@@ -127,7 +133,7 @@ class UseEffectRulePlugin {
 								useToEffectRaw(
 									`${path}[${idx}]`,
 									"[[missing ident]]",
-									/** @type {Exclude<RuleSetUseItem, EXPECTED_FUNCTION>} */
+									/** @type {Exclude<RuleSetUseItem, RuleSetUseFunction>} */
 									(item)
 								)
 							);
@@ -136,13 +142,14 @@ class UseEffectRulePlugin {
 							useToEffectRaw(
 								path,
 								"[[missing ident]]",
-								/** @type {Exclude<RuleSetUseItem, EXPECTED_FUNCTION>} */
+								/** @type {Exclude<RuleSetUseItem, RuleSetUseFunction>} */
 								(items)
 							)
 						];
 					};
 
 					/**
+					 * Returns effects.
 					 * @param {string} path current path
 					 * @param {RuleSetUse} items user provided use value
 					 * @returns {(Effect | ((effectData: EffectData) => Effect[]))[]} effects

package/lib/runtime/AsyncModuleGeneratorRuntimeModule.js

@@ -0,0 +1,56 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const Template = require("../Template");
+const HelperRuntimeModule = require("./HelperRuntimeModule");
+
+/** @typedef {import("../Compilation")} Compilation */
+
+class AsyncModuleGeneratorRuntimeModule extends HelperRuntimeModule {
+	constructor() {
+		super("async module generator");
+	}
+
+	/**
+	 * Generates runtime code for this runtime module.
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate } = compilation;
+		const fn = RuntimeGlobals.asyncModuleGenerator;
+		const cst = runtimeTemplate.renderConst();
+		// Wrap a generator-based async module body so it drives like an `async`
+		// function: run the generator and resolve each `yield`ed dependency
+		// promise, without emitting `async`/`await`.
+		return Template.asString([
+			`${fn} = ${runtimeTemplate.returningFunction(
+				runtimeTemplate.basicFunction(
+					"__webpack_handle_async_dependencies__, __webpack_async_result__",
+					[
+						`${cst} gen = body(__webpack_handle_async_dependencies__, __webpack_async_result__);`,
+						`${cst} step = ${runtimeTemplate.basicFunction("key, arg", [
+							`${cst} info = gen[key](arg);`,
+							"if (info.done) return;",
+							`Promise.resolve(info.value).then(${runtimeTemplate.expressionFunction(
+								'step("next", value)',
+								"value"
+							)}, ${runtimeTemplate.expressionFunction(
+								'step("throw", err)',
+								"err"
+							)});`
+						])};`,
+						'step("next");'
+					]
+				),
+				"body"
+			)};`
+		]);
+	}
+}
+
+module.exports = AsyncModuleGeneratorRuntimeModule;

package/lib/runtime/AsyncModuleRuntimeModule.js

@@ -21,6 +21,7 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {
@@ -28,24 +29,34 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 		const { runtimeTemplate } = compilation;
 		const fn = RuntimeGlobals.asyncModule;
 		const defer = this._deferInterop;
+		const cst = runtimeTemplate.renderConst();
+		const lt = runtimeTemplate.renderLet();
+		const supportsSymbol = runtimeTemplate.supportsSymbol();
+		/** @type {(name: string, fallback: string) => string} */
+		const renderSymbol = (name, fallback) =>
+			supportsSymbol
+				? `Symbol("${name}")`
+				: `hasSymbol ? Symbol("${name}") : "${fallback}"`;
 		return Template.asString([
-			'var hasSymbol = typeof Symbol === "function";',
-			'var webpackQueues = hasSymbol ? Symbol("webpack queues") : "__webpack_queues__";',
-			`var webpackExports = ${
+			...(supportsSymbol
+				? []
+				: [`${cst} hasSymbol = typeof Symbol === "function";`]),
+			`${cst} webpackQueues = ${renderSymbol("webpack queues", "__webpack_queues__")};`,
+			`${cst} webpackExports = ${
 				defer ? `${RuntimeGlobals.asyncModuleExportSymbol}= ` : ""
-			}hasSymbol ? Symbol("webpack exports") : "${RuntimeGlobals.exports}";`,
-			'var webpackError = hasSymbol ? Symbol("webpack error") : "__webpack_error__";',
+			}${renderSymbol("webpack exports", RuntimeGlobals.exports)};`,
+			`${cst} webpackError = ${renderSymbol("webpack error", "__webpack_error__")};`,
 			defer
 				? Template.asString([
-						`var webpackDone = ${RuntimeGlobals.asyncModuleDoneSymbol} = hasSymbol ? Symbol("webpack done") : "__webpack_done__";`,
-						`var webpackDefer = ${RuntimeGlobals.deferredModuleAsyncTransitiveDependenciesSymbol} = hasSymbol ? Symbol("webpack defer") : "__webpack_defer__";`,
+						`${cst} webpackDone = ${RuntimeGlobals.asyncModuleDoneSymbol} = ${renderSymbol("webpack done", "__webpack_done__")};`,
+						`${cst} webpackDefer = ${RuntimeGlobals.deferredModuleAsyncTransitiveDependenciesSymbol} = ${renderSymbol("webpack defer", "__webpack_defer__")};`,
 						`${RuntimeGlobals.deferredModuleAsyncTransitiveDependencies} = ${runtimeTemplate.basicFunction(
 							"asyncDeps",
 							[
 								Template.indent([
-									"var hasUnresolvedAsyncSubgraph = asyncDeps.some((id) => {",
+									`${cst} hasUnresolvedAsyncSubgraph = asyncDeps.some((id) => {`,
 									Template.indent([
-										"var cache = __webpack_module_cache__[id];",
+										`${cst} cache = __webpack_module_cache__[id];`,
 										"return !cache || cache[webpackDone] === false;"
 									]),
 									"});",
@@ -59,8 +70,8 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 						)}`
 					])
 				: "",
-			`var resolveQueue = ${runtimeTemplate.basicFunction("queue", [
-				"if(queue && queue.d < 1) {",
+			`${cst} resolveQueue = ${runtimeTemplate.basicFunction("queue", [
+				`if(${runtimeTemplate.optionalChaining("queue", "d < 1")}) {`,
 				Template.indent([
 					"queue.d = 1;",
 					`queue.forEach(${runtimeTemplate.expressionFunction(
@@ -74,7 +85,7 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 				]),
 				"}"
 			])}`,
-			`var wrapDeps = ${runtimeTemplate.returningFunction(
+			`${cst} wrapDeps = ${runtimeTemplate.returningFunction(
 				`deps.map(${runtimeTemplate.basicFunction("dep", [
 					'if(dep !== null && typeof dep === "object") {',
 					Template.indent([
@@ -82,10 +93,10 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 							? Template.asString([
 									"if(!dep[webpackQueues] && dep[webpackDefer]) {",
 									Template.indent([
-										`var asyncDeps = ${RuntimeGlobals.deferredModuleAsyncTransitiveDependencies}(dep[webpackDefer]);`,
+										`${cst} asyncDeps = ${RuntimeGlobals.deferredModuleAsyncTransitiveDependencies}(dep[webpackDefer]);`,
 										"if (asyncDeps) {",
 										Template.indent([
-											"var d = dep;",
+											`${cst} d = dep;`,
 											"dep = {",
 											Template.indent([
 												"then(onFulfilled, onRejected) {",
@@ -106,7 +117,7 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 						"if(dep[webpackQueues]) return dep;",
 						"if(dep.then) {",
 						Template.indent([
-							"var queue = [];",
+							`${cst} queue = [];`,
 							"queue.d = 0;",
 							`dep.then(${runtimeTemplate.basicFunction("r", [
 								"obj[webpackExports] = r;",
@@ -115,7 +126,7 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 								"obj[webpackError] = e;",
 								"resolveQueue(queue);"
 							])});`,
-							"var obj = {};",
+							`${cst} obj = {};`,
 							defer ? "obj[webpackDefer] = false;" : "",
 							`obj[webpackQueues] = ${runtimeTemplate.expressionFunction(
 								"fn(queue)",
@@ -126,7 +137,7 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 						"}"
 					]),
 					"}",
-					"var ret = {};",
+					`${cst} ret = {};`,
 					`ret[webpackQueues] = ${runtimeTemplate.emptyFunction()};`,
 					"ret[webpackExports] = dep;",
 					"return ret;"
@@ -134,14 +145,14 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 				"deps"
 			)};`,
 			`${fn} = ${runtimeTemplate.basicFunction("module, body, hasAwait", [
-				"var queue;",
+				`${lt} queue;`,
 				"hasAwait && ((queue = []).d = -1);",
-				"var depQueues = new Set();",
-				"var exports = module.exports;",
-				"var currentDeps;",
-				"var outerResolve;",
-				"var reject;",
-				`var promise = new Promise(${runtimeTemplate.basicFunction(
+				`${cst} depQueues = new Set();`,
+				`${cst} exports = module.exports;`,
+				`${lt} currentDeps;`,
+				`${lt} outerResolve;`,
+				`${lt} reject;`,
+				`${cst} promise = new Promise(${runtimeTemplate.basicFunction(
 					"resolve, rej",
 					["reject = rej;", "outerResolve = resolve;"]
 				)});`,
@@ -151,17 +162,17 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 					"fn"
 				)};`,
 				"module.exports = promise;",
-				`var handle = ${runtimeTemplate.basicFunction("deps", [
+				`${cst} handle = ${runtimeTemplate.basicFunction("deps", [
 					"currentDeps = wrapDeps(deps);",
-					"var fn;",
-					`var getResult = ${runtimeTemplate.returningFunction(
+					`${lt} fn;`,
+					`${cst} getResult = ${runtimeTemplate.returningFunction(
 						`currentDeps.map(${runtimeTemplate.basicFunction("d", [
 							defer ? "if(d[webpackDefer]) return d;" : "",
 							"if(d[webpackError]) throw d[webpackError];",
 							"return d[webpackExports];"
 						])})`
 					)}`,
-					`var promise = new Promise(${runtimeTemplate.basicFunction(
+					`${cst} promise = new Promise(${runtimeTemplate.basicFunction(
 						"resolve",
 						[
 							`fn = ${runtimeTemplate.expressionFunction(
@@ -169,11 +180,11 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 								""
 							)};`,
 							"fn.r = 0;",
-							`var fnQueue = ${runtimeTemplate.expressionFunction(
+							`${cst} fnQueue = ${runtimeTemplate.expressionFunction(
 								"q !== queue && !depQueues.has(q) && (depQueues.add(q), q && !q.d && (fn.r++, q.push(fn)))",
 								"q"
 							)};`,
-							`currentDeps.map(${runtimeTemplate.expressionFunction(
+							`currentDeps.forEach(${runtimeTemplate.expressionFunction(
 								`${
 									defer ? "dep[webpackDefer]||" : ""
 								}dep[webpackQueues](fnQueue)`,
@@ -183,14 +194,22 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 					)});`,
 					"return fn.r ? promise : getResult();"
 				])}`,
-				`var done = ${runtimeTemplate.expressionFunction(
+				`${cst} done = ${runtimeTemplate.expressionFunction(
 					`(err ? reject(promise[webpackError] = err) : outerResolve(exports)), resolveQueue(queue)${
-						defer ? ", promise[webpackDone] = true" : ""
+						defer
+							? ", promise[webpackDone] = true, module.evaluatingAsync = false"
+							: ""
 					}`,
 					"err"
 				)}`,
+				// Track the async body's whole lifetime (evaluating +
+				// evaluating-async states) with a dedicated flag — the sync require
+				// wrapper clears `module.evaluating` as soon as `.a` returns, so a
+				// deferred namespace reaching this module through a cycle relies on
+				// `evaluatingAsync` to keep throwing until it is fully evaluated.
+				defer ? "module.evaluatingAsync = true;" : "",
 				"body(handle, done);",
-				"queue && queue.d < 0 && (queue.d = 0);"
+				`${runtimeTemplate.optionalChaining("queue", "d < 0")} && (queue.d = 0);`
 			])};`
 		]);
 	}

package/lib/runtime/AutoPublicPathRuntimeModule.js

@@ -19,20 +19,21 @@ class AutoPublicPathRuntimeModule extends RuntimeModule {
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {
 		const compilation = /** @type {Compilation} */ (this.compilation);
 		const { scriptType, importMetaName, path, environment } =
 			compilation.outputOptions;
+		const chunk = /** @type {Chunk} */ (this.chunk);
 		const chunkName = compilation.getPath(
 			JavascriptModulesPlugin.getChunkFilenameTemplate(
-				/** @type {Chunk} */
-				(this.chunk),
+				chunk,
 				compilation.outputOptions
 			),
 			{
-				chunk: this.chunk,
+				chunk,
 				contentHashType: "javascript"
 			}
 		);
@@ -46,26 +47,38 @@ class AutoPublicPathRuntimeModule extends RuntimeModule {
 			? "globalThis"
 			: RuntimeGlobals.global;
 
+		const entryOptions = chunk.getEntryOptions();
+		// A worklet chunk is always loaded as a module via `addModule`, so it can
+		// read `import.meta.url` directly instead of the worker-scope detection.
+		const fromImportMeta =
+			scriptType === "module" || Boolean(entryOptions && entryOptions.worklet);
+
+		const runtimeTemplate = compilation.runtimeTemplate;
+		const cst = runtimeTemplate.renderConst();
+		const lt = runtimeTemplate.renderLet();
 		return Template.asString([
-			"var scriptUrl;",
-			scriptType === "module"
+			`${lt} scriptUrl;`,
+			fromImportMeta
 				? `if (typeof ${importMetaName}.url === "string") scriptUrl = ${importMetaName}.url`
 				: Template.asString([
 						`if (${global}.importScripts) scriptUrl = ${global}.location + "";`,
-						`var document = ${global}.document;`,
+						`${cst} document = ${global}.document;`,
 						"if (!scriptUrl && document) {",
 						Template.indent([
 							// Technically we could use `document.currentScript instanceof window.HTMLScriptElement`,
 							// but an attacker could try to inject `<script>HTMLScriptElement = HTMLImageElement</script>`
 							// and use `<img name="currentScript" src="https://attacker.controlled.server/"></img>`
-							"if (document.currentScript && document.currentScript.tagName.toUpperCase() === 'SCRIPT')",
+							`if (${runtimeTemplate.optionalChaining(
+								"document.currentScript",
+								"tagName.toUpperCase() === 'SCRIPT'"
+							)})`,
 							Template.indent("scriptUrl = document.currentScript.src;"),
 							"if (!scriptUrl) {",
 							Template.indent([
-								'var scripts = document.getElementsByTagName("script");',
+								`${cst} scripts = document.getElementsByTagName("script");`,
 								"if(scripts.length) {",
 								Template.indent([
-									"var i = scripts.length - 1;",
+									`${lt} i = scripts.length - 1;`,
 									"while (i > -1 && (!scriptUrl || !/^http(s?):/.test(scriptUrl))) scriptUrl = scripts[i--].src;"
 								]),
 								"}"

package/lib/runtime/BaseUriRuntimeModule.js

@@ -17,6 +17,7 @@ class BaseUriRuntimeModule extends RuntimeModule {
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {

package/lib/runtime/ChunkNameRuntimeModule.js

@@ -18,6 +18,7 @@ class ChunkNameRuntimeModule extends RuntimeModule {
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {