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

package/lib/dependencies/HarmonyAcceptDependency.js

@@ -12,11 +12,11 @@ const HarmonyImportDependency = require("./HarmonyImportDependency");
 const { ImportPhaseUtils } = require("./ImportPhase");
 const NullDependency = require("./NullDependency");
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("./HarmonyAcceptImportDependency")} HarmonyAcceptImportDependency */
+/** @import { ReplaceSource } from "webpack-sources" */
+/** @import Dependency from "../Dependency" */
+/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
+/** @import { Range } from "../javascript/JavascriptParser" */
+/** @import HarmonyAcceptImportDependency from "./HarmonyAcceptImportDependency" */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Range, HarmonyAcceptImportDependency[], boolean]>} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[Range, HarmonyAcceptImportDependency[], boolean]>} ObjectSerializerContext */
 

package/lib/dependencies/HarmonyCompatibilityDependency.js

@@ -10,12 +10,23 @@ const InitFragment = require("../InitFragment");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const isGeneratorLowered = require("../async-modules/isGeneratorLowered");
 const makeSerializable = require("../util/makeSerializable");
+const memoize = require("../util/memoize");
 const NullDependency = require("./NullDependency");
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../Module").BuildMeta} BuildMeta */
+// Required here rather than at the top: the plugin reaches back into the dependencies.
+const getJavascriptModulesPlugin = memoize(() =>
+	require("../javascript/JavascriptModulesPlugin")
+);
+
+/** @import { ReplaceSource } from "webpack-sources" */
+/** @import Dependency from "../Dependency" */
+/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
+/** @import { BuildMeta } from "../Module" */
+/**
+ * @import {
+ * 	JavascriptModuleBuildInfo
+ * } from "../javascript/JavascriptModule"
+ */
 
 class HarmonyCompatibilityDependency extends NullDependency {
 	get type() {
@@ -51,7 +62,8 @@ HarmonyCompatibilityDependency.Template = class HarmonyExportDependencyTemplate
 			concatenationScope
 		}
 	) {
-		if (concatenationScope) return;
+		// a wrapped module has a real exports object that still needs `__esModule`
+		if (concatenationScope && !concatenationScope.isWrapped()) return;
 		const exportsInfo = moduleGraph.getExportsInfo(module);
 		if (
 			exportsInfo.getReadOnlyExportInfo("__esModule").getUsed(runtime) !==
@@ -61,20 +73,43 @@ HarmonyCompatibilityDependency.Template = class HarmonyExportDependencyTemplate
 				exportsArgument: module.exportsArgument,
 				runtimeRequirements
 			});
