webpack 5.112.0 → 5.112.1

package/lib/dependencies/esm/ESMImportDependency.js

@@ -23,7 +23,7 @@ const ModuleDependency = require("../core/ModuleDependency");
  * 	JavascriptParserOptions
  * } from "../../../declarations/WebpackOptions"
  */
-/** @import { ReferencedExports, DependencyKinds, LazyRole } from "../../graph/Dependency" */
+/** @import { ReferencedExports, DependencyKinds, LazyRole, UpdateHashContext } from "../../graph/Dependency" */
 /** @import { DependencyTemplateContext } from "../../template/DependencyTemplate" */
 /** @import ExportsInfo from "../../graph/ExportsInfo" */
 /** @import Module, { BuildMeta } from "../../module/Module" */
@@ -37,6 +37,7 @@ const ModuleDependency = require("../core/ModuleDependency");
  * 	ObjectSerializerContext
  * } from "../../serialization/ObjectMiddleware"
  */
+/** @import Hash from "../../util/Hash" */
 /** @import { RuntimeSpec } from "../../util/runtime" */
 
 /** @typedef {0 | 1 | 2 | 3} ExportPresenceMode */
@@ -146,6 +147,20 @@ class ESMImportDependency extends ModuleDependency {
 		return "esm";
 	}
 
+	/**
+	 * Updates the hash with the data contributed by this instance.
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		// neither a deferred nor a missing target has a connection, yet only a
+		// missing one renders a throw
+		if (LazyBarrels.isLazy(context.chunkGraph.moduleGraph, this)) {
+			hash.update("lazy");
+		}
+	}
+
 	/**
 	 * Returns how this dependency may be deferred when its parent module is side-effect-free (lazy barrel optimization).
 	 * @returns {LazyRole | null} lazy classification, null when it must be processed eagerly
@@ -522,7 +537,7 @@ ESMImportDependency.Template = class ESMImportDependencyTemplate extends (
 			// When the consuming module is emitted as a generator (target without
 			// `async`/`await`), the dependency `await` must become `yield`.
 			const generatorLowered = isGeneratorLowered(
-				/** @type {Module} */ (module),
+				module,
 				moduleGraph,
 				templateContext.runtimeTemplate
 			);

package/lib/dependencies/esm/ESMImportDependencyParserPlugin.js

@@ -50,7 +50,6 @@ const ESMImportSpecifierDependency = require("./ESMImportSpecifierDependency");
  * } from "../../../declarations/WebpackOptions"
  */
 /** @import Module from "../../module/Module" */
-/** @import { JavascriptModuleBuildInfo } from "../../javascript/JavascriptModule" */
 /**
  * @import JavascriptParser, {
  * 	ImportAttributes,
@@ -155,14 +154,11 @@ const findImportSpecifier = (parser, node) => {
 				(parser.getTagData(node.name, harmonySpecifierTag))
 			);
 		case "UnaryExpression":
-			return findImportSpecifier(
-				parser,
-				/** @type {Expression} */ (node.argument)
-			);
+			return findImportSpecifier(parser, node.argument);
 		case "LogicalExpression":
 			return (
-				findImportSpecifier(parser, /** @type {Expression} */ (node.left)) ||
-				findImportSpecifier(parser, /** @type {Expression} */ (node.right))
+				findImportSpecifier(parser, node.left) ||
+				findImportSpecifier(parser, node.right)
 			);
 		case "MemberExpression":
 			return findImportSpecifier(
@@ -171,10 +167,7 @@ const findImportSpecifier = (parser, node) => {
 			);
 		case "BinaryExpression":
 			// `"x" in ns` presence guard
-			return (
-				node.operator === "in" &&
-				findImportSpecifier(parser, /** @type {Expression} */ (node.right))
-			);
+			return node.operator === "in" && findImportSpecifier(parser, node.right);
 		default:
 			return false;
 	}
