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

package/lib/dependencies/ImportMetaPlugin.js

@@ -7,7 +7,7 @@
 
 const { pathToFileURL } = require("url");
 const { SyncBailHook } = require("tapable");
-/** @typedef {import("../Compilation")} Compilation */
+/** @import Compilation from "../Compilation" */
 const DefinePlugin = require("../DefinePlugin");
 const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
@@ -25,6 +25,7 @@ const {
 const { getInnerGraphUtils } = require("../optimize/InnerGraph");
 const createHooksRegistry = require("../util/createHooksRegistry");
 const { propertyAccess } = require("../util/property");
+const BuildTimeConstDependency = require("./BuildTimeConstDependency");
 const ConstDependency = require("./ConstDependency");
 const ImportMetaResolveDependency = require("./ImportMetaResolveDependency");
 const ModuleInitFragmentDependency = require("./ModuleInitFragmentDependency");
@@ -36,23 +37,37 @@ const WEBPACK_VERSION = Number.parseInt(
 	10
 );
 
-/** @typedef {import("estree").MemberExpression} MemberExpression */
-/** @typedef {import("estree").Identifier} Identifier */
-/** @typedef {import("estree").CallExpression} CallExpression */
-/** @typedef {import("estree").Expression} Expression */
-/** @typedef {import("estree").Super} Super */
-/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../DefinePlugin").MergedDefinitionNode} MergedDefinitionNode */
-/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("../Module").ValueCacheVersion} ValueCacheVersion */
-/** @typedef {import("../NormalModule").NormalModuleBuildInfo} NormalModuleBuildInfo */
-/** @typedef {import("../NormalModule")} NormalModule */
-/** @typedef {import("../javascript/JavascriptParser")} Parser */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../javascript/JavascriptParser").Members} Members */
-/** @typedef {import("../javascript/JavascriptParser").DestructuringAssignmentProperty} DestructuringAssignmentProperty */
-/** @typedef {import("./ConstDependency").RawRuntimeRequirements} RawRuntimeRequirements */
+/**
+ * @import {
+ * 	MemberExpression,
+ * 	Identifier,
+ * 	CallExpression,
+ * 	Expression,
+ * 	Super
+ * } from "estree"
+ */
+/**
+ * @import {
+ * 	JavascriptParserOptions
+ * } from "../../declarations/WebpackOptions"
+ */
+/** @import Compiler from "../Compiler" */
+/** @import { MergedDefinitionNode } from "../DefinePlugin" */
+/** @import { ValueCacheVersion } from "../Module" */
+/** @import NormalModule, { NormalModuleBuildInfo } from "../NormalModule" */
+/**
+ * @import {
+ * 	JavascriptModuleBuildInfo
+ * } from "../javascript/JavascriptModule"
+ */
+/**
+ * @import Parser, {
+ * 	Range,
+ * 	Members,
+ * 	DestructuringAssignmentProperty
+ * } from "../javascript/JavascriptParser"
+ */
+/** @import { RawRuntimeRequirements } from "./NullDependency" */
 
 const PLUGIN_NAME = "ImportMetaPlugin";
 
@@ -138,6 +153,18 @@ const isImportMetaFieldEnabled = (importMeta, field) => {
 	);
 };
 
