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

package/lib/Compiler.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const asyncLib = require("neo-async");
+
 const {
 	AsyncParallelHook,
 	AsyncSeriesHook,
@@ -23,8 +24,6 @@ const NormalModuleFactory = require("./NormalModuleFactory");
 const RequestShortener = require("./RequestShortener");
 const ResolverFactory = require("./ResolverFactory");
 const Stats = require("./Stats");
-const Watching = require("./Watching");
-const ConcurrentCompilationError = require("./errors/ConcurrentCompilationError");
 const WebpackError = require("./errors/WebpackError");
 const { Logger } = require("./logging/Logger");
 const { dirname, join, mkdirp } = require("./util/fs");
@@ -37,37 +36,54 @@ const parseJson = require("./util/parseJson");
 const { isSourceEqual } = require("./util/source");
 const webpack = require(".");
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/WebpackOptions").EntryNormalized} Entry */
-/** @typedef {import("../declarations/WebpackOptions").OutputNormalized} OutputOptions */
-/** @typedef {import("../declarations/WebpackOptions").WatchOptions} WatchOptions */
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("../declarations/WebpackOptions").Plugins} Plugins */
-/** @typedef {import("./webpack").WebpackPluginFunction} WebpackPluginFunction */
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./Dependency")} Dependency */
-/** @typedef {import("./HotModuleReplacementPlugin").ChunkHashes} ChunkHashes */
-/** @typedef {import("./HotModuleReplacementPlugin").ChunkModuleHashes} ChunkModuleHashes */
-/** @typedef {import("./HotModuleReplacementPlugin").ChunkModuleIds} ChunkModuleIds */
-/** @typedef {import("./HotModuleReplacementPlugin").ChunkRuntime} ChunkRuntime */
-/** @typedef {import("./HotModuleReplacementPlugin").FullHashChunkModuleHashes} FullHashChunkModuleHashes */
-/** @typedef {import("./HotModuleReplacementPlugin").HotIndex} HotIndex */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./Module").BuildInfo} BuildInfo */
-/** @typedef {import("./RecordIdsPlugin").RecordsChunks} RecordsChunks */
-/** @typedef {import("./RecordIdsPlugin").RecordsModules} RecordsModules */
-/** @typedef {import("./config/target").PlatformTargetProperties} PlatformTargetProperties */
-/** @typedef {import("./logging/createConsoleLogger").LoggingFunction} LoggingFunction */
-/** @typedef {import("./optimize/AggressiveSplittingPlugin").SplitData} SplitData */
-/** @typedef {import("./util/fs").IStats} IStats */
-/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
-/** @typedef {import("./util/fs").IntermediateFileSystem} IntermediateFileSystem */
-/** @typedef {import("./util/fs").OutputFileSystem} OutputFileSystem */
-/** @typedef {import("./util/fs").TimeInfoEntries} TimeInfoEntries */
-/** @typedef {import("./util/fs").WatchFileSystem} WatchFileSystem */
-/** @typedef {import("schema-utils").validate} Validate */
-/** @typedef {import("schema-utils").Schema} Schema */
-/** @typedef {import("schema-utils").ValidationErrorConfiguration} ValidationErrorConfiguration */
+const getWatching = memoize(() => require("./Watching"));
+
+const getValidate = memoize(() => require("schema-utils").validate);
+
+const getConcurrentCompilationError = memoize(() =>
+	require("./errors/ConcurrentCompilationError")
+);
+
+/** @import { Source } from "webpack-sources" */
+/**
+ * @import {
+ * 	EntryNormalized as Entry,
+ * 	OutputNormalized as OutputOptions,
+ * 	WatchOptions,
+ * 	WebpackOptionsNormalized as WebpackOptions,
+ * 	Plugins
+ * } from "../declarations/WebpackOptions"
+ */
+/** @import { WebpackPluginFunction, ErrorCallback } from "./webpack" */
+/** @import Chunk from "./Chunk" */
+/** @import Dependency from "./Dependency" */
+/**
+ * @import {
+ * 	ChunkHashes,
+ * 	ChunkModuleHashes,
+ * 	ChunkModuleIds,
+ * 	ChunkRuntime,
+ * 	FullHashChunkModuleHashes,
+ * 	HotIndex
+ * } from "./HotModuleReplacementPlugin"
+ */
+/** @import Module, { BuildInfo } from "./Module" */
+/** @import Watching from "./Watching" */
+/** @import { RecordsChunks, RecordsModules } from "./RecordIdsPlugin" */
+/** @import { PlatformTargetProperties } from "./config/target" */
+/** @import { LoggingFunction } from "./logging/createConsoleLogger" */
+/** @import { SplitData } from "./optimize/AggressiveSplittingPlugin" */
+/**
+ * @import {
+ * 	IStats,
+ * 	InputFileSystem,
+ * 	IntermediateFileSystem,
+ * 	OutputFileSystem,
+ * 	TimeInfoEntries,
+ * 	WatchFileSystem
+ * } from "./util/fs"
+ */
+/** @import { Schema, ValidationErrorConfiguration } from "schema-utils" */
 
 /**
  * Defines the compilation params type used by this module.
@@ -83,8 +99,6 @@ const webpack = require(".");
  * @typedef {import("./webpack").Callback<T, R>} Callback
  */
 
