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

package/lib/runtime/ChunkNameRuntimeModule.js

@@ -8,6 +8,16 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 
 class ChunkNameRuntimeModule extends RuntimeModule {
+	/**
+	 * 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;
+	}
+
 	/**
 	 * @param {string} chunkName the chunk's name
 	 */

package/lib/runtime/CompatGetDefaultExportRuntimeModule.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 CompatGetDefaultExportRuntimeModule extends HelperRuntimeModule {
 	constructor() {
 		super("compat get default export");
 	}
 
+	/**
+	 * 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/CompatRuntimeModule.js

@@ -7,9 +7,9 @@
 const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Compilation")} Compilation */
+/** @import Chunk from "../Chunk" */
+/** @import ChunkGraph from "../ChunkGraph" */
+/** @import Compilation from "../Compilation" */
 
 class CompatRuntimeModule extends RuntimeModule {
 	constructor() {
@@ -74,6 +74,8 @@ class CompatRuntimeModule extends RuntimeModule {
 
 	/**
 	 * 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() {

package/lib/runtime/ConcatenationWrapRuntimeModule.js

@@ -0,0 +1,90 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const Template = require("../Template");
+const HelperRuntimeModule = require("./HelperRuntimeModule");
+
+/** @import Compilation from "../Compilation" */
+
+class ConcatenationWrapRuntimeModule extends HelperRuntimeModule {
+	constructor() {
+		super("concatenation wrap");
+	}
+
+	/**
+	 * 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
+	 */
+	generate() {
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate, outputOptions } = compilation;
+		const { strictModuleErrorHandling, strictModuleExceptionHandling } =
+			outputOptions;
+		const fn = RuntimeGlobals.concatenationWrap;
+		/** @type {string[]} */
+		const runBody = [];
+		if (strictModuleErrorHandling) {
+			// mirrors the module cache: the error is remembered and rethrown
+			runBody.push(
+				"try {",
+				Template.indent("fn.call(mod.exports, mod, mod.exports);"),
+				"} catch (e) {",
+				Template.indent(["mod.error = e;", "throw e;"]),
+				"}"
+			);
+		} else if (strictModuleExceptionHandling) {
+			// mirrors deleting the cache entry: a later call runs the body again
+			runBody.push(
+				"var threw = true;",
+				"try {",
+				Template.indent([
+					"fn.call(mod.exports, mod, mod.exports);",
+					"threw = false;"
+				]),
+				"} finally {",
+				Template.indent(["if (threw) { body = fn; mod = undefined; }"]),
+				"}"
+			);
+		} else {
+			runBody.push("fn.call(mod.exports, mod, mod.exports);");
+		}
+		return Template.asString([
+			"// wrap a concatenated module body as a lazy, memoized accessor; mod is",
+			"// set before the body runs so re-entrant calls (require cycles) observe",
+			"// the partial exports like Node.js",
+			`${fn} = ${runtimeTemplate.basicFunction("body", [
+				"var mod;",
+				`return ${runtimeTemplate.basicFunction("", [
+					"if (body) {",
+					Template.indent([
+						"var fn = body;",
+						"body = 0;",
+						"mod = { exports: {} };",
+						...runBody
+					]),
+					"}",
+					...(strictModuleErrorHandling
+						? ["if (mod.error !== undefined) throw mod.error;"]
+						: []),
+					"return mod.exports;"
+				])};`
+			])};`
+		]);
+	}
+}
+
+module.exports = ConcatenationWrapRuntimeModule;

package/lib/runtime/ConstructRequireRuntimeModule.js

@@ -0,0 +1,52 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const Template = require("../Template");
+const HelperRuntimeModule = require("./HelperRuntimeModule");
+
+/** @import Compilation from "../Compilation" */
+
+class ConstructRequireRuntimeModule extends HelperRuntimeModule {
+	constructor() {
+		super("construct require");
+	}
+
+	/**
+	 * 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
+	 */
+	generate() {
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate } = compilation;
+		const fn = RuntimeGlobals.constructRequire;
+		return Template.asString([
+			"// `new require(id)` invokes the require function as a constructor, so a",
+			"// primitive module.exports is discarded in favor of the freshly created",
+			"// instance, exactly as in Node.js. A concatenated module has no require",
+			"// call left, so apply that rule to its exports value instead.",
+			`${fn} = ${runtimeTemplate.basicFunction("exports", [
+				`${runtimeTemplate.renderConst()} isObject =`,
+				Template.indent(
+					'exports !== null && (typeof exports === "object" || typeof exports === "function");'
+				),
+				`return isObject ? exports : Object.create(${RuntimeGlobals.require}.prototype);`
+			])};`
+		]);
+	}
+}
+
+module.exports = ConstructRequireRuntimeModule;

package/lib/runtime/CreateFakeNamespaceObjectRuntimeModule.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 CreateFakeNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 	constructor() {
@@ -26,10 +26,9 @@ class CreateFakeNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 		const cst = runtimeTemplate.renderConst();
 		const lt = runtimeTemplate.renderLet();
 		return Template.asString([
-			`${cst} getProto = Object.getPrototypeOf ? ${runtimeTemplate.returningFunction(
-				"Object.getPrototypeOf(obj)",
-				"obj"
-			)} : ${runtimeTemplate.returningFunction("obj.__proto__", "obj")};`,
+			// No `__proto__` fallback: `Object.create` and `Object.defineProperty`
+			// below already require the same ES5 baseline.
+			`${cst} getProto = Object.getPrototypeOf;`,
 			`${lt} leafPrototypes;`,
 			"// create a fake namespace object",
 			"// mode & 1: value is a module id, require it",
@@ -51,7 +50,10 @@ class CreateFakeNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 				`${cst} ns = Object.create(null);`,
 				`${RuntimeGlobals.makeNamespaceObject}(ns);`,
 				`${cst} def = {};`,
-				"leafPrototypes = leafPrototypes || [null, getProto({}), getProto([]), getProto(getProto)];",
+				`${runtimeTemplate.assignOr(
+					"leafPrototypes",
+					"[null, getProto({}), getProto([]), getProto(getProto)]"
+				)};`,
 				"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(

package/lib/runtime/CreateScriptRuntimeModule.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 CreateScriptRuntimeModule extends HelperRuntimeModule {
 	constructor() {
 		super("trusted types script");
 	}
 
+	/**
+	 * 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/CreateScriptUrlRuntimeModule.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 CreateScriptUrlRuntimeModule extends HelperRuntimeModule {
 	constructor() {
 		super("trusted types script url");
 	}
 
+	/**
+	 * 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/DefinePropertyGettersRuntimeModule.js

@@ -8,11 +8,27 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const HelperRuntimeModule = require("./HelperRuntimeModule");
 
-/** @typedef {import("../Compilation")} Compilation */
+/** @import Compilation from "../Compilation" */
+/** @import { ReadOnlyRuntimeRequirements } from "../Module" */
 
 class DefinePropertyGettersRuntimeModule extends HelperRuntimeModule {
-	constructor() {
+	/**
+	 * @param {ReadOnlyRuntimeRequirements} runtimeRequirements runtime requirements
+	 */
+	constructor(runtimeRequirements) {
 		super("define property getters");
+		/** @type {ReadOnlyRuntimeRequirements} */
+		this.runtimeRequirements = runtimeRequirements;
+	}
+
+	/**
+	 * 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;
 	}
 
 	/**
@@ -23,48 +39,50 @@ class DefinePropertyGettersRuntimeModule extends HelperRuntimeModule {
 		const compilation = /** @type {Compilation} */ (this.compilation);
 		const { runtimeTemplate } = compilation;
 		const fn = RuntimeGlobals.definePropertyGetters;
+		// Only webpack emits the array form, so a build emitting none cannot
+		// receive one; the object form stays either way (see the note below).
+		const withArray = this.runtimeRequirements.has(
+			RuntimeGlobals.definePropertyGettersFromArray
+		);
+		// TODO webpack 6: remove object format support. Internal code (e.g. ConcatenatedModule)
+		// and third-party libraries may still call __webpack_require__.d() with an object.
+		const fromObject = [
+			"for(var key in definition) {",
+			Template.indent([
+				`if(${RuntimeGlobals.hasOwnProperty}(definition, key) && !${RuntimeGlobals.hasOwnProperty}(exports, key)) {`,
+				Template.indent([
+					"Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });"
+				]),
+				"}"
+			]),
+			"}"
+		];
 		return Template.asString([
 			"// define getter/value functions for harmony exports",
-			`${fn} = ${runtimeTemplate.basicFunction("exports, definition", [
-				"if(Array.isArray(definition)) {",
-				Template.indent([
-					"var i = 0;",
-					"while(i < definition.length) {",
-					Template.indent([
-						"var key = definition[i++];",
-						"var binding = definition[i++];",
-						`if(!${RuntimeGlobals.hasOwnProperty}(exports, key)) {`,
-						Template.indent([
-							"if(binding === 0) {",
+			`${fn} = ${runtimeTemplate.basicFunction(
+				"exports, definition",
+				withArray
+					? [
+							"if(Array.isArray(definition)) {",
 							Template.indent([
-								"Object.defineProperty(exports, key, { enumerable: true, value: definition[i++] });"
+								"var i = 0;",
+								"while(i < definition.length) {",
+								Template.indent([
+									"var key = definition[i++];",
+									"var binding = definition[i++];",
+									// The descriptor is built before the own-property check so a
+									// value binding consumes its slot either way.
+									"var descriptor = binding === 0 ? { enumerable: true, value: definition[i++] } : { enumerable: true, get: binding };",
+									`if(!${RuntimeGlobals.hasOwnProperty}(exports, key)) Object.defineProperty(exports, key, descriptor);`
+								]),
+								"}"
 							]),
 							"} else {",
-							Template.indent([
-								"Object.defineProperty(exports, key, { enumerable: true, get: binding });"
-							]),
+							Template.indent(fromObject),
 							"}"
-						]),
-						"} else if(binding === 0) { i++; }"
-					]),
-					"}"
-				]),
-				// TODO webpack 6: remove object format support. Internal code (e.g. ConcatenatedModule)
-				// and third-party libraries may still call __webpack_require__.d() with an object.
-				"} else {",
-				Template.indent([
-					"for(var key in definition) {",
-					Template.indent([
-						`if(${RuntimeGlobals.hasOwnProperty}(definition, key) && !${RuntimeGlobals.hasOwnProperty}(exports, key)) {`,
-						Template.indent([
-							"Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });"
-						]),
-						"}"
-					]),
-					"}"
-				]),
-				"}"
-			])};`
+						]
+					: fromObject
+			)};`
 		]);
 	}
 }

package/lib/runtime/EnsureChunkRuntimeModule.js

@@ -8,10 +8,20 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
+/** @import Compilation from "../Compilation" */
+/** @import { ReadOnlyRuntimeRequirements } from "../Module" */
 
 class EnsureChunkRuntimeModule extends RuntimeModule {
+	/**
+	 * 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;
+	}
+
 	/**
 	 * @param {ReadOnlyRuntimeRequirements} runtimeRequirements runtime requirements
 	 */
@@ -28,12 +38,18 @@ class EnsureChunkRuntimeModule extends RuntimeModule {
 	generate() {
 		const compilation = /** @type {Compilation} */ (this.compilation);
 		const { runtimeTemplate } = compilation;
+		// An analyzable `import()` dispatches the handlers itself, so a build can need the
+		// map without the function around it.
+		const withEnsureChunk = this.runtimeRequirements.has(
+			RuntimeGlobals.ensureChunk
+		);
 		// Check if there are non initial chunks which need to be imported using require-ensure
 		if (this.runtimeRequirements.has(RuntimeGlobals.ensureChunkHandlers)) {
 			const withFetchPriority = this.runtimeRequirements.has(
 				RuntimeGlobals.hasFetchPriority
 			);
 			const handlers = RuntimeGlobals.ensureChunkHandlers;
+			if (!withEnsureChunk) return `${handlers} = {};`;
 			return Template.asString([
 				`${handlers} = {};`,
 				"// This file contains only the entry chunk.",

package/lib/runtime/GetChunkFilenameRuntimeModule.js

@@ -10,15 +10,26 @@ const Template = require("../Template");
 const { reEncodeDigest } = require("../TemplatedPathPlugin");
 const { first } = require("../util/SetHelpers");
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Chunk").ChunkId} ChunkId */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Compilation").HashWithLengthFunction} HashWithLengthFunction */
-/** @typedef {import("../Compilation").HashWithDigestFunction} HashWithDigestFunction */
-/** @typedef {import("../Chunk").ChunkFilenameTemplate} ChunkFilenameTemplate */
+/** @import Chunk, { ChunkId, ChunkFilenameTemplate } from "../Chunk" */
+/** @import ChunkGraph from "../ChunkGraph" */
+/**
+ * @import Compilation, {
+ * 	HashWithLengthFunction,
+ * 	HashWithDigestFunction
+ * } from "../Compilation"
+ */
 
 class GetChunkFilenameRuntimeModule extends RuntimeModule {
+	/**
+	 * 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;
+	}
+
 	/**
 	 * @param {string} contentType the contentType to use the content hash for
 	 * @param {string} name kind of filename
@@ -173,6 +184,15 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 		/** @type {Set<Chunk>} */
 		const dynamicUrlChunks = new Set();
 
+		/**
+		 * Drops the dead empty string a leading placeholder leaves, only when a
+		 * quoted operand ends the expression so the `+` chain stays a string.
+		 * @param {string} expr concatenation expression
+		 * @returns {string} the expression without its dead empty string
+		 */
+		const dropDeadConcatOperand = (expr) =>
+			expr.startsWith('"" + ') && expr.endsWith('"') ? expr.slice(5) : expr;
+
 		/**
 		 * @param {Chunk} c the chunk
 		 * @param {ChunkFilenameTemplate} chunkFilename the filename template for the chunk
@@ -244,9 +264,10 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 				},
 				contentHashType: contentType
 			});
-			let set = staticUrls.get(staticChunkFilename);
+			const url = dropDeadConcatOperand(staticChunkFilename);
+			let set = staticUrls.get(url);
 			if (set === undefined) {
-				staticUrls.set(staticChunkFilename, (set = new Set()));
+				staticUrls.set(url, (set = new Set()));
 			}
 			set.add(c.id);
 		};
@@ -306,7 +327,7 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 		const mapExprWithLength = (fn) => (length) =>
 			`" + ${createMap((c) => `${fn(c)}`.slice(0, length))} + "`;
 
-		const url =
+		const dynamicUrl =
 			dynamicFilename &&
 			compilation.getPath(JSON.stringify(dynamicFilename), {
 				hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
@@ -343,35 +364,39 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 				},
 				contentHashType: contentType
 			});
+		const url = dynamicUrl && dropDeadConcatOperand(dynamicUrl);
 
+		const comment = `// This function allow to reference ${includedChunksMessages.join(
+			" and "
+		)}`;
+		// Nothing to branch on, so the whole function is the template expression.
+		if (staticUrls.size === 0) {
+			return Template.asString([
+				comment,
+				// `url` is `undefined` when no chunk contributes a filename; the
+				// function then returns `undefined`, as it did before.
+				`${global} = ${runtimeTemplate.returningFunction(`${url}`, "chunkId")};`
+			]);
+		}
 		return Template.asString([
-			`// This function allow to reference ${includedChunksMessages.join(
-				" and "
-			)}`,
-			`${global} = ${runtimeTemplate.basicFunction(
-				"chunkId",
-
-				staticUrls.size > 0
-					? [
-							"// return url for filenames not based on template",
-							// it minimizes to `x===1?"...":x===2?"...":"..."`
-							Template.asString(
-								Array.from(staticUrls, ([url, ids]) => {
-									const condition =
-										ids.size === 1
-											? `chunkId === ${JSON.stringify(first(ids))}`
-											: `{${Array.from(
-													ids,
-													(id) => `${JSON.stringify(id)}:1`
-												).join(",")}}[chunkId]`;
-									return `if (${condition}) return ${url};`;
-								})
-							),
-							"// return url for filenames based on template",
-							`return ${url};`
-						]
-					: ["// return url for filenames based on template", `return ${url};`]
-			)};`
+			comment,
+			`${global} = ${runtimeTemplate.basicFunction("chunkId", [
+				"// return url for filenames not based on template",
+				// it minimizes to `x===1?"...":x===2?"...":"..."`
+				Template.asString(
+					Array.from(staticUrls, ([url, ids]) => {
+						const condition =
+							ids.size === 1
+								? `chunkId === ${JSON.stringify(first(ids))}`
+								: `{${Array.from(ids, (id) => `${JSON.stringify(id)}:1`).join(
+										","
+									)}}[chunkId]`;
+						return `if (${condition}) return ${url};`;
+					})
+				),
+				"// return url for filenames based on template",
+				`return ${url};`
+			])};`
 		]);
 	}
 }

package/lib/runtime/GetFullHashRuntimeModule.js

@@ -7,7 +7,7 @@
 const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 
-/** @typedef {import("../Compilation")} Compilation */
+/** @import Compilation from "../Compilation" */
 
 class GetFullHashRuntimeModule extends RuntimeModule {
 	constructor() {
@@ -16,6 +16,16 @@ class GetFullHashRuntimeModule extends RuntimeModule {
 		this.fullHash = true;
 	}
 
+	/**
+	 * 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,7 +35,7 @@ class GetFullHashRuntimeModule extends RuntimeModule {
 		const { runtimeTemplate } = compilation;
 		return `${RuntimeGlobals.getFullHash} = ${runtimeTemplate.returningFunction(
 			JSON.stringify(compilation.hash || "XXXX")
-		)}`;
+		)};`;
 	}
 }
 

package/lib/runtime/GetMainFilenameRuntimeModule.js

@@ -8,10 +8,20 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compilation")} Compilation */
+/** @import Chunk from "../Chunk" */
+/** @import Compilation from "../Compilation" */
 
 class GetMainFilenameRuntimeModule extends RuntimeModule {
+	/**
+	 * 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;
+	}
+
 	/**
 	 * @param {string} name readable name
 	 * @param {string} global global object binding

package/lib/runtime/GetTrustedTypesPolicyRuntimeModule.js

@@ -8,8 +8,8 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const HelperRuntimeModule = require("./HelperRuntimeModule");
 
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
+/** @import Compilation from "../Compilation" */
+/** @import { ReadOnlyRuntimeRequirements } from "../Module" */
 
 class GetTrustedTypesPolicyRuntimeModule extends HelperRuntimeModule {
 	/**