+/**
+ * Renders the `import.meta.main` comparison and bails out of scope hoisting.
+ * @param {Parser} parser the parser
+ * @returns {string} the comparison expression
+ */
+const renderImportMetaMain = (parser) => {
+	const currentModule = parser.state.module;
+	/** @type {JavascriptModuleBuildInfo} */
+	(currentModule.buildInfo).moduleConcatenationBailout = IMPORT_META_MAIN;
+	return `${RuntimeGlobals.moduleCache}[${RuntimeGlobals.entryModuleId}] === ${currentModule.moduleArgument}`;
+};
+
 /**
  * Checks whether the callee is the `import.meta.resolve` member.
  * @param {Expression | Super} callee call callee
@@ -230,6 +257,10 @@ class ImportMetaPlugin {
 					ImportMetaResolveDependency,
 					new ImportMetaResolveDependency.Template()
 				);
+				compilation.dependencyTemplates.set(
+					BuildTimeConstDependency,
+					new BuildTimeConstDependency.Template()
+				);
 
 				/**
 				 * Returns file url.
@@ -371,6 +402,15 @@ class ImportMetaPlugin {
 						`[${JSON.stringify(field)}]: ${importMetaUnknownProperty([
 							field
 						])},`;
+					/**
+					 * Import meta runtime property for build-time execution.
+					 * @param {string} field field name
+					 * @returns {string} generated property
+					 */
+					const importMetaBuildTimeProperty = (field) =>
+						`[${JSON.stringify(field)}]: ${Template.toNormalComment(
+							`unsupported import.meta.${field}`
+						)} undefined,`;
 
 					parser.hooks.typeof
 						.for(IMPORT_META)
