webpack 5.97.1 → 5.104.1

package/lib/rules/RuleSetCompiler.js

@@ -7,10 +7,16 @@
 
 const { SyncHook } = require("tapable");
 
+/** @typedef {import("enhanced-resolve").ResolveRequest} ResolveRequest */
+/** @typedef {import("../../declarations/WebpackOptions").Falsy} Falsy */
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetLoaderOptions} RuleSetLoaderOptions */
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
-/** @typedef {import("../../declarations/WebpackOptions").RuleSetRules} RuleSetRules */
 
-/** @typedef {function(string | EffectData): boolean} RuleConditionFunction */
+/** @typedef {(Falsy | RuleSetRule)[]} RuleSetRules */
+
+/**
+ * @typedef {(value: EffectData[keyof EffectData]) => boolean} RuleConditionFunction
+ */
 
 /**
  * @typedef {object} RuleCondition
@@ -26,30 +32,62 @@ const { SyncHook } = require("tapable");
  */
 
 /**
- * @typedef {Record<string, TODO>} EffectData
+ * @typedef {object} EffectData
+ * @property {string=} resource
+ * @property {string=} realResource
+ * @property {string=} resourceQuery
+ * @property {string=} resourceFragment
+ * @property {string=} scheme
+ * @property {ImportAttributes=} attributes
+ * @property {string=} mimetype
+ * @property {string} dependency
+ * @property {ResolveRequest["descriptionFileData"]=} descriptionData
+ * @property {string=} compiler
+ * @property {string} issuer
+ * @property {string} issuerLayer
  */
 
 /**
  * @typedef {object} CompiledRule
  * @property {RuleCondition[]} conditions
- * @property {(Effect|function(EffectData): Effect[])[]} effects
+ * @property {(Effect | ((effectData: EffectData) => Effect[]))[]} effects
  * @property {CompiledRule[]=} rules
  * @property {CompiledRule[]=} oneOf
  */
 
+/** @typedef {"use" | "use-pre" | "use-post"} EffectUseType */
+
+/**
+ * @typedef {object} EffectUse
+ * @property {EffectUseType} type
+ * @property {{ loader: string, options?: string | null | Record<string, EXPECTED_ANY>, ident?: string }} value
+ */
+
 /**
- * @typedef {object} Effect
+ * @typedef {object} EffectBasic
  * @property {string} type
- * @property {any} value
+ * @property {EXPECTED_ANY} value
  */
 
+/** @typedef {EffectUse | EffectBasic} Effect */
+
+/** @typedef {Map<string, RuleSetLoaderOptions>} References */
+
 /**
  * @typedef {object} RuleSet
- * @property {Map<string, any>} references map of references in the rule set (may grow over time)
- * @property {function(EffectData): Effect[]} exec execute the rule set
+ * @property {References} references map of references in the rule set (may grow over time)
+ * @property {(effectData: EffectData) => Effect[]} exec execute the rule set
+ */
+
+/**
+ * @template T
+ * @template {T[keyof T]} V
+ * @typedef {({ [key in keyof Required<T>]: Required<T>[key] extends V ? key : never })[keyof T]} KeysOfTypes
  */
 
