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

package/lib/DefinePlugin.js

@@ -23,20 +23,26 @@ const {
 const createHash = require("./util/createHash");
 const createHooksRegistry = require("./util/createHooksRegistry");
 
-/** @typedef {import("estree").Expression} Expression */
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./Module").BuildInfo} BuildInfo */
-/** @typedef {import("./Module").ValueCacheVersion} ValueCacheVersion */
-/** @typedef {import("./Module").ValueCacheVersions} ValueCacheVersions */
-/** @typedef {import("./NormalModule")} NormalModule */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
-/** @typedef {import("./javascript/JavascriptParser").DestructuringAssignmentProperties} DestructuringAssignmentProperties */
-/** @typedef {import("./javascript/JavascriptParser").Members} Members */
-/** @typedef {import("./javascript/JavascriptParser").Range} Range */
-/** @typedef {import("./logging/Logger").Logger} Logger */
-/** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./NormalModule").NormalModuleBuildInfo} NormalModuleBuildInfo */
+/** @import { Expression, MemberExpression } from "estree" */
+/** @import Compiler from "./Compiler" */
+/**
+ * @import {
+ * 	BuildInfo,
+ * 	ValueCacheVersion,
+ * 	ValueCacheVersions
+ * } from "./Module"
+ */
+/** @import NormalModule, { NormalModuleBuildInfo } from "./NormalModule" */
+/** @import RuntimeTemplate from "./RuntimeTemplate" */
+/**
+ * @import JavascriptParser, {
+ * 	DestructuringAssignmentProperties,
+ * 	Members,
+ * 	Range
+ * } from "./javascript/JavascriptParser"
+ */
+/** @import { Logger } from "./logging/Logger" */
+/** @import Compilation from "./Compilation" */
 
 /** @typedef {null | undefined | RegExp | EXPECTED_FUNCTION | string | number | boolean | bigint | undefined} CodeValuePrimitive */
 /** @typedef {RecursiveArrayOrRecord<CodeValuePrimitive | RuntimeValue>} CodeValue */
@@ -158,6 +164,21 @@ const isObjectDefinition = (code) =>
 	!(code instanceof RuntimeValue) &&
 	!(code instanceof RegExp);
 
+/**
+ * Walks a member chain up, dropping its last `count` members.
+ * @param {Expression} node member expression
+ * @param {number} count members to drop
+ * @returns {Expression} the chain without them
+ */
+const dropTrailingMembers = (node, count) => {
+	while (count--) {
+		node = /** @type {Expression} */ (
+			/** @type {MemberExpression} */ (node).object
+		);
+	}
+	return node;
+};
+
 /** @typedef {Set<string> | null} ObjKeys */
 /** @typedef {boolean | undefined | null} AsiSafe */
 
@@ -353,6 +374,13 @@ const toCacheVersion = (code) => {
 const PLUGIN_NAME = "DefinePlugin";
 const VALUE_DEP_PREFIX = `webpack/${PLUGIN_NAME} `;
 const VALUE_DEP_MAIN = `webpack/${PLUGIN_NAME}_hash`;
+
+// Keys webpack injects itself are not the user's to remove, so `performance.unusedDefines`
+// never sees them.
+/** @type {WeakSet<DefinePlugin>} */
+const INTERNAL_PLUGINS = new WeakSet();
+/** @type {WeakMap<Compilation, Set<string>>} */
+const DECLARED_KEYS = new WeakMap();
 const TYPEOF_OPERATOR_REGEXP = /^typeof\s+/;
 const EMPTY_OBJECT = {};
 
@@ -692,6 +720,22 @@ class DefinePlugin {
 			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				const definitions = this.definitions;
+				const { performance } = compilation.options;
+				// Only `performance.unusedDefines` reads these, so a build without it
+				// collects nothing.
+				const collectDeclared =
+					performance !== false &&
+					performance.unusedDefines === true &&
+					!INTERNAL_PLUGINS.has(this);
+				/** @type {Set<string> | undefined} */
+				let declaredKeys;
+				if (collectDeclared) {
+					declaredKeys = DECLARED_KEYS.get(compilation);
+					if (declaredKeys === undefined) {
+						declaredKeys = new Set();
+						DECLARED_KEYS.set(compilation, declaredKeys);
+					}
+				}
 				const hooks = DefinePlugin.getCompilationHooks(compilation);
 
 				hooks.definitions.tap(PLUGIN_NAME, (previousDefinitions) => ({
@@ -1120,7 +1164,7 @@ class DefinePlugin {
 						const chainRoot = isMeta ? "import.meta" : chainParts[0];
 						const chainPrefix = chainParts.slice(isMeta ? 2 : 1);
 						/**
-						 * Whether a member chain reads a property that is not defined.
+						 * Finds the member of a chain that reads a property that is not defined.
 						 * Walks the merged view so dotted keys of every instance count.
 						 * Collects every define key consulted so the caller can record a
 						 * value dependency on each (a sibling key like `OBJECT.SUB2` affects
@@ -1128,12 +1172,12 @@ class DefinePlugin {
 						 * Inherited members (e.g. `toString`) stay defined.
 						 * @param {Members} members chain members (after the root)
 						 * @param {string[]} deps consulted define keys (mutated)
-						 * @returns {boolean} true when the access resolves to `undefined`
+						 * @returns {number} index of the member resolving to `undefined`, or -1
 						 */
-						const isUndefinedMemberAccess = (members, deps) => {
-							if (members.length <= chainPrefix.length) return false;
+						const findUndefinedMemberAccess = (members, deps) => {
+							if (members.length <= chainPrefix.length) return -1;
 							for (let i = 0; i < chainPrefix.length; i++) {
-								if (members[i] !== chainPrefix[i]) return false;
+								if (members[i] !== chainPrefix[i]) return -1;
 							}
 							/** @type {MergedDefinitionNode | undefined} */
 							let value = definition;
@@ -1146,9 +1190,9 @@ class DefinePlugin {
 										deps.push(nextPath);
 										value = value.get(member);
 									} else if (member in EMPTY_OBJECT) {
-										return false;
+										return -1;
 									} else {
-										return true;
+										return i;
 									}
 								} else if (isObjectDefinition(value)) {
 									// non-expandable object leaf (e.g. an array)
@@ -1164,37 +1208,45 @@ class DefinePlugin {
 										deps.push(nextPath);
 										value = mergedDefinitions.definitions[nextPath];
 									} else {
-										return true;
+										return i;
 									}
 								} else {
 									// a leaf with members left is a real property access on a value
-									return false;
+									return -1;
 								}
 								path = nextPath;
 							}
-							return false;
+							return -1;
 						};
 						parser.hooks.expressionMemberChain
 							.for(chainRoot)
 							.tap(PLUGIN_NAME, (expr, members) => {
 								const deps = [key];
-								if (!isUndefinedMemberAccess(members, deps)) return;
+								if (findUndefinedMemberAccess(members, deps) === -1) return;
 								for (const dep of deps) addValueDependency(dep);
 								return toConstantDependency(parser, "undefined")(expr);
 							});
-						// In a call, replace only the callee so the call itself is kept:
-						// `x.MISSING()` stays a (throwing) call and `x.MISSING?.()`
-						// short-circuits, with the object never inlined.
+						// Cut the chain at the undefined member, so what follows still
+						// throws; an optional link there takes the call, arguments unevaluated.
 						parser.hooks.callMemberChain
 							.for(chainRoot)
-							.tap(PLUGIN_NAME, (expr, members) => {
+							.tap(PLUGIN_NAME, (expr, members, membersOptionals) => {
 								const deps = [key];
-								if (!isUndefinedMemberAccess(members, deps)) return;
+								const undefinedIndex = findUndefinedMemberAccess(members, deps);
+								if (undefinedIndex === -1) return;
 								for (const dep of deps) addValueDependency(dep);
+								if (membersOptionals[undefinedIndex + 1]) {
+									return toConstantDependency(parser, "undefined")(expr);
+								}
 								toConstantDependency(
 									parser,
 									"undefined"
-								)(/** @type {Expression} */ (expr.callee));
+								)(
+									dropTrailingMembers(
+										/** @type {Expression} */ (expr.callee),
+										members.length - 1 - undefinedIndex
+									)
+								);
 								parser.walkExpressions(expr.arguments);
 								return true;
 							});
@@ -1245,6 +1297,17 @@ class DefinePlugin {
 							warning.hideStack = true;
 							compilation.warnings.push(warning);
 						}
+						// Leaves only: an object key counts as used whenever any of its
+						// members is, which would report the parent as unused. An object
+						// with no members has none, and still substitutes.
+						const isLeaf =
+							!isObjectDefinition(code) ||
+							Object.keys(/** @type {Definitions} */ (code)).length === 0;
+
+						if (declaredKeys !== undefined && isLeaf) {
+							declaredKeys.add(prefix + key);
+						}
+
 						if (isObjectDefinition(code)) {
 							walkDefinitionsForValues(
 								/** @type {Definitions} */ (code),
@@ -1267,10 +1330,31 @@ class DefinePlugin {
 
 DefinePlugin.getCompilationHooks = createHooksRegistry(createCompilationHooks);
 
+/**
+ * Marks an instance as webpack's own, so `performance.unusedDefines` never
+ * reports the keys it declares against the user.
+ * @param {DefinePlugin} plugin the instance webpack constructed itself
+ * @returns {DefinePlugin} the same instance
+ */
+const markInternal = (plugin) => {
+	INTERNAL_PLUGINS.add(plugin);
+	return plugin;
+};
+
+/**
+ * The keys the configuration declared, webpack's own excluded.
+ * @param {Compilation} compilation the compilation
+ * @returns {Set<string> | undefined} the keys, or undefined when none were collected
+ */
+const getDeclaredKeys = (compilation) => DECLARED_KEYS.get(compilation);
+
+DefinePlugin.VALUE_DEP_MAIN = VALUE_DEP_MAIN;
+DefinePlugin.VALUE_DEP_PREFIX = VALUE_DEP_PREFIX;
+DefinePlugin.getDeclaredKeys = getDeclaredKeys;
+DefinePlugin.getMergedDefinitionNode = getMergedDefinitionNode;
+DefinePlugin.getRuntimeRequirements = getRuntimeRequirements;
+DefinePlugin.markInternal = markInternal;
+DefinePlugin.stringifyMergedDefinition = stringifyMergedDefinition;
+DefinePlugin.toPropertyKey = toPropertyKey;
+
 module.exports = DefinePlugin;
-module.exports.VALUE_DEP_MAIN = VALUE_DEP_MAIN;
-module.exports.VALUE_DEP_PREFIX = VALUE_DEP_PREFIX;
-module.exports.getMergedDefinitionNode = getMergedDefinitionNode;
-module.exports.getRuntimeRequirements = getRuntimeRequirements;
-module.exports.stringifyMergedDefinition = stringifyMergedDefinition;
-module.exports.toPropertyKey = toPropertyKey;

package/lib/DependenciesBlock.js

@@ -7,12 +7,15 @@
 
 const makeSerializable = require("./util/makeSerializable");
 
-/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
-/** @typedef {import("./Dependency")} Dependency */
-/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-/** @typedef {import("./util/Hash")} Hash */
+/** @import AsyncDependenciesBlock from "./AsyncDependenciesBlock" */
+/** @import Dependency, { UpdateHashContext } from "./Dependency" */
+/**
+ * @import {
+ * 	ObjectDeserializerContext,
+ * 	ObjectSerializerContext
+ * } from "./serialization/ObjectMiddleware"
+ */
+/** @import Hash from "./util/Hash" */
 
 /** @typedef {(d: Dependency) => boolean} DependencyFilterFunction */
 

package/lib/Dependency.js

@@ -5,21 +5,29 @@
 
 "use strict";
 
+const { JAVASCRIPT_TYPE } = require("./ModuleSourceTypeConstants");
 const memoize = require("./util/memoize");
 
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./ModuleGraph")} ModuleGraph */
-/** @typedef {import("./ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("./errors/WebpackError")} WebpackError */
-/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-/** @typedef {import("./util/Hash")} Hash */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
-/** @typedef {import("./dependencies/ModuleDependency")} ModuleDependency */
+/** @import ChunkGraph from "./ChunkGraph" */
+/** @import DependenciesBlock from "./DependenciesBlock" */
+/** @import Module, { SourceType } from "./Module" */
+/** @import ModuleGraph from "./ModuleGraph" */
+/**
+ * @import ModuleGraphConnection, {
+ * 	ConnectionState
+ * } from "./ModuleGraphConnection"
+ */
+/** @import RuntimeTemplate from "./RuntimeTemplate" */
+/** @import WebpackError from "./errors/WebpackError" */
+/**
+ * @import {
+ * 	ObjectDeserializerContext,
+ * 	ObjectSerializerContext
+ * } from "./serialization/ObjectMiddleware"
+ */
+/** @import Hash from "./util/Hash" */
+/** @import { RuntimeSpec } from "./util/runtime" */
+/** @import ModuleDependency from "./dependencies/ModuleDependency" */
 /**
  * Defines the update hash context type used by this module.
  * @typedef {object} UpdateHashContext
@@ -165,6 +173,16 @@ class Dependency {
 		return "unknown";
 	}
 
+	/**
+	 * Returns the source type this dependency reads from the module it references:
+	 * `javascript` for anything going through the module wrapper, `asset-url` for a
+	 * bare url embedded into non-javascript output (css, html, a manifest).
+	 * @returns {SourceType} the source type read from the referenced module
+	 */
+	get referencedSourceType() {
+		return JAVASCRIPT_TYPE;
+	}
+
 	/**
 	 * Returns location.
 	 * @returns {DependencyLocation} location
@@ -424,9 +442,10 @@ class Dependency {
 
 	/**
 	 * Returns true if this dependency can be concatenated
+	 * @param {boolean} concatenateCommonJsModules whether optimization.concatenateModules.commonjs is enabled
 	 * @returns {boolean} true if this dependency can be concatenated
 	 */
-	canConcatenate() {
+	canConcatenate(concatenateCommonJsModules) {
 		return false;
 	}
 
@@ -506,11 +525,12 @@ Dependency.isLowPriorityDependency = (dependency) =>
 /**
  * Returns true if the dependency can be concatenated (scope hoisting).
  * @param {Dependency} dependency dep
+ * @param {boolean} concatenateCommonJsModules whether optimization.concatenateModules.commonjs is enabled
  * @returns {boolean} true if this dependency supports concatenation
  */
-Dependency.canConcatenate = (dependency) => {
+Dependency.canConcatenate = (dependency, concatenateCommonJsModules) => {
 	if (typeof dependency.canConcatenate === "function") {
-		return dependency.canConcatenate();
+		return dependency.canConcatenate(concatenateCommonJsModules);
 	}
 	return false;
 };

package/lib/DependencyTemplate.js

@@ -5,18 +5,17 @@
 
 "use strict";
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./CodeGenerationResults")} CodeGenerationResults */
-/** @typedef {import("./ConcatenationScope")} ConcatenationScope */
-/** @typedef {import("./Dependency")} Dependency */
-/** @typedef {import("./Dependency").RuntimeSpec} RuntimeSpec */
-/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("./Generator").GenerateContext} GenerateContext */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./Module").RuntimeRequirements} RuntimeRequirements */
-/** @typedef {import("./ModuleGraph")} ModuleGraph */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
+/** @import { ReplaceSource } from "webpack-sources" */
+/** @import ChunkGraph from "./ChunkGraph" */
+/** @import CodeGenerationResults from "./CodeGenerationResults" */
+/** @import ConcatenationScope from "./ConcatenationScope" */
+/** @import Dependency from "./Dependency" */
+/** @import DependencyTemplates from "./DependencyTemplates" */
+/** @import { GenerateContext } from "./Generator" */
+/** @import Module, { RuntimeRequirements } from "./Module" */
+/** @import ModuleGraph from "./ModuleGraph" */
+/** @import RuntimeTemplate from "./RuntimeTemplate" */
+/** @import { RuntimeSpec } from "./util/runtime" */
 
 /**
  * Defines the init fragment type used by this module.

package/lib/DependencyTemplates.js

@@ -8,9 +8,9 @@
 const { DEFAULTS } = require("./config/defaults");
 const createHash = require("./util/createHash");
 
-/** @typedef {import("./Compilation").DependencyConstructor} DependencyConstructor */
-/** @typedef {import("./DependencyTemplate")} DependencyTemplate */
-/** @typedef {import("./util/Hash").HashFunction} HashFunction */
+/** @import { DependencyConstructor } from "./Compilation" */
+/** @import DependencyTemplate from "./DependencyTemplate" */
+/** @import { HashFunction } from "./util/Hash" */
 
 class DependencyTemplates {
 	/**

package/lib/DotenvPlugin.js

@@ -6,13 +6,14 @@
 "use strict";
 
 const FileSystemInfo = require("./FileSystemInfo");
+const DotenvFileError = require("./errors/DotenvFileError");
 const { join } = require("./util/fs");
 
-/** @typedef {import("../declarations/WebpackOptions").DotenvPluginOptions} DotenvPluginOptions */
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./CacheFacade").ItemCacheFacade} ItemCacheFacade */
-/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
-/** @typedef {import("./FileSystemInfo").Snapshot} Snapshot */
+/** @import { DotenvPluginOptions } from "../declarations/WebpackOptions" */
+/** @import Compiler from "./Compiler" */
+/** @import { ItemCacheFacade } from "./CacheFacade" */
+/** @import { InputFileSystem } from "./util/fs" */
+/** @import { Snapshot } from "./FileSystemInfo" */
 
 /** @typedef {Exclude<DotenvPluginOptions["prefix"], string | undefined>} Prefix */
 /** @typedef {Record<string, string>} Env */
@@ -24,8 +25,45 @@ const DEFAULT_TEMPLATE = [
 	".env.[mode].local"
 ];
 
+// cspell:ignore Motte, motdotla
+
+/*
+ * `LINE`, `parse`, `_resolveEscapeSequences`, `expandValue` and `expand`
+ * below are ported from dotenv v17.4.2 and dotenv-expand v13.0.0, both
+ * BSD-2-Clause. Links stay version-pinned: later dotenv-expand releases
+ * ship different license text.
+ *
+ * https://github.com/motdotla/dotenv/blob/v17.4.2/lib/main.js
+ * https://github.com/motdotla/dotenv-expand/blob/v13.0.0/lib/main.js
+ *
+ * Copyright (c) 2015, Scott Motte
+ * Copyright (c) 2016, Scott Motte
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
 // Regex for parsing .env files
-// ported from https://github.com/motdotla/dotenv/blob/master/lib/main.js#L49
+// ported from https://github.com/motdotla/dotenv/blob/v17.4.2/lib/main.js#L38
 const LINE =
 	/^\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?$/gm;
 
@@ -33,7 +71,7 @@ const PLUGIN_NAME = "DotenvPlugin";
 
 /**
  * Parse .env file content
- * ported from https://github.com/motdotla/dotenv/blob/master/lib/main.js#L49
+ * ported from https://github.com/motdotla/dotenv/blob/v17.4.2/lib/main.js#L41
  * @param {string | Buffer} src the source content to parse
  * @returns {Env} parsed environment variables object
  */
@@ -79,7 +117,7 @@ function parse(src) {
 
 /**
  * Resolve escape sequences
- * ported from https://github.com/motdotla/dotenv-expand
+ * ported from https://github.com/motdotla/dotenv-expand/blob/v13.0.0/lib/main.js#L3
  * @param {string} value value to resolve
  * @returns {string} resolved value
  */
@@ -89,7 +127,7 @@ function _resolveEscapeSequences(value) {
 
 /**
  * Expand environment variable value
- * ported from https://github.com/motdotla/dotenv-expand
+ * ported from https://github.com/motdotla/dotenv-expand/blob/v13.0.0/lib/main.js#L7
  * @param {string} value value to expand
  * @param {Record<string, string | undefined>} processEnv process.env object
  * @param {Env} runningParsed running parsed object
@@ -118,8 +156,8 @@ function expandValue(value, processEnv, runningParsed) {
 		const opMatch = expression.match(opRegex);
 		const splitter = opMatch ? opMatch[0] : null;
 
-		const r = expression.split(/** @type {string} */ (splitter));
-		// const r = splitter ? expression.split(splitter) : [expression];
+		// `split(null)` splits on the string "null", cutting up names containing it
+		const r = splitter ? expression.split(splitter) : [expression];
 
 		/** @type {string} */
 		let defaultValue;
@@ -158,7 +196,7 @@ function expandValue(value, processEnv, runningParsed) {
 
 /**
  * Expand environment variables in parsed object
- * ported from https://github.com/motdotla/dotenv-expand
+ * ported from https://github.com/motdotla/dotenv-expand/blob/v13.0.0/lib/main.js#L65
  * @param {{ parsed: Env, processEnv: Record<string, string | undefined> }} options expand options
  * @returns {{ parsed: Env }} expanded options
  */
@@ -198,16 +236,21 @@ function expand(options) {
 /**
  * Format environment variables as DefinePlugin definitions
  * @param {Env} env environment variables
- * @returns {Record<string, string>} formatted definitions
+ * @returns {Record<string, string | Env>} formatted definitions
  */
 const envToDefinitions = (env) => {
-	const definitions = /** @type {Record<string, string>} */ ({});
+	const definitions = /** @type {Record<string, string | Env>} */ ({});
+	// one nested definition rather than a `import.meta.env.<key>` per key: a
+	// dotted key would otherwise read back as a nested object, not as the key
+	const importMetaEnv = /** @type {Env} */ (Object.create(null));
 
 	for (const [key, value] of Object.entries(env)) {
 		const defValue = JSON.stringify(value);
+		// `process.env` stays flat — it must not shadow the real one at runtime
 		definitions[`process.env.${key}`] = defValue;
-		definitions[`import.meta.env.${key}`] = defValue;
+		importMetaEnv[key] = defValue;
 	}
+	definitions["import.meta.env"] = importMetaEnv;
 
 	return definitions;
 };
@@ -257,8 +300,10 @@ class DotenvPlugin {
 					? compiler.context
 					: this.options.dir;
 
-		/** @type {undefined | Snapshot} */
+		/** @type {undefined | InstanceType<Snapshot>} */
 		let snapshot;
+		/** @type {undefined | DotenvFileError} */
+		let loadError;
 
 		const cache = compiler.getCache(PLUGIN_NAME);
 		const identifier = JSON.stringify(
@@ -267,16 +312,31 @@ class DotenvPlugin {
 		const itemCache = cache.getItemCache(identifier, null);
 
 		compiler.hooks.beforeCompile.tapPromise(PLUGIN_NAME, async () => {
-			const { parsed, snapshot: newSnapshot } = dir
-				? await this._loadEnv(compiler, itemCache, dir)
-				: { parsed: {} };
-			const env = this._getEnv(prefixes, parsed);
-
-			definePlugin.definitions = envToDefinitions(env || {});
-			snapshot = newSnapshot;
+			loadError = undefined;
+			try {
+				const { parsed, snapshot: newSnapshot } = dir
+					? await this._loadEnv(compiler, itemCache, dir)
+					: { parsed: {} };
+				const env = this._getEnv(prefixes, parsed);
+
+				definePlugin.definitions = envToDefinitions(env || {});
+				snapshot = newSnapshot;
+			} catch (err) {
+				// reported on the compilation so watch mode recovers when it is fixed
+				if (!(err instanceof DotenvFileError)) throw err;
+				loadError = err;
+				definePlugin.definitions = envToDefinitions({});
+				snapshot = undefined;
+			}
 		});
 
 		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+			if (loadError) {
+				compilation.errors.push(loadError);
+				compilation.fileDependencies.add(
+					/** @type {string} */ (loadError.file)
+				);
+			}
 			if (snapshot) {
 				compilation.fileDependencies.addAll(snapshot.getFileIterable());
 				compilation.missingDependencies.addAll(snapshot.getMissingIterable());
@@ -332,7 +392,12 @@ class DotenvPlugin {
 						fileDependencies.push(filePath);
 						return content;
 					},
-					() => {
+					(err) => {
+						const code = /** @type {NodeJS.ErrnoException} */ (err).code;
+						// only an absent file is normal; anything else is a real fault
+						if (code !== "ENOENT" && code !== "ENOTDIR") {
+							throw new DotenvFileError(filePath, err);
+						}
 						// File doesn't exist, add to missingDependencies (this is normal)
 						missingDependencies.push(filePath);
 						return "";
@@ -360,9 +425,9 @@ class DotenvPlugin {
 	 * Loads the provided compiler.
 	 * @private
 	 * @param {Compiler} compiler compiler
-	 * @param {ItemCacheFacade} itemCache item cache facade
+	 * @param {InstanceType<ItemCacheFacade>} itemCache item cache facade
 	 * @param {string} dir directory to read
-	 * @returns {Promise<{ parsed: Env, snapshot: Snapshot }>} parsed result and snapshot
+	 * @returns {Promise<{ parsed: Env, snapshot: InstanceType<Snapshot> }>} parsed result and snapshot
 	 */
 	async _loadEnv(compiler, itemCache, dir) {
 		const fs = /** @type {InputFileSystem} */ (compiler.inputFileSystem);

package/lib/DynamicEntryPlugin.js

@@ -9,10 +9,14 @@ const EntryOptionPlugin = require("./EntryOptionPlugin");
 const EntryPlugin = require("./EntryPlugin");
 const EntryDependency = require("./dependencies/EntryDependency");
 
-/** @typedef {import("../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescriptionNormalized */
-/** @typedef {import("../declarations/WebpackOptions").EntryStatic} EntryStatic */
-/** @typedef {import("../declarations/WebpackOptions").EntryStaticNormalized} EntryStaticNormalized */
-/** @typedef {import("./Compiler")} Compiler */
+/**
+ * @import {
+ * 	EntryDescriptionNormalized,
+ * 	EntryStatic,
+ * 	EntryStaticNormalized
+ * } from "../declarations/WebpackOptions"
+ */
+/** @import Compiler from "./Compiler" */
 
 const PLUGIN_NAME = "DynamicEntryPlugin";
 

package/lib/EntryOptionPlugin.js

@@ -7,10 +7,14 @@
 
 const { SyncBailHook } = require("tapable");
 
-/** @typedef {import("../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescription */
-/** @typedef {import("../declarations/WebpackOptions").EntryNormalized} Entry */
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
+/**
+ * @import {
+ * 	EntryDescriptionNormalized as EntryDescription,
+ * 	EntryNormalized as Entry
+ * } from "../declarations/WebpackOptions"
+ */
+/** @import Compiler from "./Compiler" */
+/** @import { EntryOptions } from "./Entrypoint" */
 
 /**
  * @typedef {object} EntryOptionPluginHooks