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

package/lib/prefetch/parseResourceHintOptions.js

@@ -4,10 +4,14 @@
 
 "use strict";
 
-const UnsupportedFeatureWarning = require("../errors/UnsupportedFeatureWarning");
+const memoize = require("../util/memoize");
 
-/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("../NormalModule")} NormalModule */
+const getUnsupportedFeatureWarning = memoize(() =>
+	require("../errors/UnsupportedFeatureWarning")
+);
+
+/** @import { DependencyLocation } from "../Dependency" */
+/** @import NormalModule from "../NormalModule" */
 
 /**
  * @typedef {object} ResourceHintOptions
@@ -38,7 +42,7 @@ const parseResourceHintOptions = (importOptions, module, loc) => {
 	 * @returns {void}
 	 */
 	const warn = (message) => {
-		module.addWarning(new UnsupportedFeatureWarning(message, loc));
+		module.addWarning(new (getUnsupportedFeatureWarning())(message, loc));
 	};
 
 	if (importOptions.webpackPrefetch !== undefined) {
@@ -100,4 +104,27 @@ const parseResourceHintOptions = (importOptions, module, loc) => {
 	return hints;
 };
 
+/**
+ * Maps a request/filename to the value of the `<link>` `as` attribute. Best
+ * effort — falls back to `"fetch"` when the type cannot be guessed. Pattern
+ * matches against the path part, ignoring any query string suffix.
+ * @param {string} request request/filename
+ * @returns {string} value for the `as` attribute
+ */
+const guessAsAttribute = (request) => {
+	if (/\.(png|jpe?g|gif|svg|webp|avif|bmp|ico|tiff?)(\?.*)?$/i.test(request)) {
+		return "image";
+	}
+	if (/\.(woff2?|ttf|otf|eot)(\?.*)?$/i.test(request)) return "font";
+	if (/\.css(\?.*)?$/i.test(request)) return "style";
+	if (/\.[cm]?jsx?(\?.*)?$/i.test(request)) return "script";
+	if (/\.[cm]?tsx?(\?.*)?$/i.test(request)) return "script";
+	if (/\.(mp3|wav|flac|aac|m4a|ogg|oga)(\?.*)?$/i.test(request)) return "audio";
+	if (/\.(mp4|webm|mkv|mov|m4v|ogv|avi)(\?.*)?$/i.test(request)) return "video";
+	if (/\.vtt(\?.*)?$/i.test(request)) return "track";
+	return "fetch";
+};
+
+parseResourceHintOptions.guessAsAttribute = guessAsAttribute;
+
 module.exports = parseResourceHintOptions;

package/lib/rules/BasicEffectRulePlugin.js

@@ -5,8 +5,8 @@
 
 "use strict";
 
-/** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
-/** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
+/** @import { RuleSetRule } from "../../declarations/WebpackOptions" */
+/** @import RuleSetCompiler from "./RuleSetCompiler" */
 
 /**
  * Defines the keys of types type used by this module.

package/lib/rules/BasicMatcherRulePlugin.js

@@ -5,10 +5,14 @@
 
 "use strict";
 
-/** @typedef {import("../../declarations/WebpackOptions").RuleSetConditionOrConditions} RuleSetConditionOrConditions */
-/** @typedef {import("../../declarations/WebpackOptions").RuleSetConditionOrConditionsAbsolute} RuleSetConditionOrConditionsAbsolute */
-/** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
-/** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
+/**
+ * @import {
+ * 	RuleSetConditionOrConditions,
+ * 	RuleSetConditionOrConditionsAbsolute,
+ * 	RuleSetRule
+ * } from "../../declarations/WebpackOptions"
+ */
+/** @import RuleSetCompiler from "./RuleSetCompiler" */
 
 /**
  * Defines the keys of types type used by this module.

package/lib/rules/GlobMatcherRulePlugin.js

@@ -0,0 +1,68 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+/**
+ * @import {
+ * 	RuleSetGlob,
+ * 	RuleSetGlobs,
+ * 	RuleSetRule
+ * } from "../../declarations/WebpackOptions"
+ */
+/** @import RuleSetCompiler from "./RuleSetCompiler" */
+
+/**
+ * Defines the keys of types type used by this module.
+ * @template T
+ * @template {T[keyof T]} V
+ * @typedef {import("./RuleSetCompiler").KeysOfTypes<T, V>} KeysOfTypes
+ */
+
+/** @typedef {KeysOfTypes<RuleSetRule, RuleSetGlob | RuleSetGlobs>} GlobMatcherRuleKeys */
+
+const PLUGIN_NAME = "GlobMatcherRulePlugin";
+
+class GlobMatcherRulePlugin {
+	/**
+	 * Creates an instance of GlobMatcherRulePlugin.
+	 * @param {GlobMatcherRuleKeys} ruleProperty the rule property
+	 * @param {string=} dataProperty the data property
+	 */
+	constructor(ruleProperty, dataProperty) {
+		/** @type {GlobMatcherRuleKeys} */
+		this.ruleProperty = ruleProperty;
+		/** @type {string | GlobMatcherRuleKeys} */
+		this.dataProperty = dataProperty || ruleProperty;
+	}
+
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
+	 * @param {RuleSetCompiler} ruleSetCompiler the rule set compiler
+	 * @returns {void}
+	 */
+	apply(ruleSetCompiler) {
+		ruleSetCompiler.hooks.rule.tap(
+			PLUGIN_NAME,
+			(path, rule, unhandledProperties, result) => {
+				if (unhandledProperties.has(this.ruleProperty)) {
+					unhandledProperties.delete(this.ruleProperty);
+					const condition = ruleSetCompiler.compileGlobCondition(
+						`${path}.${this.ruleProperty}`,
+						/** @type {RuleSetGlob | RuleSetGlobs} */
+						(rule[this.ruleProperty])
+					);
+					result.conditions.push({
+						property: this.dataProperty,
+						matchWhenEmpty: condition.matchWhenEmpty,
+						fn: condition.fn
+					});
+				}
+			}
+		);
+	}
+}
+
+module.exports = GlobMatcherRulePlugin;

package/lib/rules/ObjectMatcherRulePlugin.js

@@ -5,11 +5,18 @@
 
 "use strict";
 
-/** @typedef {import("../../declarations/WebpackOptions").RuleSetConditionOrConditions} RuleSetConditionOrConditions */
-/** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
-/** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
-/** @typedef {import("./RuleSetCompiler").EffectData} EffectData */
-/** @typedef {import("./RuleSetCompiler").RuleConditionFunction} RuleConditionFunction */
+/**
+ * @import {
+ * 	RuleSetConditionOrConditions,
+ * 	RuleSetRule
+ * } from "../../declarations/WebpackOptions"
+ */
+/**
+ * @import RuleSetCompiler, {
+ * 	EffectData,
+ * 	RuleConditionFunction
+ * } from "./RuleSetCompiler"
+ */
 
 /**
  * Defines the keys of types type used by this module.

package/lib/rules/RuleSetCompiler.js

@@ -6,13 +6,18 @@
 "use strict";
 
 const { SyncHook } = require("tapable");
+const { createPathGlobMatcher } = require("../util/globUtils");
 
-/** @typedef {import("enhanced-resolve").ResolveRequest} ResolveRequest */
-/** @typedef {import("../../declarations/WebpackOptions").Falsy} Falsy */
-/** @typedef {import("../../declarations/WebpackOptions").RuleSetUseItem} RuleSetUseItem */
-/** @typedef {import("../../declarations/WebpackOptions").RuleSetLoaderOptions} RuleSetLoaderOptions */
-/** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
-/** @typedef {import("../../declarations/WebpackOptions").RuleSetConditionAbsolute} RuleSetConditionAbsolute */
+/** @import { ResolveRequest } from "enhanced-resolve" */
+/**
+ * @import {
+ * 	Falsy,
+ * 	RuleSetUseItem,
+ * 	RuleSetLoaderOptions,
+ * 	RuleSetRule,
+ * 	RuleSetConditionAbsolute
+ * } from "../../declarations/WebpackOptions"
+ */
 
 /** @typedef {(Falsy | RuleSetRule)[]} RuleSetRules */
 
@@ -48,6 +53,7 @@ const { SyncHook } = require("tapable");
  * @property {string=} mimetype
  * @property {string} dependency
  * @property {ResolveRequest["descriptionFileData"]=} descriptionData
+ * @property {ResolveRequest["relativePath"]=} descriptionRelativePath
  * @property {string=} compiler
  * @property {string} issuer
  * @property {string} issuerLayer
@@ -57,6 +63,9 @@ const { SyncHook } = require("tapable");
 /**
  * Defines the compiled rule type used by this module.
  * @typedef {object} CompiledRule
+ * @property {string} path
+ * @property {RuleSetRule} raw
+ * @property {boolean} used
  * @property {RuleCondition[]} conditions
  * @property {(Effect | ((effectData: EffectData) => Effect[]))[]} effects
  * @property {CompiledRule[]=} rules
@@ -88,6 +97,7 @@ const { SyncHook } = require("tapable");
  * @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
+ * @property {() => CompiledRule[]} unusedRules the rules that never matched, outermost first
  */
 
 /**
@@ -99,11 +109,34 @@ const { SyncHook } = require("tapable");
 
 /** @typedef {Set<string>} UnhandledProperties */
 
+/** @typedef {(str: string) => boolean} GlobMatcher */
 /** @typedef {(data: EffectData) => (RuleSetUseItem | (Falsy | RuleSetUseItem)[])} RuleSetUseFn */
 /** @typedef {(value: string) => boolean} RuleSetConditionFn */
 
 /** @typedef {{ apply: (ruleSetCompiler: RuleSetCompiler) => void }} RuleSetPlugin */
 
+/**
+ * @param {GlobMatcher[]} positive patterns that select
+ * @param {GlobMatcher[]} negative patterns that subtract
+ * @returns {GlobMatcher} matcher
+ */
+const combineGlobMatchers = (positive, negative) => {
+	/** @type {GlobMatcher} */
+	const matchPositive =
+		positive.length === 0
+			? () => true
+			: positive.length === 1
+				? positive[0]
+				: (str) => positive.some((match) => match(str));
+	if (negative.length === 0) return matchPositive;
+	/** @type {GlobMatcher} */
+	const matchNegative =
+		negative.length === 1
+			? negative[0]
+			: (str) => negative.some((match) => match(str));
+	return (str) => matchPositive(str) && !matchNegative(str);
+};
+
 class RuleSetCompiler {
 	/**
 	 * Creates an instance of RuleSetCompiler.
@@ -177,6 +210,7 @@ class RuleSetCompiler {
 					return false;
 				}
 			}
+			rule.used = true;
 			for (const effect of rule.effects) {
 				if (typeof effect === "function") {
 					const returnedEffects = effect(data);
@@ -211,6 +245,12 @@ class RuleSetCompiler {
 					execRule(data, rule, effects);
 				}
 				return effects;
+			},
+			unusedRules: () => {
+				/** @type {CompiledRule[]} */
+				const unused = [];
+				collectUnusedRules(rules, unused);
+				return unused;
 			}
 		};
 	}