-			initFragments.push(
-				new InitFragment(
-					content,
-					InitFragment.STAGE_HARMONY_EXPORTS,
-					0,
-					"harmony compatibility"
-				)
+			// A library exporting the same bindings natively never reads the marker back
+			// off the exports object, so it takes the call over and emits it where wrapped.
+			const hooks = getJavascriptModulesPlugin().getCompilationHooks(
+				runtimeTemplate.compilation
 			);
+			const takenOver =
+				hooks.onDemandExportsGeneration.isUsed() &&
+				hooks.onDemandExportsGeneration.call(
+					module,
+					runtime,
+					content,
+					false
+				) === true;
+			if (!takenOver) {
+				initFragments.push(
+					new InitFragment(
+						content,
+						InitFragment.STAGE_HARMONY_EXPORTS,
+						0,
+						"harmony compatibility"
+					)
+				);
+			}
 		}
 		if (moduleGraph.isAsync(module)) {
 			runtimeRequirements.add(RuntimeGlobals.module);
 			const hasAwait = /** @type {BuildMeta} */ (module.buildMeta).async
 				? ", 1"
 				: "";
+			// A module-scope `await using` is disposed when its scope ends, so the body
+			// needs a block that closes before the module reports completion —
+			// otherwise dependents run before disposal is awaited.
+			const usesTopLevelUsingDeclaration =
+				/** @type {JavascriptModuleBuildInfo} */
+				(module.buildInfo).usesTopLevelUsingDeclaration;
+			const blockStart = usesTopLevelUsingDeclaration ? " {" : "";
+			const blockEnd = usesTopLevelUsingDeclaration ? "\n}" : "";
 			// Target has no `async`/`await` but has generators: drive the body as a
 			// generator so `await` becomes `yield`, keeping the module in a single
 			// scope (unlike a `.then` callback) without transpiling to a state machine.
@@ -82,11 +117,11 @@ HarmonyCompatibilityDependency.Template = class HarmonyExportDependencyTemplate
 				runtimeRequirements.add(RuntimeGlobals.asyncModuleGenerator);
 				initFragments.push(
 					new InitFragment(
-						`${RuntimeGlobals.asyncModule}(${module.moduleArgument}, ${RuntimeGlobals.asyncModuleGenerator}(function* (__webpack_handle_async_dependencies__, __webpack_async_result__) { try {\n`,
+						`${RuntimeGlobals.asyncModule}(${module.moduleArgument}, ${RuntimeGlobals.asyncModuleGenerator}(function* (__webpack_handle_async_dependencies__, __webpack_async_result__) { try {${blockStart}\n`,
 						InitFragment.STAGE_ASYNC_BOUNDARY,
 						0,
 						undefined,
-						`\n__webpack_async_result__();\n} catch(e) { __webpack_async_result__(e); } })${hasAwait});`
+						`${blockEnd}\n__webpack_async_result__();\n} catch(e) { __webpack_async_result__(e); } })${hasAwait});`
 					)
 				);
 			} else {
@@ -94,12 +129,12 @@ HarmonyCompatibilityDependency.Template = class HarmonyExportDependencyTemplate
 				initFragments.push(
 					new InitFragment(
 						runtimeTemplate.supportsArrowFunction()
-							? `${RuntimeGlobals.asyncModule}(${module.moduleArgument}, async (__webpack_handle_async_dependencies__, __webpack_async_result__) => { try {\n`
-							: `${RuntimeGlobals.asyncModule}(${module.moduleArgument}, async function (__webpack_handle_async_dependencies__, __webpack_async_result__) { try {\n`,
+							? `${RuntimeGlobals.asyncModule}(${module.moduleArgument}, async (__webpack_handle_async_dependencies__, __webpack_async_result__) => { try {${blockStart}\n`
+							: `${RuntimeGlobals.asyncModule}(${module.moduleArgument}, async function (__webpack_handle_async_dependencies__, __webpack_async_result__) { try {${blockStart}\n`,
 						InitFragment.STAGE_ASYNC_BOUNDARY,
 						0,
 						undefined,
-						`\n__webpack_async_result__();\n} catch(e) { __webpack_async_result__(e); } }${hasAwait});`
+						`${blockEnd}\n__webpack_async_result__();\n} catch(e) { __webpack_async_result__(e); } }${hasAwait});`
 					)
 				);
 			}

package/lib/dependencies/HarmonyDetectionParserPlugin.js

@@ -6,7 +6,8 @@
 "use strict";
 
 const { JAVASCRIPT_MODULE_TYPE_ESM } = require("../ModuleTypeConstants");
-const EnvironmentNotSupportAsyncWarning = require("../errors/EnvironmentNotSupportAsyncWarning");
+const memoize = require("../util/memoize");
+
 const DynamicExports = require("./DynamicExports");
 const HarmonyCompatibilityDependency = require("./HarmonyCompatibilityDependency");
 const HarmonyExports = require("./HarmonyExports");
@@ -16,10 +17,12 @@ const {
 } = require("./ImportMetaPlugin");
 const TopLevelAwaitDependency = require("./TopLevelAwaitDependency");
 