-/** @typedef {import("./webpack").ErrorCallback} ErrorCallback */
-
 /**
  * Defines the run as child callback callback.
  * @callback RunAsChildCallback
@@ -170,7 +184,7 @@ const includesHash = (filename, hashes) => {
 	return filename.includes(hashes);
 };
 
-const getValidate = memoize(() => require("schema-utils").validate);
+// only reached by `watch()`, so a one-shot build never loads the watcher
 
 class Compiler {
 	/**
@@ -541,12 +555,13 @@ class Compiler {
 	 */
 	watch(watchOptions, handler) {
 		if (this.running) {
-			handler(new ConcurrentCompilationError());
+			handler(new (getConcurrentCompilationError())());
 			return;
 		}
 
 		this.running = true;
 		this.watchMode = true;
+		const Watching = getWatching();
 		this.watching = new Watching(this, watchOptions, handler);
 		return this.watching;
 	}
@@ -558,7 +573,7 @@ class Compiler {
 	 */
 	run(callback) {
 		if (this.running) {
-			callback(new ConcurrentCompilationError());
+			callback(new (getConcurrentCompilationError())());
 			return;
 		}
 

package/lib/ConcatenationScope.js

@@ -10,14 +10,34 @@ const {
 	NAMESPACE_OBJECT_EXPORT
 } = require("./util/concatenate");
 
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./optimize/ConcatenatedModule").ConcatenatedModuleInfo} ConcatenatedModuleInfo */
-/** @typedef {import("./optimize/ConcatenatedModule").ModuleInfo} ModuleInfo */
-/** @typedef {import("./optimize/ConcatenatedModule").ExportName} Ids */
+/** @import { Source } from "webpack-sources" */
+/** @import Module from "./Module" */
+/**
+ * @import {
+ * 	ConcatenatedModuleInfo,
+ * 	ModuleInfo,
+ * 	ExportName as Ids
+ * } from "./optimize/ConcatenatedModule"
+ */
+
+/** @typedef {{ start: number, end: number, name: string, leaked: boolean }} ModuleReferenceMatch */
+
+const MODULE_REFERENCE_TOKEN = "__WEBPACK_MODULE_REFERENCE__";
 
 const MODULE_REFERENCE_REGEXP =
-	/^__WEBPACK_MODULE_REFERENCE__(\d+)_([\da-f]+|ns)(_call)?(_directImport)?(_deferredImport)?(_mangleableNs)?(?:_asiSafe(\d))?__$/;
+	/^__WEBPACK_MODULE_REFERENCE__(\d+)_([\da-f]+|ns)(_call)?(_directImport)?(_deferredImport)?(_mangleableNs)?(_moduleExportsAccess)?(?:_asiSafe(\d))?__$/;
+
+// unanchored variant: wrapped CJS bodies are not re-parsed, so their
+// references must be found textually
+const MODULE_REFERENCE_SCAN_REGEXP = new RegExp(
+	MODULE_REFERENCE_REGEXP.source.slice(1, -1),
+	"g"
+);
+
+const IDENTIFIER_CHARACTER_REGEXP = /[\w$]/;
+
+/** @type {WeakMap<Source, ModuleReferenceMatch[]>} */
+const moduleReferencesCache = new WeakMap();
 
 /**
  * Encodes how a concatenated module reference should be interpreted when it is
@@ -28,6 +48,7 @@ const MODULE_REFERENCE_REGEXP =
  * @property {boolean} directImport true, when this referenced export is directly imported (not via property access)
  * @property {boolean} deferredImport true, when this referenced export is deferred
  * @property {boolean} mangleableNamespace true, when a whole-namespace reference may use a decoupled namespace object that keeps the original export names
+ * @property {boolean} moduleExportsAccess true, when the reference resolves to the module's own exports value with plain property access, skipping ESM interop (how `require()` and a wrapped module's side-effect init see it)
  * @property {boolean | undefined} asiSafe if the position is ASI safe or unknown
  */
 
@@ -69,6 +90,36 @@ class ConcatenationScope {
 		return this._modulesMap.has(module);
 	}
 
+	/**
+	 * Whether an in-scope module's body renders inside the lazy wrapper.
+	 * @param {Module} module the referenced module
+	 * @returns {boolean} true, when it's wrapped
+	 */
+	isModuleWrapped(module) {
+		const info = this._modulesMap.get(module);
+		return info !== undefined && info.wrapped;
+	}
+
+	/**
+	 * Marks a wrapped module as eagerly imported, so its accessor is called at its
+	 * own slot in evaluation order instead of from inside the importing body.
+	 * @param {Module} module the referenced module
+	 */
+	registerEagerModule(module) {
+		const info = this._modulesMap.get(module);
+		if (info !== undefined) info.eager = true;
+	}
+
+	/**
+	 * Whether the current module runs inside the lazy wrapper. Exports then live
+	 * on a real exports object, not hoisted bindings, so templates emit runtime
+	 * code.
+	 * @returns {boolean} true, when the current module is wrapped
+	 */
+	isWrapped() {
+		return this._currentModule.wrapped;
+	}
+
 	/**
 	 * Records the symbol that should be used when the current module exports a
 	 * named binding.
@@ -149,6 +200,7 @@ class ConcatenationScope {
 			directImport = false,
 			deferredImport = false,
 			mangleableNamespace = false,
+			moduleExportsAccess = false,
 			asiSafe = false
 		}
 	) {
@@ -157,6 +209,9 @@ class ConcatenationScope {
 		const directImportFlag = directImport ? "_directImport" : "";
 		const deferredImportFlag = deferredImport ? "_deferredImport" : "";
 		const mangleableNamespaceFlag = mangleableNamespace ? "_mangleableNs" : "";
+		const moduleExportsAccessFlag = moduleExportsAccess
+			? "_moduleExportsAccess"
+			: "";
 		const asiSafeFlag = asiSafe
 			? "_asiSafe1"
 			: asiSafe === false
@@ -166,7 +221,7 @@ class ConcatenationScope {
 			? Buffer.from(JSON.stringify(ids), "utf8").toString("hex")
 			: "ns";
 		// a "._" is appended to allow "delete ...", which would cause a SyntaxError in strict mode
-		return `__WEBPACK_MODULE_REFERENCE__${info.index}_${exportData}${callFlag}${directImportFlag}${deferredImportFlag}${mangleableNamespaceFlag}${asiSafeFlag}__._`;
+		return `__WEBPACK_MODULE_REFERENCE__${info.index}_${exportData}${callFlag}${directImportFlag}${deferredImportFlag}${mangleableNamespaceFlag}${moduleExportsAccessFlag}${asiSafeFlag}__._`;
 	}
 
 	/**
@@ -179,6 +234,49 @@ class ConcatenationScope {
 		return MODULE_REFERENCE_REGEXP.test(name);
 	}
 
+	/**
+	 * Checks whether an identifier buries a reference token without being one,
+	 * which nothing can resolve: it would reach the output as an undeclared global.
+	 * @param {string} name the identifier
+	 * @returns {boolean} true, when a reference token is buried in the identifier
+	 */
+	static isLeakedModuleReference(name) {
+		return (
+			name.includes(MODULE_REFERENCE_TOKEN) &&
+			!MODULE_REFERENCE_REGEXP.test(name)
+		);
+	}
+
+	/**
+	 * Finds all encoded module references in a generated source. A match that
+	 * continues an identifier is reported as `leaked`: it is a token a wider
+	 * replacement swallowed, so substituting it would rewrite the middle of a name.
+	 * @param {Source} source generated source
+	 * @returns {ModuleReferenceMatch[]} reference token positions (end is exclusive, excludes the appended "._")
+	 */
+	static findModuleReferences(source) {
+		const cached = moduleReferencesCache.get(source);
+		if (cached !== undefined) return cached;
+		const code = source.source().toString();
+		/** @type {ModuleReferenceMatch[]} */
+		const result = [];
+		MODULE_REFERENCE_SCAN_REGEXP.lastIndex = 0;
+		let match = MODULE_REFERENCE_SCAN_REGEXP.exec(code);
+		while (match !== null) {
+			result.push({
+				start: match.index,
+				end: match.index + match[0].length,
+				name: match[0],
+				leaked:
+					match.index > 0 &&
+					IDENTIFIER_CHARACTER_REGEXP.test(code[match.index - 1])
+			});
+			match = MODULE_REFERENCE_SCAN_REGEXP.exec(code);
+		}
+		moduleReferencesCache.set(source, result);
+		return result;
+	}
+
 	/**
 	 * Parses an encoded module reference back into its module index and
 	 * reference flags.
@@ -189,7 +287,7 @@ class ConcatenationScope {
 		const match = MODULE_REFERENCE_REGEXP.exec(name);
 		if (!match) return null;
 		const index = Number(match[1]);
-		const asiSafe = match[7];
+		const asiSafe = match[8];
 		return {
 			index,
 			ids:
@@ -200,6 +298,7 @@ class ConcatenationScope {
 			directImport: Boolean(match[4]),
 			deferredImport: Boolean(match[5]),
 			mangleableNamespace: Boolean(match[6]),
+			moduleExportsAccess: Boolean(match[7]),
 			asiSafe: asiSafe ? asiSafe === "1" : undefined
 		};
 	}

package/lib/ConditionalInitFragment.js

@@ -10,9 +10,9 @@ const InitFragment = require("./InitFragment");
 const Template = require("./Template");
 const { mergeRuntime } = require("./util/runtime");
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("./Generator").GenerateContext} GenerateContext */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+/** @import { Source } from "webpack-sources" */
+/** @import { GenerateContext } from "./Generator" */
+/** @import { RuntimeSpec } from "./util/runtime" */
 
 /**
  * Returns wrapped source.

package/lib/ConstPlugin.js

@@ -15,17 +15,19 @@ const ConstDependency = require("./dependencies/ConstDependency");
 const { evaluateToString } = require("./javascript/JavascriptParserHelpers");
 const { parseResource } = require("./util/identifier");
 
-/** @typedef {import("estree").AssignmentProperty} AssignmentProperty */
-/** @typedef {import("estree").Expression} Expression */
-/** @typedef {import("estree").Identifier} Identifier */
-/** @typedef {import("estree").Pattern} Pattern */
-/** @typedef {import("estree").SourceLocation} SourceLocation */
-/** @typedef {import("estree").Statement} Statement */
-/** @typedef {import("estree").Super} Super */
-/** @typedef {import("estree").VariableDeclaration} VariableDeclaration */
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
-/** @typedef {import("./javascript/JavascriptParser").Range} Range */
+/**
+ * @import {
+ * 	AssignmentProperty,
+ * 	Expression,
+ * 	Identifier,
+ * 	Pattern,
+ * 	Statement,
+ * 	Super,
+ * 	VariableDeclaration
+ * } from "estree"
+ */
+/** @import Compiler from "./Compiler" */
+/** @import JavascriptParser, { Range } from "./javascript/JavascriptParser" */
 
 /** @typedef {Set<string>} Declarations */
 

package/lib/ContextExclusionPlugin.js

@@ -4,7 +4,7 @@
 
 "use strict";
 
-/** @typedef {import("./Compiler")} Compiler */
+/** @import Compiler from "./Compiler" */
 
 const PLUGIN_NAME = "ContextExclusionPlugin";