@depup/webpack 5.111.1-depup.1 → 5.112.0-depup.0

package/lib/{DefinePlugin.js → define/DefinePlugin.js}

@@ -6,44 +6,47 @@
 "use strict";
 
 const { SyncWaterfallHook } = require("tapable");
+const ConstDependency = require("../dependencies/core/ConstDependency");
+const WebpackError = require("../errors/WebpackError");
+const BasicEvaluatedExpression = require("../javascript/BasicEvaluatedExpression");
+const { isVariableInfo } = require("../javascript/JavascriptParser");
+const {
+	evaluateToString,
+	toConstantDependency
+} = require("../javascript/JavascriptParserHelpers");
 const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
 	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
 	JAVASCRIPT_MODULE_TYPE_ESM
-} = require("./ModuleTypeConstants");
-const RuntimeGlobals = require("./RuntimeGlobals");
-const ConstDependency = require("./dependencies/ConstDependency");
-const WebpackError = require("./errors/WebpackError");
-const BasicEvaluatedExpression = require("./javascript/BasicEvaluatedExpression");
-const { VariableInfo } = require("./javascript/JavascriptParser");
-const {
-	evaluateToString,
-	toConstantDependency
-} = require("./javascript/JavascriptParserHelpers");
-const { getBuildDiagnostics } = require("./util/buildDiagnostics");
-const createHash = require("./util/createHash");
-const createHooksRegistry = require("./util/createHooksRegistry");
+} = require("../module/ModuleTypeConstants");
+const NormalModule = require("../module/NormalModule");
+const RuntimeGlobals = require("../runtime/RuntimeGlobals");
+const { getBuildDiagnostics } = require("../util/buildDiagnostics");
+const createHash = require("../util/createHash");
+const createHooksRegistry = require("../util/createHooksRegistry");
 
 /** @import { Expression, MemberExpression } from "estree" */
-/** @import Compiler from "./Compiler" */
+/** @import { Source } from "webpack-sources" */
+/** @import Compiler from "../Compiler" */
+/** @import { PreparsedAst } from "../module/Parser" */
 /**
- * @import {
+ * @import Module, {
  * 	BuildInfo,
  * 	ValueCacheVersion,
  * 	ValueCacheVersions
- * } from "./Module"
+ * } from "../module/Module"
  */
-/** @import NormalModule, { NormalModuleBuildInfo } from "./NormalModule" */
-/** @import RuntimeTemplate from "./RuntimeTemplate" */
+/** @import { NormalModuleBuildInfo } from "../module/NormalModule" */
+/** @import RuntimeTemplate from "../template/RuntimeTemplate" */
 /**
  * @import JavascriptParser, {
  * 	DestructuringAssignmentProperties,
  * 	Members,
  * 	Range
- * } from "./javascript/JavascriptParser"
+ * } from "../javascript/JavascriptParser"
  */
-/** @import { Logger } from "./logging/Logger" */
-/** @import Compilation from "./Compilation" */
+/** @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 */
@@ -56,9 +59,30 @@ const createHooksRegistry = require("./util/createHooksRegistry");
  * @property {string[]=} missingDependencies
  * @property {string[]=} buildDependencies
  * @property {string | (() => string)=} version
+ * @property {boolean=} async resolve the generator before parsing, including promise-returning functions not declared `async`
+ */
+
+/** @typedef {CodeValuePrimitive | PromiseLike<CodeValuePrimitive>} GeneratedValue */
+/** @typedef {(value: { module: NormalModule, key: string, readonly version: ValueCacheVersion }) => GeneratedValue} GeneratorFn */
+
+/**
+ * Whether the generator is declared `async`.
+ * @param {GeneratorFn} fn generator function
+ * @returns {boolean} true when the generator is an async function
  */
+const isAsyncFunction = (fn) =>
+	Object.prototype.toString.call(fn) === "[object AsyncFunction]";
 