-/** @typedef {import("../Module").BuildInfo} BuildInfo */
-/** @typedef {import("../Module").BuildMeta} BuildMeta */
-/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+const getEnvironmentNotSupportAsyncWarning = memoize(() =>
+	require("../errors/EnvironmentNotSupportAsyncWarning")
+);
+
+/** @import { BuildInfo, BuildMeta } from "../Module" */
+/** @import JavascriptParser, { Range } from "../javascript/JavascriptParser" */
 
 const PLUGIN_NAME = "HarmonyDetectionParserPlugin";
 
@@ -90,7 +93,8 @@ module.exports = class HarmonyDetectionParserPlugin {
 					)
 				);
 			} else {
-				// `for await…of` can't be expressed as a generator; never lower it.
+				// `for await…of` and `await using` can't be expressed as a generator;
+				// never lower it.
 				buildInfo.usesTopLevelAwaitForOf = true;
 			}
 			const { runtimeTemplate } = parser.state.compilation;
@@ -100,7 +104,7 @@ module.exports = class HarmonyDetectionParserPlugin {
 					buildInfo.usesTopLevelAwaitForOf)
 			) {
 				module.addWarning(
-					new EnvironmentNotSupportAsyncWarning(module, "topLevelAwait")
+					new (getEnvironmentNotSupportAsyncWarning())(module, "topLevelAwait")
 				);
 			}
 		});

package/lib/dependencies/HarmonyEvaluatedImportSpecifierDependency.js

@@ -14,18 +14,16 @@ const { ExportPresenceModes } = require("./HarmonyImportDependency");
 const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDependency");
 const { ImportPhase } = require("./ImportPhase");
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").GetConditionFn} GetConditionFn */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../Module").BuildMeta} BuildMeta */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @import { ReplaceSource } from "webpack-sources" */
+/** @import Dependency, { GetConditionFn } from "../Dependency" */
+/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
+/** @import { BuildMeta } from "../Module" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import ModuleGraphConnection from "../ModuleGraphConnection" */
+/** @import { ImportAttributes, Range } from "../javascript/JavascriptParser" */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<string[]>} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<string[]>} ObjectSerializerContext */
-/** @typedef {import("./HarmonyImportDependency").Ids} Ids */
+/** @import { Ids } from "./HarmonyImportDependency" */
 
 /**
  * Dependency for static evaluating import specifier. e.g.
@@ -35,6 +33,11 @@ const { ImportPhase } = require("./ImportPhase");
  * a.x !== undefined; // if x value statically analyzable
  */
 class HarmonyEvaluatedImportSpecifierDependency extends HarmonyImportSpecifierDependency {
+	// read by `HarmonyImportGuard` in place of `instanceof`, which would cycle
+	get isHarmonyEvaluatedImportSpecifier() {
+		return true;
+	}
+
 	/**
 	 * Creates an instance of HarmonyEvaluatedImportSpecifierDependency.
 	 * @param {string} request the request string
@@ -147,10 +150,16 @@ HarmonyEvaluatedImportSpecifierDependency.Template = class HarmonyEvaluatedImpor
 				break;
 			}
 			case "namespace": {
-				value =
-					ids[0] === "__esModule"
-						? ids.length === 1 || undefined
-						: exportsInfo.isExportProvided(ids);
+				// Empty ids are an `export * as ns` hop skipped as side-effect free,
+				// leaving the target's own namespace, which always exists.
+				if (ids.length === 0) {
+					value = true;
+				} else {
+					value =
+						ids[0] === "__esModule"
+							? ids.length === 1 || undefined
+							: exportsInfo.isExportProvided(ids);
+				}
 				break;
 			}
 			case "dynamic": {

package/lib/dependencies/HarmonyExportDependencyParserPlugin.js

@@ -23,15 +23,21 @@ const {
 const HarmonyImportSideEffectDependency = require("./HarmonyImportSideEffectDependency");
 const { ImportPhaseUtils, createGetImportPhase } = require("./ImportPhase");
 
-/** @typedef {import("estree").Expression} Expression */
-/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
-/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
-/** @typedef {import("../javascript/JavascriptParser").ClassDeclaration} ClassDeclaration */
-/** @typedef {import("../javascript/JavascriptParser").FunctionDeclaration} FunctionDeclaration */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("./HarmonyImportDependencyParserPlugin").HarmonySettings} HarmonySettings */
-/** @typedef {import("../CompatibilityPlugin").CompatibilitySettings} CompatibilitySettings */
+/**
+ * @import {
+ * 	Expression,
+ * 	ClassDeclaration,
+ * 	FunctionDeclaration
+ * } from "estree"
+ */
+/**
+ * @import {
+ * 	JavascriptParserOptions
+ * } from "../../declarations/WebpackOptions"
+ */
+/** @import JavascriptParser, { Range } from "../javascript/JavascriptParser" */
+/** @import { HarmonySettings } from "./HarmonyImportDependencyParserPlugin" */
+/** @import { CompatibilitySettings } from "../CompatibilityPlugin" */
 
 const { HarmonyStarExportsList } = HarmonyExportImportedSpecifierDependency;
 