@@ -398,7 +438,6 @@ class ImportMetaPlugin {
 						.tap(PLUGIN_NAME, (metaProperty) => {
 							/** @type {RawRuntimeRequirements} */
 							const runtimeRequirements = [];
-							const moduleArgument = parser.state.module.moduleArgument;
 
 							const referencedPropertiesInDestructuring =
 								parser.destructuringAssignmentPropertiesFor(metaProperty);
@@ -412,9 +451,7 @@ class ImportMetaPlugin {
 									knownProps.push(`webpack: ${importMetaWebpackVersion()}`);
 								}
 								if (isImportMetaFieldEnabled(importMeta, "main")) {
-									knownProps.push(
-										`main: ${RuntimeGlobals.moduleCache}[${RuntimeGlobals.entryModuleId}] === ${moduleArgument}`
-									);
+									knownProps.push(`main: ${renderImportMetaMain(parser)}`);
 								}
 								if (isImportMetaFieldEnabled(importMeta, "env")) {
 									addDefinitionValueDependencies();
@@ -431,11 +468,14 @@ class ImportMetaPlugin {
 										)}`
 									);
 								}
+								const plainInitCode = `var ${varName} = {${knownProps.join(
+									", "
+								)}};\n`;
 								const initCode = preserveUnknown(importMeta)
 									? `var ${varName} = Object.assign(import.meta, {${knownProps.join(
 											", "
 										)}});\n`
-									: `var ${varName} = {${knownProps.join(", ")}};\n`;
+									: plainInitCode;
 								/** @type {RawRuntimeRequirements} */
 								const initRuntimeRequirements = [
 									RuntimeGlobals.moduleCache,
@@ -450,7 +490,9 @@ class ImportMetaPlugin {
 								const initDep = new ModuleInitFragmentDependency(
 									initCode,
 									initRuntimeRequirements,
-									varName
+									varName,
+									// native `import.meta` does not parse in the build-time vm
+									initCode === plainInitCode ? undefined : plainInitCode
 								);
 								initDep.loc = parser.getLocation(metaProperty);
 								parser.state.module.addPresentationalDependency(initDep);
@@ -465,6 +507,24 @@ class ImportMetaPlugin {
 							}
 
 							let str = "";
+							let strBuildTime = "";
+							/**
+							 * Appends a property shared by both variants.
+							 * @param {string} code generated property
+							 */
+							const append = (code) => {
+								str += code;
+								strBuildTime += code;
+							};
+							/**
+							 * Appends a property reading native `import.meta`, which
+							 * does not parse in the build-time vm.
+							 * @param {string} field field name
+							 */
+							const appendRuntimeProperty = (field) => {
+								str += importMetaRuntimeProperty(field);
+								strBuildTime += importMetaBuildTimeProperty(field);
+							};
 							for (const prop of referencedPropertiesInDestructuring) {
 								const fieldEnabled = isImportMetaFieldEnabled(
 									importMeta,
@@ -475,51 +535,59 @@ class ImportMetaPlugin {
 									: undefined;
 
 								if (value) {
-									str += value;
+									append(value);
 									continue;
 								}
 
 								switch (prop.id) {
 									case "url":
-										str += fieldEnabled
-											? `url: ${importMetaUrl()},`
-											: importMetaRuntimeProperty(prop.id);
+										if (fieldEnabled) {
+											append(`url: ${importMetaUrl()},`);
+										} else {
+											appendRuntimeProperty(prop.id);
+										}
 										break;
 									case "webpack":
-										str += fieldEnabled
-											? `webpack: ${importMetaWebpackVersion()},`
-											: importMetaRuntimeProperty(prop.id);
+										if (fieldEnabled) {
+											append(`webpack: ${importMetaWebpackVersion()},`);
+										} else {
+											appendRuntimeProperty(prop.id);
+										}
 										break;
 									case "main":
 										if (fieldEnabled) {
-											str += `main: ${RuntimeGlobals.moduleCache}[${RuntimeGlobals.entryModuleId}] === ${moduleArgument},`;
+											append(`main: ${renderImportMetaMain(parser)},`);
 											runtimeRequirements.push(
 												RuntimeGlobals.moduleCache,
 												RuntimeGlobals.entryModuleId,
 												RuntimeGlobals.module
 											);
 										} else {
-											str += importMetaRuntimeProperty(prop.id);
+											appendRuntimeProperty(prop.id);
 										}
 										break;
 									case "env":
 										if (fieldEnabled) {
 											addDefinitionValueDependencies();
-											str += `env: ${renderDefinition(envNode, IMPORT_META_ENV)},`;
+											append(
+												`env: ${renderDefinition(envNode, IMPORT_META_ENV)},`
+											);
 										} else {
-											str += importMetaRuntimeProperty(prop.id);
+											appendRuntimeProperty(prop.id);
 										}
 										break;
 									default: {
 										const node = customProps.get(prop.id);
 										if (node !== undefined) {
 											addDefinitionValueDependencies();
-											str += `${DefinePlugin.toPropertyKey(prop.id)}: ${renderDefinition(
-												node,
-												`${IMPORT_META}.${prop.id}`
-											)},`;
+											append(
+												`${DefinePlugin.toPropertyKey(prop.id)}: ${renderDefinition(
+													node,
+													`${IMPORT_META}.${prop.id}`
+												)},`
+											);
 										} else {
-											str += importMetaRuntimeProperty(prop.id);
+											appendRuntimeProperty(prop.id);
 										}
 										break;
 									}
@@ -531,11 +599,19 @@ class ImportMetaPlugin {
 							if (codeRequirements) {
 								runtimeRequirements.push(...codeRequirements);
 							}
-							const dep = new ConstDependency(
-								strCode,
-								/** @type {Range} */ (metaProperty.range),
-								runtimeRequirements
-							);
+							const dep =
+								strBuildTime === str
+									? new ConstDependency(
+											strCode,
+											/** @type {Range} */ (metaProperty.range),
+											runtimeRequirements
+										)
+									: new BuildTimeConstDependency(
+											strCode,
+											`({${strBuildTime}})`,
+											/** @type {Range} */ (metaProperty.range),
+											runtimeRequirements
+										);
 							dep.loc = parser.getLocation(metaProperty);
 							parser.state.module.addPresentationalDependency(dep);
 							return true;
@@ -664,17 +740,12 @@ class ImportMetaPlugin {
 					if (isImportMetaFieldEnabled(importMeta, "main")) {
 						parser.hooks.expression
 							.for(IMPORT_META_MAIN)
-							.tap(
-								PLUGIN_NAME,
-								toConstantDependency(
-									parser,
-									`${RuntimeGlobals.moduleCache}[${RuntimeGlobals.entryModuleId}] === ${RuntimeGlobals.module}`,
-									[
-										RuntimeGlobals.moduleCache,
-										RuntimeGlobals.entryModuleId,
-										RuntimeGlobals.module
-									]
-								)
+							.tap(PLUGIN_NAME, (expr) =>
+								toConstantDependency(parser, renderImportMetaMain(parser), [
+									RuntimeGlobals.moduleCache,
+									RuntimeGlobals.entryModuleId,
+									RuntimeGlobals.module
+								])(expr)
 							);
 						parser.hooks.typeof
 							.for(IMPORT_META_MAIN)
@@ -752,15 +823,6 @@ class ImportMetaPlugin {
 					parser.hooks.unhandledExpressionMemberChain
 						.for(IMPORT_META)
 						.tap(PLUGIN_NAME, (expr, members) => {
-							// unknown import.meta properties should be determined at runtime
-							if (
-								preserveUnknown(importMeta) ||
-								(IMPORT_META_FIELDS.has(members[0]) &&
-									!isImportMetaFieldEnabled(importMeta, members[0]))
-							) {
-								return true;
-							}
-
 							// keep import.meta.env unknown property
 							// don't evaluate import.meta.env.UNKNOWN_PROPERTY -> undefined.UNKNOWN_PROPERTY
 							// `dirname` and `filename` logic in NodeStuffPlugin
@@ -771,6 +833,26 @@ class ImportMetaPlugin {
 							) {
 								return true;
 							}
+
+							// unknown import.meta properties should be determined at runtime
+							if (
+								preserveUnknown(importMeta) ||
+								(IMPORT_META_FIELDS.has(members[0]) &&
+									!isImportMetaFieldEnabled(importMeta, members[0]))
+							) {
+								// keep the native access verbatim for emitted output, but
+								// native `import.meta` does not parse in the build-time vm
+								const dep = new BuildTimeConstDependency(
+									`${IMPORT_META}${propertyAccess(members, 0)}`,
+									`${Template.toNormalComment(
+										`unsupported import.meta.${members.join(".")}`
+									)} undefined${propertyAccess(members, 1)}`,
+									/** @type {Range} */ (expr.range)
+								);
+								dep.loc = parser.getLocation(expr);
+								parser.state.module.addPresentationalDependency(dep);
+								return true;
+							}
 							const dep = new ConstDependency(
 								importMetaUnknownProperty(members),
 								/** @type {Range} */ (expr.range)
@@ -834,10 +916,11 @@ ImportMetaPlugin.getCompilationHooks = createHooksRegistry(
 		})
 );
 
-module.exports = ImportMetaPlugin;
-module.exports.IMPORT_META_DIRNAME = IMPORT_META_DIRNAME;
-module.exports.IMPORT_META_FILENAME = IMPORT_META_FILENAME;
-module.exports.IMPORT_META_NAMES = IMPORT_META_NAMES;
-module.exports.IMPORT_META_STAGE_ESM_DETECTION =
+ImportMetaPlugin.IMPORT_META_DIRNAME = IMPORT_META_DIRNAME;
+ImportMetaPlugin.IMPORT_META_FILENAME = IMPORT_META_FILENAME;
+ImportMetaPlugin.IMPORT_META_NAMES = IMPORT_META_NAMES;
+ImportMetaPlugin.IMPORT_META_STAGE_ESM_DETECTION =
 	IMPORT_META_STAGE_ESM_DETECTION;
-module.exports.isImportMetaFieldEnabled = isImportMetaFieldEnabled;
+ImportMetaPlugin.isImportMetaFieldEnabled = isImportMetaFieldEnabled;
+
+module.exports = ImportMetaPlugin;

package/lib/dependencies/ImportMetaResolveDependency.js

@@ -10,10 +10,9 @@ const makeSerializable = require("../util/makeSerializable");
 const ModuleDependency = require("./ModuleDependency");
 const URLDependency = require("./URLDependency");
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @import { ReplaceSource } from "webpack-sources" */
+/** @import Dependency from "../Dependency" */
+/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
 
 // `import.meta.resolve(specifier)` is the string form of
 // `new URL(specifier, import.meta.url)`, so it reuses the URL asset pipeline

package/lib/dependencies/ImportParserPlugin.js

@@ -6,8 +6,7 @@
 "use strict";
 
 const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
-const CommentCompilationWarning = require("../errors/CommentCompilationWarning");
-const UnsupportedFeatureWarning = require("../errors/UnsupportedFeatureWarning");
+
 const {
 	VariableInfo,
 	getImportAttributes
@@ -16,35 +15,50 @@ const memoize = require("../util/memoize");
 const traverseDestructuringAssignmentProperties = require("../util/traverseDestructuringAssignmentProperties");
 const ContextDependencyHelpers = require("./ContextDependencyHelpers");
 const { getNonOptionalPart } = require("./HarmonyImportDependency");
+const HarmonyImportGuard = require("./HarmonyImportGuard");
 const ImportContextDependency = require("./ImportContextDependency");
 const ImportDependency = require("./ImportDependency");
 const ImportEagerDependency = require("./ImportEagerDependency");
 const { createGetImportPhase } = require("./ImportPhase");
 const ImportWeakDependency = require("./ImportWeakDependency");
 
-/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
-/** @typedef {import("../ChunkGroup").RawChunkGroupOptions} RawChunkGroupOptions */
-/** @typedef {import("../ContextModule").ContextMode} ContextMode */
-/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("../Dependency").RawReferencedExports} RawReferencedExports */
-/** @typedef {import("../Module").BuildMeta} BuildMeta */
-/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
-/** @typedef {import("../javascript/JavascriptParser").ImportExpression} ImportExpression */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../javascript/JavascriptParser").JavascriptParserState} JavascriptParserState */
-/** @typedef {import("../javascript/JavascriptParser").Members} Members */
-/** @typedef {import("../javascript/JavascriptParser").MembersOptionals} MembersOptionals */
-/** @typedef {import("../javascript/JavascriptParser").ArrowFunctionExpression} ArrowFunctionExpression */
-/** @typedef {import("../javascript/JavascriptParser").FunctionExpression} FunctionExpression */
-/** @typedef {import("../javascript/JavascriptParser").Identifier} Identifier */
-/** @typedef {import("../javascript/JavascriptParser").ObjectPattern} ObjectPattern */
-/** @typedef {import("../javascript/JavascriptParser").CallExpression} CallExpression */
+const getUnsupportedFeatureWarning = memoize(() =>
+	require("../errors/UnsupportedFeatureWarning")
+);
+
+const getCommentCompilationWarning = memoize(() =>
+	require("../errors/CommentCompilationWarning")
+);
+
+/**
+ * @import {
+ * 	ArrowFunctionExpression,
+ * 	FunctionExpression,
+ * 	Identifier,
+ * 	ObjectPattern,
+ * 	CallExpression
+ * } from "estree"
+ */
+/**
+ * @import {
+ * 	JavascriptParserOptions
+ * } from "../../declarations/WebpackOptions"
+ */
+/** @import { RawChunkGroupOptions } from "../ChunkGroup" */
+/** @import { ContextMode } from "../ContextModule" */
+/** @import { RawReferencedExports } from "../Dependency" */
+/** @import { BuildMeta } from "../Module" */
+/**
+ * @import JavascriptParser, {
+ * 	ImportExpression,
+ * 	Range,
+ * 	JavascriptParserState
+ * } from "../javascript/JavascriptParser"
+ */
 
 /** @typedef {{ references: RawReferencedExports, expression: ImportExpression }} ImportSettings */
 /** @typedef {WeakMap<ImportExpression, RawReferencedExports>} State */
 
-const getHarmonyImportGuard = memoize(() => require("./HarmonyImportGuard"));
-
 /** @type {WeakMap<JavascriptParserState, State>} */
 const parserStateMap = new WeakMap();
 const dynamicImportTag = Symbol("import()");
@@ -357,7 +371,7 @@ class ImportParserPlugin {
 				for (const e of commentErrors) {
 					const { comment } = e;
 					parser.state.module.addWarning(
-						new CommentCompilationWarning(
+						new (getCommentCompilationWarning())(
 							`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
 							parser.getLocation(comment)
 						)
@@ -374,7 +388,7 @@ class ImportParserPlugin {
 				if (importOptions.webpackIgnore !== undefined) {
 					if (typeof importOptions.webpackIgnore !== "boolean") {
 						parser.state.module.addWarning(
-							new UnsupportedFeatureWarning(
+							new (getUnsupportedFeatureWarning())(
 								`\`webpackIgnore\` expected a boolean, but received: ${importOptions.webpackIgnore}.`,
 								parser.getLocation(expr)
 							)
@@ -387,7 +401,7 @@ class ImportParserPlugin {
 				if (importOptions.webpackChunkName !== undefined) {
 					if (typeof importOptions.webpackChunkName !== "string") {
 						parser.state.module.addWarning(
-							new UnsupportedFeatureWarning(
+							new (getUnsupportedFeatureWarning())(
 								`\`webpackChunkName\` expected a string, but received: ${importOptions.webpackChunkName}.`,
 								parser.getLocation(expr)
 							)
@@ -399,7 +413,7 @@ class ImportParserPlugin {
 				if (importOptions.webpackMode !== undefined) {
 					if (typeof importOptions.webpackMode !== "string") {
 						parser.state.module.addWarning(
-							new UnsupportedFeatureWarning(
+							new (getUnsupportedFeatureWarning())(
 								`\`webpackMode\` expected a string, but received: ${importOptions.webpackMode}.`,
 								parser.getLocation(expr)
 							)
@@ -415,7 +429,7 @@ class ImportParserPlugin {
 						groupOptions.prefetchOrder = importOptions.webpackPrefetch;
 					} else {
 						parser.state.module.addWarning(
-							new UnsupportedFeatureWarning(
+							new (getUnsupportedFeatureWarning())(
 								`\`webpackPrefetch\` expected true or a number, but received: ${importOptions.webpackPrefetch}.`,
 								parser.getLocation(expr)
 							)
@@ -429,7 +443,7 @@ class ImportParserPlugin {
 						groupOptions.preloadOrder = importOptions.webpackPreload;
 					} else {
 						parser.state.module.addWarning(
-							new UnsupportedFeatureWarning(
+							new (getUnsupportedFeatureWarning())(
 								`\`webpackPreload\` expected true or a number, but received: ${importOptions.webpackPreload}.`,
 								parser.getLocation(expr)
 							)
@@ -446,7 +460,7 @@ class ImportParserPlugin {
 							(importOptions.webpackFetchPriority);
 					} else {
 						parser.state.module.addWarning(
-							new UnsupportedFeatureWarning(
+							new (getUnsupportedFeatureWarning())(
 								`\`webpackFetchPriority\` expected true or "low", "high" or "auto", but received: ${importOptions.webpackFetchPriority}.`,
 								parser.getLocation(expr)
 							)
@@ -459,7 +473,7 @@ class ImportParserPlugin {
 						!(importOptions.webpackInclude instanceof RegExp)
 					) {
 						parser.state.module.addWarning(
-							new UnsupportedFeatureWarning(
+							new (getUnsupportedFeatureWarning())(
 								`\`webpackInclude\` expected a regular expression, but received: ${importOptions.webpackInclude}.`,
 								parser.getLocation(expr)
 							)
@@ -474,7 +488,7 @@ class ImportParserPlugin {
 						!(importOptions.webpackExclude instanceof RegExp)
 					) {
 						parser.state.module.addWarning(
-							new UnsupportedFeatureWarning(
+							new (getUnsupportedFeatureWarning())(
 								`\`webpackExclude\` expected a regular expression, but received: ${importOptions.webpackExclude}.`,
 								parser.getLocation(expr)
 							)
@@ -492,7 +506,7 @@ class ImportParserPlugin {
 							))
 					)) {
 						parser.state.module.addWarning(
-							new UnsupportedFeatureWarning(
+							new (getUnsupportedFeatureWarning())(
 								`\`webpackExports\` expected a string or an array of strings, but received: ${importOptions.webpackExports}.`,
 								parser.getLocation(expr)
 							)
@@ -511,7 +525,7 @@ class ImportParserPlugin {
 					importOptions.webpackEntryOptions.worker !== undefined
 				) {
 					parser.state.module.addWarning(
-						new UnsupportedFeatureWarning(
+						new (getUnsupportedFeatureWarning())(
 							"`worker` entry option is not supported in `import()`, it only applies to workers (e.g. `new Worker(new URL(...))`).",
 							parser.getLocation(expr)
 						)
@@ -526,7 +540,7 @@ class ImportParserPlugin {
 				mode !== "weak"
 			) {
 				parser.state.module.addWarning(
-					new UnsupportedFeatureWarning(
+					new (getUnsupportedFeatureWarning())(
 						`\`webpackMode\` expected 'lazy', 'lazy-once', 'eager' or 'weak', but received: ${mode}.`,
 						parser.getLocation(expr)
 					)
@@ -547,7 +561,7 @@ class ImportParserPlugin {
 			) {
 				if (exports) {
 					parser.state.module.addWarning(
-						new UnsupportedFeatureWarning(
+						new (getUnsupportedFeatureWarning())(
 							"You don't need `webpackExports` if the usage of dynamic import is statically analyse-able. You can safely remove the `webpackExports` magic comment.",
 							parser.getLocation(expr)
 						)
@@ -629,7 +643,7 @@ class ImportParserPlugin {
 					dep.optional = Boolean(parser.scope.inTry);
 					depBlock.addDependency(dep);
 					parser.state.current.addBlock(depBlock);
-					getHarmonyImportGuard().attachDependencyGuards(parser, dep);
+					HarmonyImportGuard.attachDependencyGuards(parser, dep);
 				}
 			} else {
 				if (mode === "weak") {

package/lib/dependencies/ImportPhase.js

@@ -11,11 +11,18 @@ const getCommentCompilationWarning = memoize(() =>
 	require("../errors/CommentCompilationWarning")
 );
 
-/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
-/** @typedef {import("../javascript/JavascriptParser").ExportAllDeclaration} ExportAllDeclaration */
-/** @typedef {import("../javascript/JavascriptParser").ExportNamedDeclaration} ExportNamedDeclaration */
-/** @typedef {import("../javascript/JavascriptParser").ImportDeclaration} ImportDeclaration */
-/** @typedef {import("../javascript/JavascriptParser").ImportExpression} ImportExpression */
+/**
+ * @import {
+ * 	ExportAllDeclaration,
+ * 	ExportNamedDeclaration,
+ * 	ImportDeclaration
+ * } from "estree"
+ */
+/**
+ * @import JavascriptParser, {
+ * 	ImportExpression
+ * } from "../javascript/JavascriptParser"
+ */
 
 /** @typedef {typeof ImportPhase.Evaluation | typeof ImportPhase.Defer | typeof ImportPhase.Source}  ImportPhaseType */
 

package/lib/dependencies/ImportPlugin.js

@@ -16,9 +16,13 @@ const ImportEagerDependency = require("./ImportEagerDependency");
 const ImportParserPlugin = require("./ImportParserPlugin");
 const ImportWeakDependency = require("./ImportWeakDependency");
 
-/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../javascript/JavascriptParser")} Parser */
+/**
+ * @import {
+ * 	JavascriptParserOptions
+ * } from "../../declarations/WebpackOptions"
+ */
+/** @import Compiler from "../Compiler" */
+/** @import Parser from "../javascript/JavascriptParser" */
 
 const PLUGIN_NAME = "ImportPlugin";
 

package/lib/dependencies/ImportWeakDependency.js

@@ -8,15 +8,12 @@
 const makeSerializable = require("../util/makeSerializable");
 const ImportDependency = require("./ImportDependency");
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../Module").BuildMeta} BuildMeta */
-/** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {ImportDependency.RawReferencedExports} RawReferencedExports */
-/** @typedef {import("./ImportPhase").ImportPhaseType} ImportPhaseType */
+/** @import { ReplaceSource } from "webpack-sources" */
+/** @import Dependency, { RawReferencedExports } from "../Dependency" */
+/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
+/** @import Module, { BuildMeta } from "../Module" */
+/** @import { ImportAttributes, Range } from "../javascript/JavascriptParser" */
+/** @import { ImportPhaseType } from "./ImportPhase" */
 
 class ImportWeakDependency extends ImportDependency {
 	/**