-/** @typedef {(value: { module: NormalModule, key: string, readonly version: ValueCacheVersion }) => CodeValuePrimitive} GeneratorFn */
+/**
+ * Whether a generated value still has to be awaited.
+ * @param {GeneratedValue} value what the generator returned
+ * @returns {value is PromiseLike<CodeValuePrimitive>} true for a thenable
+ */
+const isThenable = (value) =>
+	(typeof value === "object" || typeof value === "function") &&
+	value !== null &&
+	typeof (/** @type {PromiseLike<CodeValuePrimitive>} */ (value).then) ===
+		"function";
 
 class RuntimeValue {
 	/**
@@ -76,6 +100,15 @@ class RuntimeValue {
 		}
 		/** @type {true | RuntimeValueOptions} */
 		this.options = options || {};
+		/**
+		 * Resolved before the module is parsed, since the parser cannot wait.
+		 * Use the option for promise-returning functions not declared `async`.
+		 * @type {boolean}
+		 */
+		this.async =
+			this.options !== true && typeof this.options.async === "boolean"
+				? this.options.async
+				: isAsyncFunction(fn);
 	}
 
 	get fileDependencies() {
@@ -83,14 +116,14 @@ class RuntimeValue {
 	}
 
 	/**
-	 * Returns code.
-	 * @param {JavascriptParser} parser the parser
-	 * @param {ValueCacheVersions} valueCacheVersions valueCacheVersions
+	 * Records what the value is computed from on the module it is rendered into,
+	 * so a change to any of it rebuilds that module.
+	 * @param {NormalModule} module the module the value is rendered into
 	 * @param {string} key the defined key
-	 * @returns {CodeValuePrimitive} code
+	 * @returns {void}
 	 */
-	exec(parser, valueCacheVersions, key) {
-		const buildInfo = /** @type {BuildInfo} */ (parser.state.module.buildInfo);
+	addDependencies(module, key) {
+		const buildInfo = /** @type {BuildInfo} */ (module.buildInfo);
 		if (this.options === true) {
 			buildInfo.cacheable = false;
 			const diagnostics = getBuildDiagnostics(buildInfo);
@@ -125,9 +158,18 @@ class RuntimeValue {
 				}
 			}
 		}
+	}
 
+	/**
+	 * Runs the generator for one module.
+	 * @param {NormalModule} module the module the value is rendered into
+	 * @param {ValueCacheVersions} valueCacheVersions valueCacheVersions
+	 * @param {string} key the defined key
+	 * @returns {GeneratedValue} the value, or a promise of it
+	 */
+	call(module, valueCacheVersions, key) {
 		return this.fn({
-			module: parser.state.module,
+			module,
 			key,
 			get version() {
 				return /** @type {ValueCacheVersion} */ (
@@ -137,6 +179,32 @@ class RuntimeValue {
 		});
 	}
 
+	/**
+	 * Returns code.
+	 * @param {JavascriptParser} parser the parser
+	 * @param {ValueCacheVersions} valueCacheVersions valueCacheVersions
+	 * @param {string} key the defined key
+	 * @returns {CodeValuePrimitive} code
+	 */
+	exec(parser, valueCacheVersions, key) {
+		const module = parser.state.module;
+		this.addDependencies(module, key);
+
+		if (this.async) return getResolvedValue(module, this, key);
+
+		const value = this.call(module, valueCacheVersions, key);
+
+		if (isThenable(value)) {
+			// Consume a rejection even though the synchronous parser cannot await it.
+			Promise.resolve(value).catch(() => {});
+			throw new WebpackError(
+				`DefinePlugin: the runtime value for "${key}" returned a Promise, but the generator was not declared asynchronous. Declare it with \`async\`, or set \`async: true\` in its options, so webpack can resolve it before the module is parsed.`
+			);
+		}
+
+		return value;
+	}
+
 	getCacheVersion() {
 		return this.options === true
 			? undefined
@@ -400,6 +468,7 @@ const EMPTY_OBJECT = {};
  * @property {Map<string, Set<string>>} nestedByFinalKey nested object keys by final key segment
  * @property {Map<string, string[]>} keysByPrefix definition keys below each dotted-key prefix
  * @property {boolean} hasRuntimeValue renders are module-dependent (RuntimeValue present)
+ * @property {boolean} hasAsyncRuntimeValue asynchronous generators need to resolve before parsing
  * @property {WeakMap<MergedDefinitionMap, string>} codeCache rendered code per node (static trees only)
  * @property {Logger} logger the logger
  */
@@ -429,13 +498,14 @@ const toPropertyKey = (key) =>
 /**
  * Whether a definition value contains a RuntimeValue (module-dependent code).
  * @param {CodeValue} value definition value
+ * @param {boolean=} asyncOnly whether only asynchronous generators count
  * @returns {boolean} true when a RuntimeValue is contained
  */
-const containsRuntimeValue = (value) => {
-	if (value instanceof RuntimeValue) return true;
+const containsRuntimeValue = (value, asyncOnly = false) => {
+	if (value instanceof RuntimeValue) return !asyncOnly || value.async;
 	if (isObjectDefinition(value)) {
 		for (const key of Object.keys(value)) {
-			if (containsRuntimeValue(value[key])) return true;
+			if (containsRuntimeValue(value[key], asyncOnly)) return true;
 		}
 	}
 	return false;
@@ -515,11 +585,15 @@ const getMergedDefinitions = (compilation) => {
 		}
 	};
 	let hasRuntimeValue = false;
+	let hasAsyncRuntimeValue = false;
 	/** @type {Map<string, string[]>} */
 	const keysByPrefix = new Map();
 	for (const key of Object.keys(definitions)) {
-		if (TYPEOF_OPERATOR_REGEXP.test(key)) continue;
 		const code = definitions[key];
+		if (!hasAsyncRuntimeValue && containsRuntimeValue(code, true)) {
+			hasAsyncRuntimeValue = true;
+		}
+		if (TYPEOF_OPERATOR_REGEXP.test(key)) continue;
 		insertMergedDefinition(root, key.split("."), code);
 		if (!hasRuntimeValue && containsRuntimeValue(code)) hasRuntimeValue = true;
 		// group this key under every ancestor prefix (value deps of object reads)
@@ -536,7 +610,9 @@ const getMergedDefinitions = (compilation) => {
 				keysByPrefix.set(prefix, [key]);
 			}
 		}
-		if (!code || typeof code === "object") continue;
+		// a nested object is walked separately and an empty string renders to
+		// no code; every other shape is a destructurable leaf, falsy included
+		if (isObjectDefinition(code) || code === "") continue;
 		const idx = key.lastIndexOf(".");
 		if (idx <= 0 || idx >= key.length - 1) continue;
 		const nested = key.slice(0, idx);
@@ -552,6 +628,7 @@ const getMergedDefinitions = (compilation) => {
 		nestedByFinalKey,
 		keysByPrefix,
 		hasRuntimeValue,
+		hasAsyncRuntimeValue,
 		codeCache: new WeakMap(),
 		logger: compilation.getLogger("webpack.DefinePlugin")
 	};
@@ -678,15 +755,256 @@ const createCompilationHooks = () => ({
  * @returns {Error} the annotated error
  */
 const annotateEvaluationError = (key, code, error) => {
-	const value = typeof code === "string" ? code : JSON.stringify(code);
+	// a RuntimeValue holds the generator, not code: JSON drops the function and
+	// leaves only its options, which says nothing about what failed
+	const value =
+		code instanceof RuntimeValue
+			? `runtimeValue(${code.fn.name || "anonymous"})`
+			: typeof code === "string"
+				? code
+				: JSON.stringify(code);
 	const prefix = `DefinePlugin: failed to evaluate value for "${key}" (\`${value}\`)`;
 	if (error instanceof Error) {
-		error.message = `${prefix}: ${error.message}`;
+		// one instance can reach several modules, so prefix it only once
+		if (!error.message.startsWith(prefix)) {
+			error.message = `${prefix}: ${error.message}`;
+		}
 		return error;
 	}
 	return new WebpackError(`${prefix}: ${error}`);
 };
 
+/** @typedef {{ value: CodeValuePrimitive } | { error: unknown }} ResolvedRuntimeValue */
+/** @typedef {Map<RuntimeValue, Map<string, ResolvedRuntimeValue>>} ResolvedRuntimeValues */
+/** @typedef {{ value: RuntimeValue, keys: Set<string>, roots: Set<string> }} AsyncRuntimeValue */
+
+/**
+ * Values resolved during the async build, ready for synchronous parser hooks.
+ * @type {WeakMap<Module, ResolvedRuntimeValues>}
+ */
+const RESOLVED_RUNTIME_VALUES = new WeakMap();
+
+/**
+ * @typedef {object} AsyncRuntimeDefinitions
+ * @property {Map<RuntimeValue, AsyncRuntimeValue>} values async generators
+ * @property {Map<string, string[]>} references replacement code by definition root
+ * @property {Set<string>} dynamicRoots roots whose synchronous generators may return more references
+ */
+
+/** @type {WeakMap<Compilation, AsyncRuntimeDefinitions>} */
+const ASYNC_RUNTIME_VALUES = new WeakMap();
+
+/** @type {WeakSet<Compilation>} */
+const ASYNC_RESOLUTION_TAPPED = new WeakSet();
+
+/** @type {WeakSet<JavascriptParser>} */
+const ASYNC_PARSERS = new WeakSet();
+
+const IDENTIFIER_ESCAPE_REGEXP =
+	/\\u(?:\{([\da-fA-F]{1,6})\}|([\da-fA-F]{4}))/g;
+
+/**
+ * Includes escaped spellings when checking whether source may use a definition.
+ * @param {string} source source or replacement code
+ * @returns {string} source with Unicode escapes decoded
+ */
+const decodeIdentifierEscapes = (source) =>
+	source.includes("\\u")
+		? source.replace(IDENTIFIER_ESCAPE_REGEXP, (escape, point, unit) => {
+				const value = Number.parseInt(point || unit, 16);
+				return value <= 0x10ffff ? String.fromCodePoint(value) : escape;
+			})
+		: source;
+
+/**
+ * Collects runtime values under their dotted, object-member and array keys.
+ * @param {CodeValue} code definition value
+ * @param {Set<string>} keys keys the value can be rendered under
+ * @param {string} root first segment of the definition key
+ * @param {AsyncRuntimeDefinitions} into collected definitions
+ * @returns {void}
+ */
+const collectAsyncRuntimeValues = (code, keys, root, into) => {
+	if (code instanceof RuntimeValue) {
+		if (!code.async) {
+			into.dynamicRoots.add(root);
+			return;
+		}
+		const collected = into.values.get(code);
+		// one instance can be defined under more than one key
+		if (collected === undefined) {
+			into.values.set(code, {
+				value: code,
+				keys: new Set(keys),
+				roots: new Set([root])
+			});
+			return;
+		}
+		for (const key of keys) collected.keys.add(key);
+		collected.roots.add(root);
+		return;
+	}
+	if (!isObjectDefinition(code)) {
+		const reference = decodeIdentifierEscapes(String(code));
+		const references = into.references.get(root);
+		if (references) references.push(reference);
+		else into.references.set(root, [reference]);
+		return;
+	}
+	const isArray = Array.isArray(code);
+	for (const name of Object.keys(code)) {
+		/** @type {Set<string>} */
+		const childKeys = new Set(
+			isArray ? keys : [name, name.slice(name.lastIndexOf(".") + 1)]
+		);
+		for (const key of keys) childKeys.add(`${key}.${name}`);
+		collectAsyncRuntimeValues(code[name], childKeys, root, into);
+	}
+};
+
+/**
+ * The asynchronous runtime values of every definition, collected once per
+ * compilation.
+ * @param {Compilation} compilation the compilation
+ * @returns {AsyncRuntimeDefinitions} the definitions
+ */
+const getAsyncRuntimeValues = (compilation) => {
+	const cached = ASYNC_RUNTIME_VALUES.get(compilation);
+	if (cached) return cached;
+
+	/** @type {AsyncRuntimeDefinitions} */
+	const collected = {
+		values: new Map(),
+		references: new Map(),
+		dynamicRoots: new Set()
+	};
+	const { definitions } = getMergedDefinitions(compilation);
+
+	for (const key of Object.keys(definitions)) {
+		const name = key.replace(TYPEOF_OPERATOR_REGEXP, "");
+		const dot = name.indexOf(".");
+		const keys = new Set([key]);
+		if (name === key && dot !== -1) {
+			keys.add(key.slice(key.lastIndexOf(".") + 1));
+		}
+		collectAsyncRuntimeValues(
+			definitions[key],
+			keys,
+			dot === -1 ? name : name.slice(0, dot),
+			collected
+		);
+	}
+
+	ASYNC_RUNTIME_VALUES.set(compilation, collected);
+	return collected;
+};
+
+/**
+ * Whether source or replacement code may reference a definition root.
+ * @param {string[]} sources module source and reachable replacement code
+ * @param {Iterable<string>} roots first segments of definition keys
+ * @returns {boolean} false only when the module cannot reference the value
+ */
+const mayReference = (sources, roots) => {
+	for (const root of roots) {
+		for (const source of sources) {
+			if (source.includes(root)) return true;
+		}
+	}
+	return false;
+};
+
+/**
+ * Resolves the asynchronous runtime values a module may reference, while the
+ * module is still building and a promise can still be awaited.
+ * @param {Compilation} compilation the compilation
+ * @param {NormalModule} module the module about to be parsed
+ * @param {boolean} resolveAll whether a custom AST can introduce additional references
+ * @returns {Promise<void>} resolves once every value the module may use is known
+ */
+const resolveAsyncRuntimeValues = async (compilation, module, resolveAll) => {
+	const definitions = getAsyncRuntimeValues(compilation);
+	const remaining = new Set(definitions.values.values());
+	const references = new Map(definitions.references);
+	/** @type {ResolvedRuntimeValues} */
+	const resolved = new Map();
+	const { valueCacheVersions } = compilation;
+	const source = /** @type {Source} */ (module.originalSource()).source();
+	const sources = [decodeIdentifierEscapes(source.toString())];
+
+	while (remaining.size > 0) {
+		let addedReferences;
+		do {
+			addedReferences = false;
+			for (const [root, code] of references) {
+				if (!mayReference(sources, [root])) continue;
+				references.delete(root);
+				sources.push(...code);
+				addedReferences = true;
+			}
+		} while (addedReferences);
+		// A synchronous generator may return arbitrary code. Keep its invocation
+		// at parse time, but prepare any async values that code might reference.
+		resolveAll = resolveAll || mayReference(sources, definitions.dynamicRoots);
+		/** @type {Promise<void>[]} */
+		const pending = [];
+		for (const entry of remaining) {
+			const { value, keys, roots } = entry;
+			if (!resolveAll && !mayReference(sources, roots)) continue;
+			remaining.delete(entry);
+			/** @type {Map<string, ResolvedRuntimeValue>} */
+			const byKey = new Map();
+			resolved.set(value, byKey);
+			for (const key of keys) {
+				pending.push(
+					Promise.resolve()
+						.then(() => value.call(module, valueCacheVersions, key))
+						.then(
+							(code) => {
+								byKey.set(key, { value: code });
+								sources.push(decodeIdentifierEscapes(String(code)));
+							},
+							(error) => {
+								// Text matching can include unused members or shadowed names,
+								// so keep the rejection as it is and annotate it in
+								// `getResolvedValue`, only for the module that consumes it
+								byKey.set(key, { error });
+							}
+						)
+				);
+			}
+		}
+		if (pending.length === 0) break;
+		await Promise.all(pending);
+	}
+
+	// last, so that a rebuild never reads what the previous build resolved
+	RESOLVED_RUNTIME_VALUES.set(module, resolved);
+};
+
+/**
+ * What an asynchronous generator produced for this module, resolved before the
+ * module was parsed.
+ * @param {NormalModule} module the module being parsed
+ * @param {RuntimeValue} runtimeValue the runtime value
+ * @param {string} key the defined key
+ * @returns {CodeValuePrimitive} the value
+ */
+const getResolvedValue = (module, runtimeValue, key) => {
+	const resolved = RESOLVED_RUNTIME_VALUES.get(module);
+	const byKey = resolved && resolved.get(runtimeValue);
+	const result = byKey && byKey.get(key);
+	if (result === undefined) {
+		throw new WebpackError(
+			`DefinePlugin: the asynchronous runtime value for "${key}" was not resolved before the module was parsed.`
+		);
+	}
+	if ("error" in result) {
+		throw annotateEvaluationError(key, runtimeValue, result.error);
+	}
+	return result.value;
+};
+
 /**
  * @typedef {ReturnType<typeof createCompilationHooks>} DefinePluginHooks
  */
@@ -704,7 +1022,8 @@ class DefinePlugin {
 	}
 
 	/**
-	 * Returns runtime value.
+	 * Creates a runtime value. Async generators resolve once per module and key
+	 * before parsing; promise-returning functions require the `async` option.
 	 * @param {GeneratorFn} fn generator function
 	 * @param {true | string[] | RuntimeValueOptions=} options options
 	 * @returns {RuntimeValue} runtime value
@@ -768,6 +1087,52 @@ class DefinePlugin {
 					// built lazily here: every definitions hook is tapped by the time
 					// parsers are created, and the result is cached per compilation
 					const mergedDefinitions = getMergedDefinitions(compilation);
+					// a parser is created before the module it parses is built, so this
+					// is in place before the first value has to be resolved
+					if (mergedDefinitions.hasAsyncRuntimeValue) {
+						ASYNC_PARSERS.add(parser);
+						if (!ASYNC_RESOLUTION_TAPPED.has(compilation)) {
+							ASYNC_RESOLUTION_TAPPED.add(compilation);
+							NormalModule.getCompilationHooks(
+								compilation
+							).beforeParse.tapPromise(
+								{ name: PLUGIN_NAME, stage: Infinity },
+								async (module) => {
+									const moduleParser = /** @type {JavascriptParser} */ (
+										module.parser
+									);
+									if (
+										!ASYNC_PARSERS.has(moduleParser) ||
+										module.shouldPreventParsing(
+											compilation.options.module.noParse,
+											module.request
+										)
+									) {
+										return;
+									}
+									// A loader-provided AST or a custom parse function means the
+									// module is parsed from something other than its source text,
+									// so scanning that text cannot find every reference.
+									const hasPreparsedAst =
+										/** @type {{ _ast: PreparsedAst | null }} */ (
+											/** @type {unknown} */ (module)
+										)._ast !== null;
+									await resolveAsyncRuntimeValues(
+										compilation,
+										module,
+										hasPreparsedAst ||
+											typeof moduleParser.options.parse === "function"
+									);
+								}
+							);
+							compilation.hooks.succeedModule.tap(PLUGIN_NAME, (module) => {
+								RESOLVED_RUNTIME_VALUES.delete(module);
+							});
+							compilation.hooks.failedModule.tap(PLUGIN_NAME, (module) => {
+								RESOLVED_RUNTIME_VALUES.delete(module);
+							});
+						}
+					}
 					/** @type {Set<string>} */
 					const hooked = new Set();
 					const mainValue =
@@ -852,9 +1217,7 @@ class DefinePlugin {
 							if (fullKey === "import" || fullKey === "import.meta") continue;
 							parser.hooks.canRename.for(fullKey).tap(PLUGIN_NAME, () => {
 								addValueDependency(key);
-								if (
-									parser.scope.definitions.get(firstKey) instanceof VariableInfo
-								) {
+								if (isVariableInfo(parser.scope.definitions.get(firstKey))) {
 									return false;
 								}
 								return true;
@@ -898,7 +1261,10 @@ class DefinePlugin {
 												if (
 													!finalSet ||
 													!finalSet.has(id) ||
-													!mergedDefinitions.definitions[fullKey]
+													!Object.prototype.hasOwnProperty.call(
+														mergedDefinitions.definitions,
+														fullKey
+													)
 												) {
 													return;
 												}

package/lib/{DotenvPlugin.js → define/DotenvPlugin.js}

@@ -42,15 +42,15 @@
 
 "use strict";
 
-const FileSystemInfo = require("./FileSystemInfo");
-const DotenvFileError = require("./errors/DotenvFileError");
-const { join } = require("./util/fs");
+const DotenvFileError = require("../errors/DotenvFileError");
+const FileSystemInfo = require("../fs/FileSystemInfo");
+const { join } = require("../fs/fs");
 
-/** @import { DotenvPluginOptions } from "../declarations/WebpackOptions" */
-/** @import Compiler from "./Compiler" */
-/** @import { ItemCacheFacade } from "./CacheFacade" */
-/** @import { InputFileSystem } from "./util/fs" */
-/** @import { Snapshot } from "./FileSystemInfo" */
+/** @import { DotenvPluginOptions } from "../../declarations/WebpackOptions" */
+/** @import Compiler from "../Compiler" */
+/** @import { ItemCacheFacade } from "../cache/CacheFacade" */
+/** @import { InputFileSystem } from "../fs/fs" */
+/** @import { Snapshot } from "../fs/FileSystemInfo" */
 
 /** @typedef {Exclude<DotenvPluginOptions["prefix"], string | undefined>} Prefix */
 /** @typedef {Record<string, string>} Env */
@@ -270,7 +270,7 @@ class DotenvPlugin {
 		compiler.hooks.validate.tap(PLUGIN_NAME, () => {
 			compiler.validate(
 				() => {
-					const { definitions } = require("../schemas/WebpackOptions.json");
+					const { definitions } = require("../../schemas/WebpackOptions.json");
 
 					return {
 						definitions,

package/lib/{EnvironmentPlugin.js → define/EnvironmentPlugin.js}

@@ -5,10 +5,10 @@
 
 "use strict";
 
+const WebpackError = require("../errors/WebpackError");
 const DefinePlugin = require("./DefinePlugin");
-const WebpackError = require("./errors/WebpackError");
 
-/** @import Compiler from "./Compiler" */
+/** @import Compiler from "../Compiler" */
 /** @import { CodeValue } from "./DefinePlugin" */
 
 const PLUGIN_NAME = "EnvironmentPlugin";

package/lib/deno/DenoTargetPlugin.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const ExternalsPlugin = require("../ExternalsPlugin");
+const ExternalsPlugin = require("../externals/ExternalsPlugin");
 const { coreModules } = require("../node/nodeBuiltins");
 
 /** @import Compiler from "../Compiler" */