@@ -444,8 +437,7 @@ class ESMImportDependencyParserPlugin {
 		 * @returns {void}
 		 */
 		const bailOutOfConcatenation = () => {
-			/** @type {JavascriptModuleBuildInfo} */
-			(parser.state.module.buildInfo).moduleConcatenationBailout =
+			parser.state.module.buildInfo.moduleConcatenationBailout =
 				"assignment to an imported binding";
 		};
 
@@ -483,10 +475,7 @@ class ESMImportDependencyParserPlugin {
 		});
 		parser.hooks.write.for(harmonySpecifierTag).tap(PLUGIN_NAME, (node) => {
 			const written = writeTargetOf(node);
-			const target =
-				written.type === "Identifier"
-					? /** @type {Identifier} */ (written)
-					: undefined;
+			const target = written.type === "Identifier" ? written : undefined;
 			markImportedBindingWrite(node, target);
 			// A loop's binding walks nothing on its own, so the reference the
 			// write renders as has to be walked here to exist at all.

package/lib/dependencies/esm/ESMImportGuard.js

@@ -74,7 +74,7 @@ const buildLivenessFormula = (test, depByRangeStart) => {
 	 */
 	const build = (node) => {
 		if (node.type === "UnaryExpression" && node.operator === "!") {
-			return ["!", build(/** @type {Expression} */ (node.argument))];
+			return ["!", build(node.argument)];
 		}
 		if (
 			node.type === "LogicalExpression" &&
@@ -82,14 +82,9 @@ const buildLivenessFormula = (test, depByRangeStart) => {
 				node.operator === "||" ||
 				node.operator === "??")
 		) {
-			return [
-				node.operator,
-				build(/** @type {Expression} */ (node.left)),
-				build(/** @type {Expression} */ (node.right))
-			];
+			return [node.operator, build(node.left), build(node.right)];
 		}
-		const dep =
-			node.range && depByRangeStart.get(/** @type {number} */ (node.range[0]));
+		const dep = node.range && depByRangeStart.get(node.range[0]);
 		return dep ? ["v", dep] : ["?"];
 	};
 
@@ -243,23 +238,19 @@ const buildPresenceFormula = (parser, test, depByRangeStart) => {
 	 */
 	const build = (node) => {
 		if (node.type === "UnaryExpression" && node.operator === "!") {
-			return ["!", build(/** @type {Expression} */ (node.argument))];
+			return ["!", build(node.argument)];
 		}
 		if (node.type === "LogicalExpression") {
 			if (node.operator === "&&") {
-				return [
-					"&&",
-					build(/** @type {Expression} */ (node.left)),
-					build(/** @type {Expression} */ (node.right))
-				];
+				return ["&&", build(node.left), build(node.right)];
 			}
 
 			if (node.operator === "||") {
 				if (parser.evaluateExpression(node.left).asBool() === false) {
-					return build(/** @type {Expression} */ (node.right));
+					return build(node.right);
 				}
 				if (parser.evaluateExpression(node.right).asBool() === false) {
-					return build(/** @type {Expression} */ (node.left));
+					return build(node.left);
 				}
 				return ["?"];
 			}
@@ -267,16 +258,15 @@ const buildPresenceFormula = (parser, test, depByRangeStart) => {
 			if (node.operator === "??") {
 				const nullish = parser.evaluateExpression(node.left).asNullish();
 				if (nullish === true) {
-					return build(/** @type {Expression} */ (node.right));
+					return build(node.right);
 				}
 				if (nullish === false) {
-					return build(/** @type {Expression} */ (node.left));
+					return build(node.left);
 				}
 				return ["?"];
 			}
 		}
-		const dep =
-			node.range && depByRangeStart.get(/** @type {number} */ (node.range[0]));
+		const dep = node.range && depByRangeStart.get(node.range[0]);
 		return dep ? ["p", dep] : ["?"];
 	};
 
@@ -298,9 +288,7 @@ const buildPresenceFormula = (parser, test, depByRangeStart) => {
 const evalPresenceFormula = (formula, name, member, needTruthy) => {
 	switch (formula[0]) {
 		case "p": {
-			const dep = /** @type {ESMEvaluatedImportSpecifierDependency} */ (
-				formula[1]
-			);
+			const dep = formula[1];
 			return (
 				needTruthy &&
 				dep.directImport === true &&

package/lib/dependencies/esm/ESMImportSideEffectDependency.js

@@ -279,7 +279,7 @@ ESMImportSideEffectDependency.Template = class ESMImportSideEffectDependencyTemp
 		const exportsType = importedModule.getExportsType(
 			moduleGraph,
 			/** @type {JavascriptModuleBuildMeta} */
-			(/** @type {Module} */ (module).buildMeta).strictHarmonyModule
+			(module.buildMeta).strictHarmonyModule
 		);
 		if (exportsType !== "namespace") return;
 		const importVar = dep.getImportVar(moduleGraph);

package/lib/dependencies/esm/ESMImportSpecifierDependency.js

@@ -169,7 +169,10 @@ class ESMImportSpecifierDependency extends ESMImportDependency {
 	 * @returns {string | true | null} export name, true for all exports, null for none
 	 */
 	get forwardId() {
-		return this.ids.length > 0 ? this.ids[0] : true;
+		// SideEffectsFlagPlugin keeps a call with the namespace as `this` on the
+		// barrel, so the barrel runs whole
+		if (this.ids.length === 0 || this.namespaceObjectAsContext) return true;
+		return this.ids[0];
 	}
 
 	/**

package/lib/dependencies/esm/ESMLiveExportDependency.js

@@ -0,0 +1,311 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../../runtime/RuntimeGlobals");
+const makeSerializable = require("../../util/makeSerializable");
+const { propertyAccess } = require("../../util/property");
+const { getRuntimeKey } = require("../../util/runtime");
+const NullDependency = require("../core/NullDependency");
+
+// ReplaceSource sorts fractional positions before flooring them to source offsets.
+// Value wrappers open before sync calls and close after them; statement inserts
+// and body closures follow both.
+const SYNC_START_OFFSET = 0.5;
+const VALUE_END_OFFSET = 0.5;
+const AFTER_VALUE_OFFSET = 0.75;
+
+/** @import { ReplaceSource } from "webpack-sources" */
+/** @import Dependency, { DependencyKinds, UpdateHashContext } from "../../graph/Dependency" */
+/** @import ModuleGraph, { LiveBinding } from "../../graph/ModuleGraph" */
+/** @import Module from "../../module/Module" */
+/** @import { DependencyTemplateContext } from "../../template/DependencyTemplate" */
+/** @import Hash from "../../util/Hash" */
+/** @import { RuntimeSpec } from "../../util/runtime" */
+/** @typedef {import("../../serialization/ObjectMiddleware").ObjectDeserializerContext<[string[], number[], number[], boolean, boolean, boolean]>} ObjectDeserializerContext */
+/** @typedef {import("../../serialization/ObjectMiddleware").ObjectSerializerContext<[string[], number[], number[], boolean, boolean, boolean]>} ObjectSerializerContext */
+
+/**
+ * The names the chunk's scope declares for a declaration, and how the module keeps them.
+ * @typedef {object} HoistedNames
+ * @property {string[]} names the declared name of each name
+ * @property {boolean} mirrored whether the module keeps its declaration and mirrors each write
+ * @property {boolean} registered whether it mirrors them through the setters a module library registers
+ */
+
+/**
+ * A module-level binding a module library may declare in the chunk's scope under a
+ * reserved name, so the library exports the binding itself; it holds every reference,
+ * and every write a module keeping its declaration mirrors there instead.
+ */
+class ESMLiveExportDependency extends NullDependency {
+	/**
+	 * Creates an instance of ESMLiveExportDependency.
+	 * @param {string[]} names every name the declaration declares
+	 * @param {number[]} occurrences flat triples of start, end and `name index * KINDS_PER_NAME + kind` renaming takes, a kind from {@link ESMLiveExportDependency.REFERENCE}
+	 * @param {number[]} mirrors the same triples for where a module keeping its declaration mirrors a write, a kind from {@link ESMLiveExportDependency.SYNC}
+	 * @param {boolean} readByEval whether the module calls `eval`, which reads the names as written
+	 * @param {boolean} hot whether a hot update replaces the module, which then only mirrors, as renaming cannot reach it
+	 * @param {boolean} earlyUse whether the module uses a `let` or class above its declaration, where only its own declaration throws
+	 */
+	constructor(names, occurrences, mirrors, readByEval, hot, earlyUse) {
+		super();
+		this.names = names;
+		this.occurrences = occurrences;
+		this.mirrors = mirrors;
+		this.readByEval = readByEval;
+		this.hot = hot;
+		this.earlyUse = earlyUse;
+	}
+
+	get type() {
+		return "harmony live export";
+	}
+
+	/**
+	 * Returns the names the chunk's scope declares for this runtime, if it does.
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {RuntimeSpec} runtime the runtime the module is generated for
+	 * @returns {HoistedNames | undefined} the names and how the module keeps them
+	 */
+	getHoistedNames(moduleGraph, runtime) {
+		const meta = moduleGraph.getMetaIfExisting(
+			/** @type {Module} */ (moduleGraph.getParentModule(this))
+		);
+		if (meta === undefined) return;
+		const runtimeKey = getRuntimeKey(runtime);
+		for (const bindings of [meta.liveSetters, meta.liveBindings]) {
+			if (bindings === undefined) continue;
+			const first = bindings.get(this.names[0]);
+			if (first === undefined || !first.runtimes.has(runtimeKey)) continue;
+			return {
+				names: this.names.map(
+					(name) => /** @type {LiveBinding} */ (bindings.get(name)).name
+				),
+				mirrored: bindings === meta.liveSetters,
+				registered: first.registered.has(runtimeKey)
+			};
+		}
+	}
+
+	/**
+	 * Updates the hash with the data contributed by this instance.
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		const hoisted = this.getHoistedNames(
+			context.chunkGraph.moduleGraph,
+			context.runtime
+		);
+		if (hoisted === undefined) return;
+		hash.update(
+			`${hoisted.names.join()}|${hoisted.mirrored}|${hoisted.registered}`
+		);
+	}
+
+	/**
+	 * Serializes this instance into the provided serializer context.
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		context
+			.write(this.names)
+			.write(this.occurrences)
+			.write(this.mirrors)
+			.write(this.readByEval)
+			.write(this.hot)
+			.write(this.earlyUse);
+		super.serialize(context);
+	}
+
+	/**
+	 * Restores this instance from the provided deserializer context.
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		this.names = context.read();
+		const c1 = context.rest;
+		this.occurrences = c1.read();
+		const c2 = c1.rest;
+		this.mirrors = c2.read();
+		const c3 = c2.rest;
+		this.readByEval = c3.read();
+		const c4 = c3.rest;
+		this.hot = c4.read();
+		const c5 = c4.rest;
+		this.earlyUse = c5.read();
+		super.deserialize(c5.rest);
+	}
+}
+
+makeSerializable(
+	ESMLiveExportDependency,
+	"webpack/lib/dependencies/esm/ESMLiveExportDependency"
+);
+
+ESMLiveExportDependency.Template = class ESMLiveExportDependencyTemplate extends (
+	NullDependency.Template
+) {
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(
+		dependency,
+		source,
+		{ moduleGraph, chunkGraph, module, runtime, runtimeRequirements }
+	) {
+		const dep = /** @type {ESMLiveExportDependency} */ (dependency);
+		const hoisted = dep.getHoistedNames(moduleGraph, runtime);
+		if (hoisted === undefined) return;
+		const { occurrences, mirrors, names } = dep;
+		const kinds = ESMLiveExportDependency.KINDS_PER_NAME;
+		if (hoisted.mirrored) {
+			const id = hoisted.registered
+				? JSON.stringify(chunkGraph.getModuleId(module))
+				: "";
+			if (hoisted.registered) runtimeRequirements.add(RuntimeGlobals.require);
+			/** @type {string[]} */
+			const helpers = [];
+			for (let index = 0; index < names.length; index++) {
+				const name = names[index];
+				const helper = `__webpack_live_sync_${name}__`;
+				helpers.push(helper);
+				// Hoisted, so any write may call it; a value passed with `v` set is what
+				// the binding is about to hold, read before the binding is initialized.
+				const sync = hoisted.registered
+					? `\tvar s = ${RuntimeGlobals.liveExportSetters};\n` +
+						`\ts = s && s[${id}];\n` +
+						`\ts = s && s${propertyAccess([name])};\n` +
+						`\tif (s) for (var i = 0; i < s.length; i++) s[i](v ? r : ${name});\n`
+					: `\t${hoisted.names[index]} = v ? r : ${name};\n`;
+				source.insert(
+					0,
+					`function ${helper}(r, v) {\n${
+						// an eval() call may come before the binding is initialized
+						dep.readByEval
+							? `\ttry {\n\t${sync.replace(/\n\t/g, "\n\t\t")}\t} catch (e) {}\n`
+							: sync
+					}\treturn r;\n}\n`
+				);
+			}
+			for (let i = 0; i < mirrors.length; i += 3) {
+				const start = mirrors[i];
+				const end = mirrors[i + 1];
+				const helper = helpers[Math.floor(mirrors[i + 2] / kinds)];
+				switch (mirrors[i + 2] % kinds) {
+					case ESMLiveExportDependency.SYNC:
+						source.insert(start + SYNC_START_OFFSET, `${helper}(`);
+						source.insert(end, ")");
+						break;
+					case ESMLiveExportDependency.VALUE:
+						source.insert(start, `${helper}((`);
+						source.insert(end + VALUE_END_OFFSET, "), 1)");
+						break;
+					case ESMLiveExportDependency.NAMED_VALUE: {
+						// A property key gives the function or class the name the binding did
+						const name = names[Math.floor(mirrors[i + 2] / kinds)];
+						source.insert(start, `${helper}({ ${name}: `);
+						source.insert(end + VALUE_END_OFFSET, ` }.${name}, 1)`);
+						break;
+					}
+					case ESMLiveExportDependency.UNDEFINED:
+						source.insert(start, ` = ${helper}(void 0, 1)`);
+						break;
+					case ESMLiveExportDependency.STATEMENT:
+						source.insert(start + AFTER_VALUE_OFFSET, `;${helper}();\n`);
+						break;
+					case ESMLiveExportDependency.DECLARATOR:
+						source.insert(
+							start + AFTER_VALUE_OFFSET,
+							`, __webpack_live_synced__ = ${helper}()`
+						);
+						break;
+					default:
+						source.insert(start, `{;${helper}();`);
+						source.insert(end + AFTER_VALUE_OFFSET, "}");
+				}
+			}
+			return;
+		}
+		for (let i = 0; i < occurrences.length; i += 3) {
+			const start = occurrences[i];
+			const end = occurrences[i + 1];
+			const index = Math.floor(occurrences[i + 2] / kinds);
+			switch (occurrences[i + 2] % kinds) {
+				case ESMLiveExportDependency.KEYWORD:
+					source.replace(start, end - 1, "");
+					break;
+				case ESMLiveExportDependency.REFERENCE:
+					source.replace(start, end - 1, hoisted.names[index]);
+					break;
+				case ESMLiveExportDependency.SHORTHAND:
+					source.replace(
+						start,
+						end - 1,
+						`${names[index]}: ${hoisted.names[index]}`
+					);
+					break;
+				case ESMLiveExportDependency.NAMED:
+					// A property key gives the function or class the name the binding did
+					source.insert(start, `{ ${names[index]}: `);
+					source.insert(end, ` }.${names[index]}`);
+					break;
+				case ESMLiveExportDependency.PARENTHESIZED:
+					source.insert(start, "(");
+					source.insert(end, ")");
+					break;
+				default:
+					source.insert(
+						start,
+						`\n${hoisted.names[index]} = ${names[index]};\n`
+					);
+			}
+		}
+	}
+};
+
+/** An occurrence the hoisted name replaces */
+ESMLiveExportDependency.REFERENCE = 0;
+/** A shorthand property, which keeps its key */
+ESMLiveExportDependency.SHORTHAND = 1;
+/** An anonymous function or class the binding names */
+ESMLiveExportDependency.NAMED = 2;
+/** A declaration's `let` or `var`, dropped with the space up to its first name */
+ESMLiveExportDependency.KEYWORD = 3;
+/** A destructuring declarator that, without its keyword, needs parentheses */
+ESMLiveExportDependency.PARENTHESIZED = 4;
+/** Where a function or class declaration, which stays, sets the binding */
+ESMLiveExportDependency.INITIALIZE = 5;
+/** A write a hot module mirrors once it ran, wrapped in the name's sync call */
+ESMLiveExportDependency.SYNC = 6;
+/** A declarator's initializer, mirrored as the value the binding takes */
+ESMLiveExportDependency.VALUE = 7;
+/** An anonymous function or class initializer, mirrored under the name it takes */
+ESMLiveExportDependency.NAMED_VALUE = 8;
+/** A declarator without an initializer, mirrored as `undefined` */
+ESMLiveExportDependency.UNDEFINED = 9;
+/** Where a statement mirrors the binding, after a declaration or a loop's next value */
+ESMLiveExportDependency.STATEMENT = 10;
+/** A loop body that is not a block, wrapped in one mirroring the loop's next value */
+ESMLiveExportDependency.BODY = 11;
+/** The end of a loop's `var` head, where a declarator mirrors what a pattern took */
+ESMLiveExportDependency.DECLARATOR = 12;
+/** How many kinds an occurrence's third number tells apart per name */
+ESMLiveExportDependency.KINDS_PER_NAME = 13;
+
+/** @type {Set<keyof DependencyKinds>} */
+ESMLiveExportDependency.KINDS = new Set([
+	...NullDependency.KINDS,
+	"esm-live-export"
+]);
+
+module.exports = ESMLiveExportDependency;