@depup/webpack 5.109.0-depup.0 → 5.110.1-depup.0

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 {
 	/**

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`
+		);
 	}
 }
 

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.",