-/** @typedef {{ apply: (function(RuleSetCompiler): void) }} RuleSetPlugin */
+/** @typedef {Set<string>} UnhandledProperties */
+
+/** @typedef {{ apply: (ruleSetCompiler: RuleSetCompiler) => void }} RuleSetPlugin */
 
 class RuleSetCompiler {
 	/**
@@ -57,7 +95,7 @@ class RuleSetCompiler {
 	 */
 	constructor(plugins) {
 		this.hooks = Object.freeze({
-			/** @type {SyncHook<[string, RuleSetRule, Set<string>, CompiledRule, Map<string | undefined, any>]>} */
+			/** @type {SyncHook<[string, RuleSetRule, UnhandledProperties, CompiledRule, References]>} */
 			rule: new SyncHook([
 				"path",
 				"rule",
@@ -74,7 +112,7 @@ class RuleSetCompiler {
 	}
 
 	/**
-	 * @param {TODO[]} ruleSet raw user provided rules
+	 * @param {RuleSetRules} ruleSet raw user provided rules
 	 * @returns {RuleSet} compiled RuleSet
 	 */
 	compile(ruleSet) {
@@ -91,7 +129,7 @@ class RuleSetCompiler {
 			for (const condition of rule.conditions) {
 				const p = condition.property;
 				if (Array.isArray(p)) {
-					/** @type {EffectData | string | undefined} */
+					/** @type {EXPECTED_ANY} */
 					let current = data;
 					for (const subProperty of p) {
 						if (
@@ -99,7 +137,7 @@ class RuleSetCompiler {
 							typeof current === "object" &&
 							Object.prototype.hasOwnProperty.call(current, subProperty)
 						) {
-							current = current[subProperty];
+							current = current[/** @type {keyof EffectData} */ (subProperty)];
 						} else {
 							current = undefined;
 							break;
@@ -110,7 +148,7 @@ class RuleSetCompiler {
 						continue;
 					}
 				} else if (p in data) {
-					const value = data[p];
+					const value = data[/** @type {keyof EffectData} */ (p)];
 					if (value !== undefined) {
 						if (!condition.fn(value)) return false;
 						continue;
@@ -147,7 +185,7 @@ class RuleSetCompiler {
 
 		return {
 			references: refs,
-			exec: data => {
+			exec: (data) => {
 				/** @type {Effect[]} */
 				const effects = [];
 				for (const rule of rules) {
@@ -161,7 +199,7 @@ class RuleSetCompiler {
 	/**
 	 * @param {string} path current path
 	 * @param {RuleSetRules} rules the raw rules provided by user
-	 * @param {Map<string, any>} refs references
+	 * @param {References} refs references
 	 * @returns {CompiledRule[]} rules
 	 */
 	compileRules(path, rules, refs) {
@@ -179,13 +217,14 @@ class RuleSetCompiler {
 	/**
 	 * @param {string} path current path
 	 * @param {RuleSetRule} rule the raw rule provided by user
-	 * @param {Map<string, any>} refs references
+	 * @param {References} refs references
 	 * @returns {CompiledRule} normalized and compiled rule for processing
 	 */
 	compileRule(path, rule, refs) {
+		/** @type {UnhandledProperties} */
 		const unhandledProperties = new Set(
 			Object.keys(rule).filter(
-				key => rule[/** @type {keyof RuleSetRule} */ (key)] !== undefined
+				(key) => rule[/** @type {keyof RuleSetRule} */ (key)] !== undefined
 			)
 		);
 
@@ -202,16 +241,18 @@ class RuleSetCompiler {
 		if (unhandledProperties.has("rules")) {
 			unhandledProperties.delete("rules");
 			const rules = rule.rules;
-			if (!Array.isArray(rules))
+			if (!Array.isArray(rules)) {
 				throw this.error(path, rules, "Rule.rules must be an array of rules");
+			}
 			compiledRule.rules = this.compileRules(`${path}.rules`, rules, refs);
 		}
 
 		if (unhandledProperties.has("oneOf")) {
 			unhandledProperties.delete("oneOf");
 			const oneOf = rule.oneOf;
-			if (!Array.isArray(oneOf))
+			if (!Array.isArray(oneOf)) {
 				throw this.error(path, oneOf, "Rule.oneOf must be an array of rules");
+			}
 			compiledRule.oneOf = this.compileRules(`${path}.oneOf`, oneOf, refs);
 		}
 
@@ -219,7 +260,7 @@ class RuleSetCompiler {
 			throw this.error(
 				path,
 				rule,
-				`Properties ${Array.from(unhandledProperties).join(", ")} are unknown`
+				`Properties ${[...unhandledProperties].join(", ")} are unknown`
 			);
 		}
 
@@ -228,14 +269,14 @@ class RuleSetCompiler {
 
 	/**
 	 * @param {string} path current path
-	 * @param {any} condition user provided condition value
+	 * @param {RuleSetLoaderOptions} condition user provided condition value
 	 * @returns {Condition} compiled condition
 	 */
 	compileCondition(path, condition) {
 		if (condition === "") {
 			return {
 				matchWhenEmpty: true,
-				fn: str => str === ""
+				fn: (str) => str === ""
 			};
 		}
 		if (!condition) {
@@ -248,14 +289,14 @@ class RuleSetCompiler {
 		if (typeof condition === "string") {
 			return {
 				matchWhenEmpty: condition.length === 0,
-				fn: str => typeof str === "string" && str.startsWith(condition)
+				fn: (str) => typeof str === "string" && str.startsWith(condition)
 			};
 		}
 		if (typeof condition === "function") {
 			try {
 				return {
 					matchWhenEmpty: condition(""),
-					fn: condition
+					fn: /** @type {RuleConditionFunction} */ (condition)
 				};
 			} catch (_err) {
 				throw this.error(
@@ -268,7 +309,7 @@ class RuleSetCompiler {
 		if (condition instanceof RegExp) {
 			return {
 				matchWhenEmpty: condition.test(""),
-				fn: v => typeof v === "string" && condition.test(v)
+				fn: (v) => typeof v === "string" && condition.test(v)
 			};
 		}
 		if (Array.isArray(condition)) {
@@ -324,7 +365,7 @@ class RuleSetCompiler {
 						const fn = matcher.fn;
 						conditions.push({
 							matchWhenEmpty: !matcher.matchWhenEmpty,
-							fn: /** @type {RuleConditionFunction} */ (v => !fn(v))
+							fn: /** @type {RuleConditionFunction} */ ((v) => !fn(v))
 						});
 					}
 					break;
@@ -360,8 +401,8 @@ class RuleSetCompiler {
 			return conditions[0];
 		}
 		return {
-			matchWhenEmpty: conditions.some(c => c.matchWhenEmpty),
-			fn: v => conditions.some(c => c.fn(v))
+			matchWhenEmpty: conditions.some((c) => c.matchWhenEmpty),
+			fn: (v) => conditions.some((c) => c.fn(v))
 		};
 	}
 
@@ -379,14 +420,14 @@ class RuleSetCompiler {
 			return conditions[0];
 		}
 		return {
-			matchWhenEmpty: conditions.every(c => c.matchWhenEmpty),
-			fn: v => conditions.every(c => c.fn(v))
+			matchWhenEmpty: conditions.every((c) => c.matchWhenEmpty),
+			fn: (v) => conditions.every((c) => c.fn(v))
 		};
 	}
 
 	/**
 	 * @param {string} path current path
-	 * @param {any} value value at the error location
+	 * @param {EXPECTED_ANY} value value at the error location
 	 * @param {string} message message explaining the problem
 	 * @returns {Error} an error object
 	 */

package/lib/rules/UseEffectRulePlugin.js

@@ -7,11 +7,18 @@
 
 const util = require("util");
 
+/** @typedef {import("../../declarations/WebpackOptions").Falsy} Falsy */
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetLoader} RuleSetLoader */
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetLoaderOptions} RuleSetLoaderOptions */
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetUse} RuleSetUse */
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetUseItem} RuleSetUseItem */
 /** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
 /** @typedef {import("./RuleSetCompiler").Effect} Effect */
+/** @typedef {import("./RuleSetCompiler").EffectData} EffectData */
+/** @typedef {import("./RuleSetCompiler").EffectUseType} EffectUseType */
+
+const PLUGIN_NAME = "UseEffectRulePlugin";
 
 class UseEffectRulePlugin {
 	/**
@@ -20,7 +27,7 @@ class UseEffectRulePlugin {
 	 */
 	apply(ruleSetCompiler) {
 		ruleSetCompiler.hooks.rule.tap(
-			"UseEffectRulePlugin",
+			PLUGIN_NAME,
 			(path, rule, unhandledProperties, result, references) => {
 				/**
 				 * @param {keyof RuleSetRule} property property
@@ -43,20 +50,27 @@ class UseEffectRulePlugin {
 					conflictWith("loader", "use");
 					conflictWith("options", "use");
 
-					const use = rule.use;
+					const use = /** @type {RuleSetUse} */ (rule.use);
 					const enforce = rule.enforce;
 
-					const type = enforce ? `use-${enforce}` : "use";
+					const type =
+						/** @type {EffectUseType} */
+						(enforce ? `use-${enforce}` : "use");
 
 					/**
 					 * @param {string} path options path
 					 * @param {string} defaultIdent default ident when none is provided
-					 * @param {object} item user provided use value
-					 * @returns {Effect|function(any): Effect[]} effect
+					 * @param {RuleSetUseItem} item user provided use value
+					 * @returns {(Effect | ((effectData: EffectData) => Effect[]))} effect
 					 */
 					const useToEffect = (path, defaultIdent, item) => {
 						if (typeof item === "function") {
-							return data => useToEffectsWithoutIdent(path, item(data));
+							return (data) =>
+								useToEffectsWithoutIdent(
+									path,
+									/** @type {RuleSetUseItem | RuleSetUseItem[]} */
+									(item(data))
+								);
 						}
 						return useToEffectRaw(path, defaultIdent, item);
 					};
@@ -64,7 +78,7 @@ class UseEffectRulePlugin {
 					/**
 					 * @param {string} path options path
 					 * @param {string} defaultIdent default ident when none is provided
-					 * @param {{ ident?: string, loader?: RuleSetLoader, options?: RuleSetLoaderOptions }} item user provided use value
+					 * @param {Exclude<NonNullable<RuleSetUseItem>, EXPECTED_FUNCTION>} item user provided use value
 					 * @returns {Effect} effect
 					 */
 					const useToEffectRaw = (path, defaultIdent, item) => {
@@ -78,7 +92,7 @@ class UseEffectRulePlugin {
 								}
 							};
 						}
-						const loader = item.loader;
+						const loader = /** @type {string} */ (item.loader);
 						const options = item.options;
 						let ident = item.ident;
 						if (options && typeof options === "object") {
@@ -104,41 +118,55 @@ class UseEffectRulePlugin {
 
 					/**
 					 * @param {string} path options path
-					 * @param {any} items user provided use value
+					 * @param {RuleSetUseItem | (Falsy | RuleSetUseItem)[]} items user provided use value
 					 * @returns {Effect[]} effects
 					 */
 					const useToEffectsWithoutIdent = (path, items) => {
 						if (Array.isArray(items)) {
-							return items
-								.filter(Boolean)
-								.map((item, idx) =>
-									useToEffectRaw(`${path}[${idx}]`, "[[missing ident]]", item)
-								);
+							return items.filter(Boolean).map((item, idx) =>
+								useToEffectRaw(
+									`${path}[${idx}]`,
+									"[[missing ident]]",
+									/** @type {Exclude<RuleSetUseItem, EXPECTED_FUNCTION>} */
+									(item)
+								)
+							);
 						}
-						return [useToEffectRaw(path, "[[missing ident]]", items)];
+						return [
+							useToEffectRaw(
+								path,
+								"[[missing ident]]",
+								/** @type {Exclude<RuleSetUseItem, EXPECTED_FUNCTION>} */
+								(items)
+							)
+						];
 					};
 
 					/**
 					 * @param {string} path current path
-					 * @param {any} items user provided use value
-					 * @returns {(Effect|function(any): Effect[])[]} effects
+					 * @param {RuleSetUse} items user provided use value
+					 * @returns {(Effect | ((effectData: EffectData) => Effect[]))[]} effects
 					 */
 					const useToEffects = (path, items) => {
 						if (Array.isArray(items)) {
 							return items.filter(Boolean).map((item, idx) => {
 								const subPath = `${path}[${idx}]`;
-								return useToEffect(subPath, subPath, item);
+								return useToEffect(
+									subPath,
+									subPath,
+									/** @type {RuleSetUseItem} */
+									(item)
+								);
 							});
 						}
-						return [useToEffect(path, path, items)];
+						return [
+							useToEffect(path, path, /** @type {RuleSetUseItem} */ (items))
+						];
 					};
 
 					if (typeof use === "function") {
-						result.effects.push(data =>
-							useToEffectsWithoutIdent(
-								`${path}.use`,
-								use(/** @type {TODO} */ (data))
-							)
+						result.effects.push((data) =>
+							useToEffectsWithoutIdent(`${path}.use`, use(data))
 						);
 					} else {
 						for (const effect of useToEffects(`${path}.use`, use)) {
@@ -182,7 +210,15 @@ class UseEffectRulePlugin {
 
 					const ident =
 						options && typeof options === "object" ? path : undefined;
-					references.set(ident, options);
+
+					if (ident) {
+						references.set(
+							ident,
+							/** @type {RuleSetLoaderOptions} */
+							(options)
+						);
+					}
+
 					result.effects.push({
 						type: enforce ? `use-${enforce}` : "use",
 						value: {

package/lib/runtime/AsyncModuleRuntimeModule.js

@@ -11,8 +11,12 @@ const HelperRuntimeModule = require("./HelperRuntimeModule");
 /** @typedef {import("../Compilation")} Compilation */
 
 class AsyncModuleRuntimeModule extends HelperRuntimeModule {
-	constructor() {
+	/**
+	 * @param {boolean=} deferInterop if defer import is used.
+	 */
+	constructor(deferInterop = false) {
 		super("async module");
+		this._deferInterop = deferInterop;
 	}
 
 	/**
@@ -22,10 +26,38 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 		const compilation = /** @type {Compilation} */ (this.compilation);
 		const { runtimeTemplate } = compilation;
 		const fn = RuntimeGlobals.asyncModule;
+		const defer = this._deferInterop;
 		return Template.asString([
-			'var webpackQueues = typeof Symbol === "function" ? Symbol("webpack queues") : "__webpack_queues__";',
-			`var webpackExports = typeof Symbol === "function" ? Symbol("webpack exports") : "${RuntimeGlobals.exports}";`,
-			'var webpackError = typeof Symbol === "function" ? Symbol("webpack error") : "__webpack_error__";',
+			'var hasSymbol = typeof Symbol === "function";',
+			'var webpackQueues = hasSymbol ? Symbol("webpack queues") : "__webpack_queues__";',
+			`var webpackExports = ${
+				defer ? `${RuntimeGlobals.asyncModuleExportSymbol}= ` : ""
+			}hasSymbol ? Symbol("webpack exports") : "${RuntimeGlobals.exports}";`,
+			'var webpackError = hasSymbol ? Symbol("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__";`,
+						`${RuntimeGlobals.deferredModuleAsyncTransitiveDependencies} = ${runtimeTemplate.basicFunction(
+							"asyncDeps",
+							[
+								Template.indent([
+									"var hasUnresolvedAsyncSubgraph = asyncDeps.some((id) => {",
+									Template.indent([
+										"var cache = __webpack_module_cache__[id];",
+										"return !cache || cache[webpackDone] === false;"
+									]),
+									"});",
+									"if (hasUnresolvedAsyncSubgraph) {",
+									Template.indent([
+										"return ({ then(onFulfilled, onRejected) { return Promise.all(asyncDeps.map(__webpack_require__)).then(onFulfilled, onRejected) } })"
+									]),
+									"}"
+								])
+							]
+						)}`
+					])
+				: "",
 			`var resolveQueue = ${runtimeTemplate.basicFunction("queue", [
 				"if(queue && queue.d < 1) {",
 				Template.indent([
@@ -45,6 +77,31 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 				`deps.map(${runtimeTemplate.basicFunction("dep", [
 					'if(dep !== null && typeof dep === "object") {',
 					Template.indent([
+						defer
+							? Template.asString([
+									"if(!dep[webpackQueues] && dep[webpackDefer]) {",
+									Template.indent([
+										`var asyncDeps = ${RuntimeGlobals.deferredModuleAsyncTransitiveDependencies}(dep[webpackDefer]);`,
+										"if (asyncDeps) {",
+										Template.indent([
+											"var d = dep;",
+											"dep = {",
+											Template.indent([
+												"then(onFulfilled, onRejected) {",
+												Template.indent([
+													`asyncDeps.then(${runtimeTemplate.returningFunction(
+														"onFulfilled(d)"
+													)}, onRejected);`
+												]),
+												"}"
+											]),
+											"};"
+										]),
+										"} else return dep;"
+									]),
+									"}"
+								])
+							: "",
 						"if(dep[webpackQueues]) return dep;",
 						"if(dep.then) {",
 						Template.indent([
@@ -58,6 +115,7 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 								"resolveQueue(queue);"
 							])});`,
 							"var obj = {};",
+							defer ? "obj[webpackDefer] = false;" : "",
 							`obj[webpackQueues] = ${runtimeTemplate.expressionFunction(
 								"fn(queue)",
 								"fn"
@@ -92,11 +150,12 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 					"fn"
 				)};`,
 				"module.exports = promise;",
-				`body(${runtimeTemplate.basicFunction("deps", [
+				`var handle = ${runtimeTemplate.basicFunction("deps", [
 					"currentDeps = wrapDeps(deps);",
 					"var fn;",
 					`var getResult = ${runtimeTemplate.returningFunction(
 						`currentDeps.map(${runtimeTemplate.basicFunction("d", [
+							defer ? "if(d[webpackDefer]) return d;" : "",
 							"if(d[webpackError]) throw d[webpackError];",
 							"return d[webpackExports];"
 						])})`
@@ -114,16 +173,22 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 								"q"
 							)};`,
 							`currentDeps.map(${runtimeTemplate.expressionFunction(
-								"dep[webpackQueues](fnQueue)",
+								`${
+									defer ? "dep[webpackDefer]||" : ""
+								}dep[webpackQueues](fnQueue)`,
 								"dep"
 							)});`
 						]
 					)});`,
 					"return fn.r ? promise : getResult();"
-				])}, ${runtimeTemplate.expressionFunction(
-					"(err ? reject(promise[webpackError] = err) : outerResolve(exports)), resolveQueue(queue)",
+				])}`,
+				`var done = ${runtimeTemplate.expressionFunction(
+					`(err ? reject(promise[webpackError] = err) : outerResolve(exports)), resolveQueue(queue)${
+						defer ? ", promise[webpackDone] = true" : ""
+					}`,
 					"err"
-				)});`,
+				)}`,
+				"body(handle, done);",
 				"queue && queue.d < 0 && (queue.d = 0);"
 			])};`
 		]);

package/lib/runtime/AutoPublicPathRuntimeModule.js

@@ -23,7 +23,8 @@ class AutoPublicPathRuntimeModule extends RuntimeModule {
 	 */
 	generate() {
 		const compilation = /** @type {Compilation} */ (this.compilation);
-		const { scriptType, importMetaName, path } = compilation.outputOptions;
+		const { scriptType, importMetaName, path, environment } =
+			compilation.outputOptions;
 		const chunkName = compilation.getPath(
 			JavascriptModulesPlugin.getChunkFilenameTemplate(
 				/** @type {Chunk} */
@@ -41,13 +42,17 @@ class AutoPublicPathRuntimeModule extends RuntimeModule {
 			false
 		);
 
+		const global = environment.globalThis
+			? "globalThis"
+			: RuntimeGlobals.global;
+
 		return Template.asString([
 			"var scriptUrl;",
 			scriptType === "module"
 				? `if (typeof ${importMetaName}.url === "string") scriptUrl = ${importMetaName}.url`
 				: Template.asString([
-						`if (${RuntimeGlobals.global}.importScripts) scriptUrl = ${RuntimeGlobals.global}.location + "";`,
-						`var document = ${RuntimeGlobals.global}.document;`,
+						`if (${global}.importScripts) scriptUrl = ${global}.location + "";`,
+						`var document = ${global}.document;`,
 						"if (!scriptUrl && document) {",
 						Template.indent([
 							// Technically we could use `document.currentScript instanceof window.HTMLScriptElement`,
@@ -72,7 +77,7 @@ class AutoPublicPathRuntimeModule extends RuntimeModule {
 			"// When supporting browsers where an automatic publicPath is not supported you must specify an output.publicPath manually via configuration",
 			'// or pass an empty string ("") and set the __webpack_public_path__ variable from your code to use your own logic.',
 			'if (!scriptUrl) throw new Error("Automatic publicPath is not supported in this browser");',
-			'scriptUrl = scriptUrl.replace(/#.*$/, "").replace(/\\?.*$/, "").replace(/\\/[^\\/]+$/, "/");',
+			'scriptUrl = scriptUrl.replace(/^blob:/, "").replace(/#.*$/, "").replace(/\\?.*$/, "").replace(/\\/[^\\/]+$/, "/");',
 			!undoPath
 				? `${RuntimeGlobals.publicPath} = scriptUrl;`
 				: `${RuntimeGlobals.publicPath} = scriptUrl + ${JSON.stringify(

package/lib/runtime/BaseUriRuntimeModule.js

@@ -8,7 +8,7 @@
 const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 
-/** @typedef {import("../../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescriptionNormalized */
+/** @typedef {import("../../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescription */
 /** @typedef {import("../Chunk")} Chunk */
 
 class BaseUriRuntimeModule extends RuntimeModule {
@@ -22,7 +22,7 @@ class BaseUriRuntimeModule extends RuntimeModule {
 	generate() {
 		const chunk = /** @type {Chunk} */ (this.chunk);
 		const options =
-			/** @type {EntryDescriptionNormalized} */
+			/** @type {EntryDescription} */
 			(chunk.getEntryOptions());
 		return `${RuntimeGlobals.baseURI} = ${
 			options.baseUri === undefined

package/lib/runtime/CompatRuntimeModule.js

@@ -10,7 +10,6 @@ const RuntimeModule = require("../RuntimeModule");
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../MainTemplate")} MainTemplate */
 
 class CompatRuntimeModule extends RuntimeModule {
 	constructor() {

package/lib/runtime/CreateFakeNamespaceObjectRuntimeModule.js

@@ -49,7 +49,7 @@ class CreateFakeNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 				`${RuntimeGlobals.makeNamespaceObject}(ns);`,
 				"var def = {};",
 				"leafPrototypes = leafPrototypes || [null, getProto({}), getProto([]), getProto(getProto)];",
-				"for(var current = mode & 2 && value; typeof current == 'object' && !~leafPrototypes.indexOf(current); current = getProto(current)) {",
+				"for(var current = mode & 2 && value; (typeof current == 'object' || typeof current == 'function') && !~leafPrototypes.indexOf(current); current = getProto(current)) {",
 				Template.indent([
 					`Object.getOwnPropertyNames(current).forEach(${runtimeTemplate.expressionFunction(
 						`def[key] = ${runtimeTemplate.returningFunction("value[key]", "")}`,