@@ -251,6 +291,9 @@ class RuleSetCompiler {
 
 		/** @type {CompiledRule} */
 		const compiledRule = {
+			path,
+			raw: rule,
+			used: false,
 			conditions: [],
 			effects: [],
 			rules: undefined,
@@ -382,6 +425,11 @@ class RuleSetCompiler {
 						}
 					}
 					break;
+				case "glob":
+					if (value) {
+						conditions.push(this.compileGlobCondition(`${path}.glob`, value));
+					}
+					break;
 				case "not":
 					if (value) {
 						const matcher = this.compileCondition(`${path}.not`, value);
@@ -410,6 +458,49 @@ class RuleSetCompiler {
 		return this.combineConditionsAnd(conditions);
 	}
 
+	/**
+	 * Returns a compiled glob condition. Unlike a regexp it matches the same way
+	 * on every OS: `\` is a path separator in both the pattern and the tested
+	 * value, and a relative pattern matches at any depth. Patterns are OR-ed,
+	 * a `!` prefix subtracts, and a list of only `!` patterns subtracts from
+	 * everything.
+	 * @param {string} path current path
+	 * @param {string | string[]} glob user provided glob pattern(s)
+	 * @returns {Condition} compiled condition
+	 */
+	compileGlobCondition(path, glob) {
+		const globs = Array.isArray(glob) ? glob : [glob];
+		if (globs.length === 0) {
+			throw this.error(path, glob, "Expected glob pattern, but got empty list");
+		}
+		/** @type {GlobMatcher[]} */
+		const positive = [];
+		/** @type {GlobMatcher[]} */
+		const negative = [];
+		for (let i = 0; i < globs.length; i++) {
+			const pattern = globs[i];
+			const patternPath = Array.isArray(glob) ? `${path}[${i}]` : path;
+			if (typeof pattern !== "string") {
+				throw this.error(
+					patternPath,
+					pattern,
+					`Unexpected ${typeof pattern} when glob pattern was expected`
+				);
+			}
+			const negated = pattern.startsWith("!");
+			const match = createPathGlobMatcher(negated ? pattern.slice(1) : pattern);
+			if (match === null) {
+				throw this.error(patternPath, pattern, "Invalid glob pattern");
+			}
+			(negated ? negative : positive).push(match);
+		}
+		const match = combineGlobMatchers(positive, negative);
+		return {
+			matchWhenEmpty: match(""),
+			fn: (v) => typeof v === "string" && match(v)
+		};
+	}
+
 	/**
 	 * Combine conditions or.
 	 * @param {Condition[]} conditions some conditions
@@ -477,7 +568,8 @@ class RuleSetCompiler {
 	 * 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.
+	 * doesn't match, so a loader scoped to specific filenames is still detected; a
+	 * `glob` condition naming the extension counts the same way.
 	 * @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
@@ -493,7 +585,13 @@ class RuleSetCompiler {
 				inherited ||
 				matchesResource(rule.test, resource, extProbe) ||
 				matchesResource(rule.resource, resource, extProbe) ||
-				matchesResource(rule.include, resource, extProbe);
+				matchesResource(rule.include, resource, extProbe) ||
+				// the rule-level `glob` selects the resource as well
+				matchesResource(
+					rule.glob === undefined ? undefined : { glob: rule.glob },
+					resource,
+					extProbe
+				);
 			const establishesType =
 				rule.type !== undefined ||
 				((rule.use !== undefined || rule.loader !== undefined) &&
@@ -543,9 +641,25 @@ const matchRuleSetCondition = (condition, resource) => {
 };
 
 /**
- * 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} glob glob pattern(s)
+ * @param {string} extension extension including the dot (e.g. `".css"`)
+ * @returns {boolean} whether a pattern targets the extension
+ */
+const globReferencesExtension = (glob, extension) => {
+	// a `!` pattern subtracts the extension instead of targeting it
+	if (typeof glob === "string") {
+		return !glob.startsWith("!") && glob.includes(extension);
+	}
+	return (
+		Array.isArray(glob) &&
+		glob.some((pattern) => globReferencesExtension(pattern, extension))
+	);
+};
+
+/**
+ * Whether any regexp or glob 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
@@ -557,6 +671,8 @@ const conditionReferencesExtension = (condition, extProbe) => {
 	}
 	if (condition && typeof condition === "object") {
 		return (
+			// `\.css` → `.css`
+			globReferencesExtension(condition.glob, extProbe.slice(1)) ||
 			conditionReferencesExtension(condition.and, extProbe) ||
 			conditionReferencesExtension(condition.or, extProbe)
 		);
@@ -566,7 +682,7 @@ const conditionReferencesExtension = (condition, extProbe) => {
 
 /**
  * A condition counts as targeting the resource if it matches the sample path or
- * references the extension via a regexp.
+ * references the extension via a regexp or glob.
  * @param {RuleSetConditionAbsolute | undefined} condition condition
  * @param {string} resource sample resource path
  * @param {string} extProbe escaped extension probe (e.g. `"\\.css"`)
@@ -577,4 +693,22 @@ const matchesResource = (condition, resource, extProbe) =>
 	(matchRuleSetCondition(condition, resource) ||
 		conditionReferencesExtension(condition, extProbe));
 
+/**
+ * Collects the outermost rules that never matched. A rule below an unused one is
+ * unused only because of its parent, so its subtree is not descended into.
+ * @param {CompiledRule[]} rules compiled rules
+ * @param {CompiledRule[]} result where unused rules are collected
+ * @returns {void}
+ */
+const collectUnusedRules = (rules, result) => {
+	for (const rule of rules) {
+		if (!rule.used) {
+			result.push(rule);
+			continue;
+		}
+		if (rule.rules) collectUnusedRules(rule.rules, result);
+		if (rule.oneOf) collectUnusedRules(rule.oneOf, result);
+	}
+};
+
 module.exports = RuleSetCompiler;

package/lib/rules/UseEffectRulePlugin.js

@@ -7,17 +7,24 @@
 
 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("../../declarations/WebpackOptions").RuleSetUseFunction} RuleSetUseFunction */
-/** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
-/** @typedef {import("./RuleSetCompiler").Effect} Effect */
-/** @typedef {import("./RuleSetCompiler").EffectData} EffectData */
-/** @typedef {import("./RuleSetCompiler").EffectUseType} EffectUseType */
+/**
+ * @import {
+ * 	Falsy,
+ * 	RuleSetLoader,
+ * 	RuleSetLoaderOptions,
+ * 	RuleSetRule,
+ * 	RuleSetUse,
+ * 	RuleSetUseItem,
+ * 	RuleSetUseFunction
+ * } from "../../declarations/WebpackOptions"
+ */
+/**
+ * @import RuleSetCompiler, {
+ * 	Effect,
+ * 	EffectData,
+ * 	EffectUseType
+ * } from "./RuleSetCompiler"
+ */
 
 const PLUGIN_NAME = "UseEffectRulePlugin";
 

package/lib/runtime/AsyncModuleGeneratorRuntimeModule.js

@@ -8,13 +8,23 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const HelperRuntimeModule = require("./HelperRuntimeModule");
 
-/** @typedef {import("../Compilation")} Compilation */
+/** @import Compilation from "../Compilation" */
 
 class AsyncModuleGeneratorRuntimeModule extends HelperRuntimeModule {
 	constructor() {
 		super("async module generator");
 	}
 
+	/**
+	 * Returns true, if the runtime module should get it's own scope.
+	 * When false, `generate()` must emit complete statements ending with `;`
+	 * so a following runtime IIFE is not parsed as a call (ASI).
+	 * @returns {boolean} true, if the runtime module should get it's own scope
+	 */
+	shouldIsolate() {
+		return false;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/runtime/AsyncModuleRuntimeModule.js

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

package/lib/runtime/AutoPublicPathRuntimeModule.js

@@ -7,11 +7,10 @@
 const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
-const JavascriptModulesPlugin = require("../javascript/JavascriptModulesPlugin");
-const { getUndoPath } = require("../util/identifier");
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compilation")} Compilation */
+/** @import Chunk from "../Chunk" */
+/** @import ChunkGraph from "../ChunkGraph" */
+/** @import Compilation from "../Compilation" */
 
 class AutoPublicPathRuntimeModule extends RuntimeModule {
 	constructor() {
@@ -24,22 +23,16 @@ class AutoPublicPathRuntimeModule extends RuntimeModule {
 	 */
 	generate() {
 		const compilation = /** @type {Compilation} */ (this.compilation);
-		const { scriptType, importMetaName, path, environment } =
+		// The virtual build-time chunk has no script url and sits at the output
+		// root, so urls resolve against the `importModule` baseUri.
+		if (/** @type {ChunkGraph} */ (this.chunkGraph).buildTimeExecution) {
+			return `${RuntimeGlobals.publicPath} = "";`;
+		}
+		const { scriptType, importMetaName, environment } =
 			compilation.outputOptions;
 		const chunk = /** @type {Chunk} */ (this.chunk);
-		const chunkName = compilation.getPath(
-			JavascriptModulesPlugin.getChunkFilenameTemplate(
-				chunk,
-				compilation.outputOptions
-			),
-			{
-				chunk,
-				contentHashType: "javascript"
-			}
-		);
-		const undoPath = getUndoPath(
-			chunkName,
-			/** @type {string} */ (path),
+		const undoPath = compilation.runtimeTemplate.chunkRootOutputDir(
+			chunk,
 			false
 		);
 
@@ -79,7 +72,7 @@ class AutoPublicPathRuntimeModule extends RuntimeModule {
 								"if(scripts.length) {",
 								Template.indent([
 									`${lt} i = scripts.length - 1;`,
-									"while (i > -1 && (!scriptUrl || !/^http(s?):/.test(scriptUrl))) scriptUrl = scripts[i--].src;"
+									"while (i > -1 && (!scriptUrl || !/^https?:/.test(scriptUrl))) scriptUrl = scripts[i--].src;"
 								]),
 								"}"
 							]),
@@ -90,7 +83,9 @@ 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(/^blob:/, "").replace(/#.*$/, "").replace(/\\?.*$/, "").replace(/\\/[^\\/]+$/, "/");',
+			// One pass for the `blob:` prefix and the query/fragment: both stop at the
+			// first `?` or `#`, so stripping either first leaves the same url.
+			'scriptUrl = scriptUrl.replace(/^blob:|[?#].*$/g, "").replace(/\\/[^/]+$/, "/");',
 			!undoPath
 				? `${RuntimeGlobals.publicPath} = scriptUrl;`
 				: `${RuntimeGlobals.publicPath} = scriptUrl + ${JSON.stringify(

package/lib/runtime/BaseUriRuntimeModule.js

@@ -7,15 +7,31 @@
 
 const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
+const { renderBaseUri } = require("./baseUri");
 
-/** @typedef {import("../../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescription */
-/** @typedef {import("../Chunk")} Chunk */
+/**
+ * @import {
+ * 	EntryDescriptionNormalized as EntryDescription
+ * } from "../../declarations/WebpackOptions"
+ */
+/** @import Chunk from "../Chunk" */
+/** @import Compilation from "../Compilation" */
 
 class BaseUriRuntimeModule extends RuntimeModule {
 	constructor() {
 		super("base uri", RuntimeModule.STAGE_ATTACH);
 	}
 
+	/**
+	 * Returns true, if the runtime module should get it's own scope.
+	 * When false, `generate()` must emit complete statements ending with `;`
+	 * so a following runtime IIFE is not parsed as a call (ASI).
+	 * @returns {boolean} true, if the runtime module should get it's own scope
+	 */
+	shouldIsolate() {
+		return false;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
@@ -25,11 +41,21 @@ class BaseUriRuntimeModule extends RuntimeModule {
 		const options =
 			/** @type {EntryDescription} */
 			(chunk.getEntryOptions());
-		return `${RuntimeGlobals.baseURI} = ${
-			options.baseUri === undefined
-				? "undefined"
-				: JSON.stringify(options.baseUri)
-		};`;
+		if (options.baseUri === undefined) {
+			return `${RuntimeGlobals.baseURI} = undefined;`;
+		}
+		const { runtimeTemplate, outputOptions } =
+			/** @type {Compilation} */
+			(this.compilation);
+		// Chunk loading is off here, so no loader has named a base for a relative one to be
+		// read against. Module output carries its own url; anything else has none to offer.
+		if (!runtimeTemplate.isModule()) {
+			return `${RuntimeGlobals.baseURI} = ${JSON.stringify(options.baseUri)};`;
+		}
+		return renderBaseUri(
+			options.baseUri,
+			`${outputOptions.importMetaName}.url`
+		);
 	}
 }