@@ -65,9 +71,7 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 
 		parser.hooks.export.tap(PLUGIN_NAME, (statement) => {
 			const dep = new HarmonyExportHeaderDependency(
-				/** @type {Range | false} */ (
-					statement.declaration && statement.declaration.range
-				),
+				statement.declaration && statement.declaration.range,
 				/** @type {Range} */ (statement.range)
 			);
 			dep.setLocWithIndex(parser.getLocation(statement), -1);
@@ -107,6 +111,69 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 			parser.state.current.addDependency(sideEffectDep);
 			return true;
 		});
+		// `export default <namespace binding>` is the same export as
+		// `export { ns as default }`, so it is claimed here and rewritten into the
+		// same re-export. Stage -10 runs before the inner-graph tap, which would
+		// otherwise wrap the identifier in a pure-expression guard whose insertions
+		// outlive the statement this removes.
+		parser.hooks.statement.tap(
+			{ name: PLUGIN_NAME, stage: -10 },
+			(statement) => {
+				if (
+					statement.type !== "ExportDefaultDeclaration" ||
+					statement.declaration.type !== "Identifier"
+				) {
+					return;
+				}
+				const name = statement.declaration.name;
+				const settings =
+					/** @type {HarmonySettings | undefined} */
+					(parser.getTagData(name, harmonySpecifierTag));
+				if (!settings || settings.ids.length !== 0) return;
+				settings.used = true;
+				if (ImportPhaseUtils.isDefer(settings.phase)) return;
+				const harmonyNamedExports = (parser.state.harmonyNamedExports =
+					parser.state.harmonyNamedExports || new Set());
+				harmonyNamedExports.add("default");
+				getInnerGraphUtils(parser.state.compilation).addVariableUsage(
+					parser,
+					name,
+					"default"
+				);
+				const dep = new HarmonyExportImportedSpecifierDependency(
+					settings.source,
+					settings.sourceOrder,
+					settings.ids,
+					"default",
+					harmonyNamedExports,
+					null,
+					exportPresenceMode,
+					null,
+					settings.phase,
+					settings.attributes
+				);
+
+				// lazy barrel: defer the re-export at parse time when the importing module is side-effect-free
+				const moduleFactoryMeta = parser.state.module.factoryMeta;
+				if (
+					moduleFactoryMeta !== undefined &&
+					moduleFactoryMeta.sideEffectFree
+				) {
+					dep.setLazy(true);
+				}
+				dep.setLocWithIndex(parser.getLocation(statement), -1);
+				parser.state.current.addDependency(dep);
+
+				// no range erases the whole statement, as for `export { ns as default }`
+				const headerDep = new HarmonyExportHeaderDependency(
+					undefined,
+					/** @type {Range} */ (statement.range)
+				);
+				headerDep.setLocWithIndex(parser.getLocation(statement), -1);
+				parser.state.module.addPresentationalDependency(headerDep);
+				return true;
+			}
+		);
 		parser.hooks.exportExpression.tap(PLUGIN_NAME, (statement, node) => {
 			const isFunctionDeclaration = node.type === "FunctionDeclaration";
 			const exprRange = /** @type {Range} */ (node.range);
@@ -189,6 +256,7 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 				const settings =
 					/** @type {HarmonySettings} */
 					(parser.getTagData(id, harmonySpecifierTag));
+				if (settings) settings.used = true;
 				const harmonyNamedExports = (parser.state.harmonyNamedExports =
 					parser.state.harmonyNamedExports || new Set());
 				harmonyNamedExports.add(name);

package/lib/dependencies/HarmonyExportExpressionDependency.js

@@ -18,19 +18,22 @@ const NullDependency = require("./NullDependency");
 
 const DEFAULT_EXPORT_NAME = "default";
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
-/** @typedef {import("../Dependency").LazyUntil} LazyUntil */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("../optimize/InlineExports").InlinedValue} InlinedValue */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @import { ReplaceSource } from "webpack-sources" */
+/** @import { ExportsSpec, LazyUntil } from "../Dependency" */
+/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import { ConnectionState } from "../ModuleGraphConnection" */
+/** @import { InlinedValue } from "../optimize/InlineExports" */
+/** @import { Range } from "../javascript/JavascriptParser" */
 /** @typedef {string | { id?: string | undefined, range: Range, prefix: string, suffix: string }} DeclarationId */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Range, Range, string, DeclarationId | undefined, boolean]>} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[Range, Range, string, DeclarationId | undefined, boolean]>} ObjectSerializerContext */
