webpack 5.112.0 → 5.112.1

package/lib/css/syntax-printer.js

@@ -179,6 +179,8 @@ const {
 	_joinSlots,
 	_keepKeywordComments,
 	_lowercaseConditionParts,
+	_memoizeBlockBody,
+	_memoizedBlockBody,
 	_minifyColorFunction,
 	_minifyPolarColorFunction,
 	_nearByteHalf,
@@ -200,6 +202,7 @@ const {
 	_rulesOf,
 	_setHoistedRuns,
 	_setRuleEntry,
+	_setVerbatimLeafPrinter,
 	_shortestAuthoredFlex,
 	_shortestColor,
 	_shortestFlexValue,
@@ -1342,11 +1345,7 @@ const _prefixQualifiedRule = (ruleText, parts, soft, body, scope, top) => {
 		const removable = bases.every(
 			(base, i) =>
 				selectors[i].at === -1 ||
-				_prefixRemovable(
-					PREFIXED_SELECTORS,
-					base,
-					/** @type {string} */ (listPrefix)
-				)
+				_prefixRemovable(PREFIXED_SELECTORS, base, listPrefix)
 		);
 		// Covered when every selector is: a list of twins says the same as one twin
 		// of the list, and the rules writing them need not be one rule.
@@ -2388,12 +2387,17 @@ const _writeNested = (
 	const taken = [];
 	// A rule written in another names its own parent where its list opens on a
 	// combinator, so that parent stays an `&` the next level out writes in.
-	const against =
-		path.parent !== null && path.type(path.parent) !== NodeType.Stylesheet
-			? _parentNamed(prelude)
-			: prelude;
+	// Read only once a rule written in this one asks.
+	/** @type {string | undefined} */
+	let against;
 	for (let i = _pendingNested.length - 1; i >= 0; i--) {
 		if (_pendingNested[i].owner !== node) continue;
+		if (against === undefined) {
+			against =
+				path.parent !== null && path.type(path.parent) !== NodeType.Stylesheet
+					? _parentNamed(prelude)
+					: prelude;
+		}
 		const one = _pendingNested[i];
 		_pendingNested.splice(i, 1);
 		one.prelude = _resolveNestedPrelude(one.prelude, against);
@@ -2504,7 +2508,10 @@ const _hoistedEntry = (text, prelude) => ({
 	listKind: LIST_KIND_SELECTOR,
 	children: null,
 	head: "",
-	unordered: false
+	unordered: false,
+	list: null,
+	block: null,
+	declarations: null
 });
 
 /**
@@ -2516,7 +2523,7 @@ const _hoistedEntry = (text, prelude) => ({
  * @returns {void}
  */
 const _recordHoistedRule = (text, parent, parentPrelude) => {
-	const node = /** @type {Node} */ (_S._currentNode);
+	const node = _S._currentNode;
 	if (parent === null && _nestedRuns.length === 1) {
 		_setRuleEntry(node, _hoistedEntry(text, _nestedRuns[0].prelude));
 		return;
@@ -3190,8 +3197,11 @@ const _numberAlphaValue = (property, value) => {
 	const parts = _LONE_PERCENTAGE_RE.exec(value);
 	if (parts === null) return value;
 	const digits = `00${parts[2]}`;
-	const shifted = _normalizeNumber(
-		`${parts[1]}${digits.slice(0, -2)}.${digits.slice(-2)}${parts[3] || ""}`
+	// A number rounds to fewer digits than the percentage it was printed as.
+	const shifted = _roundSignificant(
+		_normalizeNumber(
+			`${parts[1]}${digits.slice(0, -2)}.${digits.slice(-2)}${parts[3] || ""}`
+		)
 	);
 	return shifted.length < value.length ? shifted : value;
 };
@@ -3587,6 +3597,18 @@ const _dropDefaultGradientPosition = (fn, inner) => {
 	return match[1] === undefined ? rest : `${match[1]},${rest}`;
 };
 
+// The basic shapes `_dropDefaultShapeParts` reads, so every other call is
+// turned away before its arguments are scanned.
+const _BASIC_SHAPE_FUNCTIONS = new Set([
+	"polygon",
+	"path",
+	"circle",
+	"ellipse",
+	"inset",
+	"rect",
+	"xywh"
+]);
+
 /**
  * Drop what a basic shape (CSS Shapes 1 §3) says with its own defaults: a
  * `closest-side` radius, a zero corner `round`, `nonzero`, and the sides an
@@ -3596,7 +3618,11 @@ const _dropDefaultGradientPosition = (fn, inner) => {
  * @returns {string | null} the arguments without them, or null to keep them
  */
 const _dropDefaultShapeParts = (fn, inner) => {
-	if (!_S._transforms.reduceFunctions || containsSubstitutionFunction(inner)) {
+	if (
+		!_BASIC_SHAPE_FUNCTIONS.has(fn) ||
+		!_S._transforms.reduceFunctions ||
+		containsSubstitutionFunction(inner)
+	) {
 		return null;
 	}
 	if (fn === "polygon" || fn === "path") {
@@ -4285,6 +4311,23 @@ const _standardSpelling = (property) => {
 	return standard === undefined ? property : standard;
 };
 
+/**
+ * What `_composeBlockBody` hands back for a block of declarations alone whose
+ * body was composed before.
+ * @param {string} body the body
+ * @returns {ReturnType<typeof _composeBlockBody>} the composition
+ */
+const _memoizedComposition = (body) => ({
+	body,
+	items: [],
+	texts: [],
+	superseded: null,
+	droppedPrefix: null,
+	addedPrefix: null,
+	deadPrefixed: null,
+	spans: null
+});
+
 /**
  * Shorten a shorthand declaration's value to an equivalent spelling. A prefixed
  * spelling is a different property, and neither table lists one.
@@ -4465,6 +4508,7 @@ const _dropFontNormals = (components) => {
  * @returns {string[] | null} the fragments to join, or `null` to keep the value
  */
 const _shortenIndividualTransform = (property, components) => {
+	if (property !== "translate" && property !== "scale") return null;
 	if (components.length > 3) return null;
 	if (components.some((one) => one.includes("(") || one.includes(","))) {
 		return null;
@@ -4486,7 +4530,7 @@ const _shortenIndividualTransform = (property, components) => {
 		for (let i = 0; i < kept.length; i++) {
 			const percentage = _PERCENTAGE_RE.exec(kept[i]);
 			if (percentage === null) continue;
-			const number = _shiftDecimal(percentage[1], -2);
+			const number = _roundSignificant(_shiftDecimal(percentage[1], -2));
 			if (number.length <= kept[i].length) kept[i] = number;
 		}
 		if (kept.length === 3 && Number(kept[2]) === 1) kept.pop();
@@ -5625,11 +5669,12 @@ const printer = (path, writer) => {
 			}
 			// Read before the body: composing it is what leaves the block empty, and
 			// the drop below asks the same question again.
-			const unusedRule = _takeUnusedRule(/** @type {Node} */ (_S._currentNode));
+			const unusedRule = _takeUnusedRule(_S._currentNode);
 			const rules = _rulesOf(path.node);
 			// `nl` prefixes each item: nothing minifying, a line break beautifying
 			// (declarations end in `;`, rules don't).
 			const nl = minify ? "" : "\n";
+			const memoized = _memoizedBlockBody(_S._currentNode);
 			const {
 				body,
 				items,
@@ -5639,15 +5684,23 @@ const printer = (path, writer) => {
 				addedPrefix,
 				deadPrefixed,
 				spans
-			} = _composeBlockBody(
-				path,
-				decls,
-				rules,
-				writer,
-				minify,
-				nl,
+			} =
+				memoized === undefined
+					? _composeBlockBody(
+							path,
+							decls,
+							rules,
+							writer,
+							minify,
+							nl,
+							_S._currentNode,
+							unusedRule
+						)
+					: // A rule its selector made unused writes nothing, whatever its block.
+						_memoizedComposition(unusedRule ? "" : memoized);
+			_memoizeBlockBody(
 				_S._currentNode,
-				unusedRule
+				memoized === undefined && !unusedRule ? body : null
 			);
 			if (
 				minify &&
@@ -5671,13 +5724,7 @@ const printer = (path, writer) => {
 				);
 				{
 					const written =
-						_writeNested(
-							path,
-							/** @type {Node} */ (_S._currentNode),
-							prelude,
-							null,
-							true
-						) || "";
+						_writeNested(path, _S._currentNode, prelude, null, true) || "";
 					if (minify && written.length !== 0) {
 						_recordHoistedRule(written, null, 0);
 					}
@@ -5772,12 +5819,12 @@ const printer = (path, writer) => {
 			const copies =
 				out === text ||
 				_prefixCopyPreludes.length === 0 ||
-				_holdsNested(/** @type {Node} */ (_S._currentNode))
+				_holdsNested(_S._currentNode)
 					? undefined
 					: _prefixCopyPreludes;
 			const nested = _writeNested(
 				path,
-				/** @type {Node} */ (_S._currentNode),
+				_S._currentNode,
 				prelude,
 				ownRest,
 				out === text || copies !== undefined,
@@ -5835,7 +5882,10 @@ const printer = (path, writer) => {
 					// The block's own merges have run and settled what they grew, so the
 					// text above and the children agree; a list one of them still carries
 					// concatenated is one this block says is there to settle.
-					unordered: _anyUnordered(children)
+					unordered: _anyUnordered(children),
+					list: null,
+					block: null,
+					declarations: null
 				});
 			}
 			if (minify && path.type() === NodeType.QualifiedRule) {
@@ -5868,7 +5918,10 @@ const printer = (path, writer) => {
 					listKind,
 					children: null,
 					head: "",
-					unordered: false
+					unordered: false,
+					list: null,
+					block: null,
+					declarations: null
 				});
 			}
 			return text;
@@ -6034,4 +6087,6 @@ const _renderDataUrl = (url) => {
 	return buildDataURI(read.parsed, rendered);
 };
 
+_setVerbatimLeafPrinter(printer);
+
 module.exports.printer = printer;

package/lib/debug/ProfilingPlugin.js

@@ -34,23 +34,7 @@ const { fileUrlToPath } = require("../util/identifier");
  * @property {AbsolutePath=} outputPath Path to the output file e.g. `path.resolve(__dirname, 'profiling/events.json')`. Defaults to `events.json`.
  */
 
-/**
- * Defines the hook type used by this module.
- * @template T, R
- * @typedef {import("tapable").Hook<T, R>} Hook
- */
-
-/**
- * Defines the fake hook type used by this module.
- * @template T
- * @typedef {import("../util/deprecation").FakeHook<T>} FakeHook
- */
-
-/**
- * Defines the hook map type used by this module.
- * @template T
- * @typedef {import("tapable").HookMap<T>} HookMap
- */
+/** @import { FakeHookMarker } from "../util/deprecation" */
 
 /**
  * Defines the hook interceptor type used by this module.
@@ -96,8 +80,7 @@ class Profiler {
 
 		try {
 			this.session = new /** @type {Inspector} */ (inspector).Session();
-			/** @type {Session} */
-			(this.session).connect();
+			this.session.connect();
 		} catch (_) {
 			this.session = undefined;
 			return Promise.resolve();
@@ -119,7 +102,7 @@ class Profiler {
 	 * Returns promise for the result.
 	 * @param {string} method method name
 	 * @param {import("inspector").Profiler.SetSamplingIntervalParameterType=} params params
-	 * @returns {Promise<EXPECTED_ANY | void>} Promise for the result
+	 * @returns {Promise<Partial<import("inspector").Profiler.StopReturnType> | void>} Promise for the result, `{}` for commands without one
 	 */
 	sendCommand(method, params) {
 		if (this.hasSession()) {
@@ -151,7 +134,9 @@ class Profiler {
 	 * @returns {Promise<{ profile: { startTime: number, endTime: number } }>} profile result
 	 */
 	stopProfiling() {
-		return this.sendCommand("Profiler.stop").then(({ profile }) => {
+		return /** @type {Promise<import("inspector").Profiler.StopReturnType>} */ (
+			this.sendCommand("Profiler.stop")
+		).then(({ profile }) => {
 			const hrtime = process.hrtime();
 			const endTime = hrtime[0] * 1000000 + Math.round(hrtime[1] / 1000);
 			// Avoid coverage problems due indirect changes
@@ -406,18 +391,34 @@ class ProfilingPlugin {
 	}
 }
 
-/** @typedef {Record<string, Hook<EXPECTED_ANY, EXPECTED_ANY> | FakeHook<EXPECTED_ANY> | HookMap<EXPECTED_ANY>>} Hooks */
+/**
+ * The part of a tapable `HookInterceptor` this plugin sets: it rewraps each tap.
+ * @typedef {{ register?(tap: FullTap): FullTap }} TapInterceptor
+ */
+
+/**
+ * What intercepting a tapable `Hook` needs of it. Methods, so every hook fits
+ * whatever its arguments, result and additional tap options.
+ * @typedef {{ intercept(interceptor: TapInterceptor): void, _fakeHook?: undefined }} HookWithInterceptor
+ */
+
+/**
+ * What intercepting a tapable `HookMap` needs of it, whatever hook it holds.
+ * @typedef {{ for(key: string): HookWithInterceptor, intercept(interceptor: { factory?(key: string, hook: HookWithInterceptor): HookWithInterceptor }): void, _fakeHook?: undefined }} HookMapWithInterceptor
+ */
+
+/** @typedef {Record<string, HookWithInterceptor | HookMapWithInterceptor | FakeHookMarker>} Hooks */
 
 /**
  * Intercepts the taps of a hook or every cached and future hook in a hook map.
- * @param {Hooks[string]} hook the hook or hook map
- * @param {HookInterceptor<EXPECTED_ANY, EXPECTED_ANY>} interceptor what intercepts each tap
+ * @param {HookWithInterceptor | HookMapWithInterceptor} hook the hook or hook map
+ * @param {TapInterceptor} interceptor what intercepts each tap
  * @returns {void}
  */
 const interceptTaps = (hook, interceptor) => {
 	if ("for" in hook) {
 		const { _map } =
-			/** @type {HookMap<Hook<EXPECTED_ANY, EXPECTED_ANY>> & { _map: Map<unknown, Hook<EXPECTED_ANY, EXPECTED_ANY>> }} */
+			/** @type {HookMapWithInterceptor & { _map: Map<string, HookWithInterceptor> }} */
 			(hook);
 		for (const cached of _map.values()) {
 			cached.intercept(interceptor);
@@ -425,8 +426,8 @@ const interceptTaps = (hook, interceptor) => {
 		hook.intercept({
 			/**
 			 * @param {string} key the key the hook is created for
-			 * @param {Hook<EXPECTED_ANY, EXPECTED_ANY>} created the hook created
-			 * @returns {Hook<EXPECTED_ANY, EXPECTED_ANY>} the same hook, intercepted
+			 * @param {HookWithInterceptor} created the hook created
+			 * @returns {HookWithInterceptor} the same hook, intercepted
 			 */
 			factory: (key, created) => {
 				created.intercept(interceptor);
@@ -533,7 +534,25 @@ const interceptAllCssModulesPluginHooks = (compilation, tracer) => {
 	);
 };
 
-/** @typedef {(...args: EXPECTED_ANY[]) => EXPECTED_ANY | Promise<(...args: EXPECTED_ANY[]) => EXPECTED_ANY>} PluginFunction */
+/**
+ * A `sync` tap's function, or a `promise` tap's when `R` is a promise.
+ * @template {unknown[]} A the hook's arguments
+ * @template R what the tap returns
+ * @typedef {(...args: A) => R} PluginFunction
+ */
+
+/**
+ * The callback an `async` tap reports its error or result through.
+ * @template R the hook's result
+ * @typedef {(error?: Error | null, result?: R) => void} TapCallback
+ */
+
+/**
+ * An `async` tap's function, the hook's callback after its arguments.
+ * @template {unknown[]} A the hook's arguments
+ * @template R the hook's result
+ * @typedef {(...args: [...A, TapCallback<R>]) => void} AsyncPluginFunction
+ */
 
 /**
  * Creates interceptor for.
@@ -556,7 +575,7 @@ const makeInterceptorFor = (instance, tracer) => (hookName) => ({
 				: makeNewProfiledTapFn(hookName, tracer, {
 						name,
 						type,
-						fn: /** @type {PluginFunction} */ (internalFn)
+						fn: internalFn
 					});
 		return { ...tapInfo, fn: newFn };
 	}
@@ -564,20 +583,22 @@ const makeInterceptorFor = (instance, tracer) => (hookName) => ({
 
 /**
  * Creates new profiled tap fn.
+ * @template {unknown[]} A the hook's arguments
+ * @template R the hook's result
  * @param {string} hookName Name of the hook to profile.
  * @param {Trace} tracer The trace object.
  * @param {object} options Options for the profiled fn.
  * @param {string} options.name Plugin name
  * @param {"sync" | "async" | "promise"} options.type Plugin type (sync | async | promise)
- * @param {PluginFunction} options.fn Plugin function
- * @returns {PluginFunction} Chainable hooked function.
+ * @param {FullTap["fn"]} options.fn Plugin function, its shape set by `options.type`
+ * @returns {FullTap["fn"]} Chainable hooked function.
  */
 const makeNewProfiledTapFn = (hookName, tracer, { name, type, fn }) => {
 	const defaultCategory = ["blink.user_timing"];
 
 	switch (type) {
 		case "promise":
-			return (...args) => {
+			return /** @type {PluginFunction<A, Promise<R>>} */ (...args) => {
 				const id = ++tracer.counter;
 				tracer.trace.begin({
 					name,
@@ -585,8 +606,8 @@ const makeNewProfiledTapFn = (hookName, tracer, { name, type, fn }) => {
 					cat: defaultCategory
 				});
 				const promise =
-					/** @type {Promise<(...args: EXPECTED_ANY[]) => EXPECTED_ANY>} */
-					(fn(...args));
+					/** @type {PluginFunction<A, Promise<R>>} */
+					(fn)(...args);
 				return promise.then((r) => {
 					tracer.trace.end({
 						name,
@@ -597,19 +618,20 @@ const makeNewProfiledTapFn = (hookName, tracer, { name, type, fn }) => {
 				});
 			};
 		case "async":
-			return (...args) => {
+			return /** @type {AsyncPluginFunction<A, R>} */ (...args) => {
 				const id = ++tracer.counter;
 				tracer.trace.begin({
 					name,
 					id,
 					cat: defaultCategory
 				});
-				const callback = args.pop();
-				fn(
-					...args,
+				const callback = /** @type {TapCallback<R>} */ (args.pop());
+				/** @type {AsyncPluginFunction<A, R>} */ (fn)(
+					// `pop()` took the callback off, which the tuple type cannot follow.
+					.../** @type {A} */ (/** @type {unknown[]} */ (args)),
 					/**
 					 * Handles the cat callback for this hook.
-					 * @param {...EXPECTED_ANY[]} r result
+					 * @param {Parameters<TapCallback<R>>} r result
 					 */
 					(...r) => {
 						tracer.trace.end({
@@ -622,12 +644,12 @@ const makeNewProfiledTapFn = (hookName, tracer, { name, type, fn }) => {
 				);
 			};
 		case "sync":
-			return (...args) => {
+			return /** @type {PluginFunction<A, R>} */ (...args) => {
 				const id = ++tracer.counter;
 				// Do not instrument ourself due to the CPU
 				// profile needing to be the last event in the trace.
 				if (name === PLUGIN_NAME) {
-					return fn(...args);
+					return /** @type {PluginFunction<A, R>} */ (fn)(...args);
 				}
 
 				tracer.trace.begin({
@@ -635,10 +657,10 @@ const makeNewProfiledTapFn = (hookName, tracer, { name, type, fn }) => {
 					id,
 					cat: defaultCategory
 				});
-				/** @type {PluginFunction} */
+				/** @type {R} */
 				let r;
 				try {
-					r = fn(...args);
+					r = /** @type {PluginFunction<A, R>} */ (fn)(...args);
 				} catch (err) {
 					tracer.trace.end({
 						name,

package/lib/define/DefinePlugin.js

@@ -255,7 +255,7 @@ const dropTrailingMembers = (node, count) => {
 
 /**
  * Returns code converted to string that evaluates.
- * @param {EXPECTED_ANY[] | { [k: string]: EXPECTED_ANY }} obj obj
+ * @param {CodeValue[] | Record<string, CodeValue>} obj obj
  * @param {JavascriptParser} parser Parser
  * @param {ValueCacheVersions} valueCacheVersions valueCacheVersions
  * @param {string} key the defined key
@@ -376,7 +376,7 @@ const toCode = (
 		}
 		if (typeof code === "object") {
 			return stringifyObj(
-				code,
+				/** @type {CodeValue[] | Record<string, CodeValue>} */ (code),
 				parser,
 				valueCacheVersions,
 				key,
@@ -675,7 +675,7 @@ const stringifyMergedNode = (merged, node, parser, key, objKeys) => {
 	}
 	const code = `{${keys
 		.map((k) => {
-			const value = /** @type {MergedDefinitionNode} */ (node.get(k));
+			const value = node.get(k);
 			return `${toPropertyKey(k)}:${
 				value instanceof Map
 					? stringifyMergedNode(merged, value, parser, k)
@@ -1115,7 +1115,9 @@ class DefinePlugin {
 									// so scanning that text cannot find every reference.
 									const hasPreparsedAst =
 										/** @type {{ _ast: PreparsedAst | null }} */ (
-											/** @type {unknown} */ (module)
+											/** @type {NormalModule | { _ast: PreparsedAst | null }} */ (
+												module
+											)
 										)._ast !== null;
 									await resolveAsyncRuntimeValues(
 										compilation,
@@ -1139,9 +1141,7 @@ class DefinePlugin {
 						/** @type {ValueCacheVersion} */
 						(compilation.valueCacheVersions.get(VALUE_DEP_MAIN));
 					parser.hooks.program.tap(PLUGIN_NAME, () => {
-						const buildInfo = /** @type {NormalModuleBuildInfo} */ (
-							parser.state.module.buildInfo
-						);
+						const buildInfo = parser.state.module.buildInfo;
 						if (!buildInfo.valueDependencies) {
 							buildInfo.valueDependencies = new Map();
 						}
@@ -1153,9 +1153,7 @@ class DefinePlugin {
 					 * @param {string} key key
 					 */
 					const addValueDependency = (key) => {
-						const buildInfo =
-							/** @type {NormalModuleBuildInfo} */
-							(parser.state.module.buildInfo);
+						const buildInfo = parser.state.module.buildInfo;
 						/** @type {NonNullable<NormalModuleBuildInfo["valueDependencies"]>} */
 						(buildInfo.valueDependencies).set(
 							VALUE_DEP_PREFIX + key,
@@ -1229,7 +1227,7 @@ class DefinePlugin {
 							// several DefinePlugins can still be destructured together
 							const nestedSet = mergedDefinitions.nestedByFinalKey.get(final);
 							if (!nestedSet || nestedSet.size <= 0) return;
-							for (const nested of /** @type {Set<string>} */ (nestedSet)) {
+							for (const nested of nestedSet) {
 								if (nested && !hooked.has(nested)) {
 									// only detect the same nested key once
 									hooked.add(nested);
@@ -1475,10 +1473,7 @@ class DefinePlugin {
 						parser.hooks.expression.for(key).tap(PLUGIN_NAME, (expr) => {
 							const valueDependencies =
 								/** @type {NonNullable<NormalModuleBuildInfo["valueDependencies"]>} */
-								(
-									/** @type {NormalModuleBuildInfo} */
-									(parser.state.module.buildInfo).valueDependencies
-								);
+								(parser.state.module.buildInfo.valueDependencies);
 							for (const [name, version] of objectValueDependencies) {
 								valueDependencies.set(name, version);
 							}

package/lib/define/DotenvPlugin.js

@@ -281,7 +281,11 @@ class DotenvPlugin {
 				{
 					name: "Dotenv Plugin",
 					baseDataPath: "options"
-				}
+				},
+				(options) =>
+					require("../../schemas/plugins/define/DotenvPluginOptions.check")(
+						options
+					)
 			);
 		});
 		const definePlugin = new compiler.webpack.DefinePlugin({});
@@ -491,6 +495,8 @@ class DotenvPlugin {
 	 * @returns {Env} env variables
 	 */
 	_getEnv(prefixes, parsed) {
+		// Expansion mutates its input, but the cache must retain the raw file values.
+		parsed = Object.assign(/** @type {Env} */ (Object.create(null)), parsed);
 		// Always expand environment variables (like Vite does)
 		// Make a copy of process.env so that dotenv-expand doesn't modify global process.env
 		const processEnv = { ...process.env };
@@ -503,11 +509,9 @@ class DotenvPlugin {
 		// Prioritize actual env variables from `process.env`, fallback to parsed
 		for (const key of keys) {
 			if (prefixes.some((prefix) => key.startsWith(prefix))) {
-				env[key] =
-					Object.prototype.hasOwnProperty.call(process.env, key) &&
-					process.env[key]
-						? process.env[key]
-						: parsed[key];
+				env[key] = Object.prototype.hasOwnProperty.call(process.env, key)
+					? /** @type {string} */ (process.env[key])
+					: parsed[key];
 			}
 		}
 

package/lib/define/EnvironmentPlugin.js

@@ -10,23 +10,25 @@ const DefinePlugin = require("./DefinePlugin");
 
 /** @import Compiler from "../Compiler" */
 /** @import { CodeValue } from "./DefinePlugin" */
+/** @import { JsonObject } from "../fs/fs" */
 
 const PLUGIN_NAME = "EnvironmentPlugin";
 
 class EnvironmentPlugin {
 	/**
 	 * Creates an instance of EnvironmentPlugin.
-	 * @param {(string | string[] | Record<string, EXPECTED_ANY>)[]} keys keys
+	 * @param {(string | string[] | JsonObject)[]} keys keys
 	 */
 	constructor(...keys) {
 		if (keys.length === 1 && Array.isArray(keys[0])) {
 			/** @type {string[]} */
 			this.keys = keys[0];
+			/** @type {JsonObject} */
 			this.defaultValues = {};
 		} else if (keys.length === 1 && keys[0] && typeof keys[0] === "object") {
 			this.keys = Object.keys(keys[0]);
 			this.defaultValues =
-				/** @type {Record<string, EXPECTED_ANY>} */
+				/** @type {JsonObject} */
 				(keys[0]);
 		} else {
 			this.keys = /** @type {string[]} */ (keys);

package/lib/dependencies/amd/AMDDefineDependencyParserPlugin.js

@@ -36,7 +36,6 @@ const { addLocalModule, getLocalModule } = require("./LocalModulesHelpers");
  * } from "../../../declarations/WebpackOptions"
  */
 /** @import Dependency from "../../graph/Dependency" */
-/** @import { BuildInfo } from "../../module/Module" */
 /** @import BasicEvaluatedExpression from "../../javascript/BasicEvaluatedExpression" */
 /**
  * @import JavascriptParser, {
@@ -356,7 +355,7 @@ class AMDDefineDependencyParserPlugin {
 		}
 		DynamicExports.bailout(parser.state);
 		recordOptimizationBailout(
-			/** @type {BuildInfo} */ (parser.state.module.buildInfo),
+			parser.state.module.buildInfo,
 			"AMD bailout: define() prevents static exports analysis"
 		);
 		/** @type {Identifier[] | null} */

package/lib/dependencies/amd/AMDRequireDependenciesBlockParserPlugin.js

@@ -39,6 +39,7 @@ const getUnsupportedFeatureWarning = memoize(() =>
  * } from "../../../declarations/WebpackOptions"
  */
 /** @import Dependency, { DependencyLocation } from "../../graph/Dependency" */
+/** @import DependenciesBlock from "../../graph/DependenciesBlock" */
 /** @import BasicEvaluatedExpression from "../../javascript/BasicEvaluatedExpression" */
 /** @import JavascriptParser, { Range } from "../../javascript/JavascriptParser" */
 /** @import LocalModule from "./LocalModule" */
@@ -323,7 +324,9 @@ class AMDRequireDependenciesBlockParserPlugin {
 			dep.loc = parser.getLocation(expr);
 			depBlock.addDependency(dep);
 
-			parser.state.current = /** @type {EXPECTED_ANY} */ (depBlock);
+			parser.state.current = /** @type {typeof parser.state.current} */ (
+				/** @type {DependenciesBlock} */ (depBlock)
+			);
 		}
 
 		if (expr.arguments.length === 1) {