-/** @typedef {import("./HarmonyExportInitFragment").ExportMap} ExportMap */
-/** @typedef {import("../javascript/JavascriptModule").JavascriptModuleBuildInfo} JavascriptModuleBuildInfo */
+/** @import { ExportMap } from "./HarmonyExportInitFragment" */
+/**
+ * @import {
+ * 	JavascriptModuleBuildInfo
+ * } from "../javascript/JavascriptModule"
+ */
 
 class HarmonyExportExpressionDependency extends NullDependency {
 	/**
@@ -162,19 +165,21 @@ HarmonyExportExpressionDependency.Template = class HarmonyExportDependencyTempla
 	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	apply(
-		dependency,
-		source,
-		{
+	apply(dependency, source, templateContext) {
+		const {
 			module,
 			moduleGraph,
 			runtimeTemplate,
 			runtimeRequirements,
 			initFragments,
-			runtime,
-			concatenationScope
-		}
-	) {
+			runtime
+		} = templateContext;
+		// a wrapped module's default binding is unreachable from the shared scope
+		const concatenationScope =
+			templateContext.concatenationScope &&
+			!templateContext.concatenationScope.isWrapped()
+				? templateContext.concatenationScope
+				: undefined;
 		const dep = /** @type {HarmonyExportExpressionDependency} */ (dependency);
 		const { declarationId } = dep;
 		const exportsName = module.exportsArgument;

package/lib/dependencies/HarmonyExportHeaderDependency.js

@@ -8,17 +8,17 @@
 const makeSerializable = require("../util/makeSerializable");
 const NullDependency = require("./NullDependency");
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Range | false, Range]>} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[Range | false, Range]>} ObjectSerializerContext */
+/** @import { ReplaceSource } from "webpack-sources" */
+/** @import Dependency from "../Dependency" */
+/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
+/** @import { Range } from "../javascript/JavascriptParser" */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Range | undefined | null, Range]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[Range | undefined | null, Range]>} ObjectSerializerContext */
 
 class HarmonyExportHeaderDependency extends NullDependency {
 	/**
 	 * Creates an instance of HarmonyExportHeaderDependency.
-	 * @param {Range | false} range range
+	 * @param {Range | undefined | null} range range
 	 * @param {Range} rangeStatement range statement
 	 */
 	constructor(range, rangeStatement) {