webpack 5.107.2 → 5.108.0

package/lib/dependencies/HtmlInlineScriptDependency.js

@@ -14,8 +14,8 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../Entrypoint")} Entrypoint */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[number, Range, string, string]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[number, Range, string, string]>} ObjectSerializerContext */
 
 /**
  * Represents an inline `<script>...</script>` block in an HTML module. The
@@ -34,9 +34,11 @@ class HtmlInlineScriptDependency extends ModuleDependency {
 	 */
 	constructor(request, insertPos, contentRange, entryName, category) {
 		super(request);
+		/** @type {number} */
 		this.insertPos = insertPos;
 		this.contentRange = contentRange;
 		this.range = contentRange;
+		/** @type {string} */
 		this.entryName = entryName;
 		/** @type {string} */
 		this._category = category || "commonjs";
@@ -55,11 +57,11 @@ class HtmlInlineScriptDependency extends ModuleDependency {
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
-		const { write } = context;
-		write(this.insertPos);
-		write(this.contentRange);
-		write(this.entryName);
-		write(this._category);
+		context
+			.write(this.insertPos)
+			.write(this.contentRange)
+			.write(this.entryName)
+			.write(this._category);
 		super.serialize(context);
 	}
 
@@ -68,13 +70,15 @@ class HtmlInlineScriptDependency extends ModuleDependency {
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
-		const { read } = context;
-		this.insertPos = read();
-		this.contentRange = read();
+		this.insertPos = context.read();
+		const c1 = context.rest;
+		this.contentRange = c1.read();
 		this.range = this.contentRange;
-		this.entryName = read();
-		this._category = read();
-		super.deserialize(context);
+		const c2 = c1.rest;
+		this.entryName = c2.read();
+		const c3 = c2.rest;
+		this._category = c3.read();
+		super.deserialize(c3.rest);
 	}
 }
 

package/lib/dependencies/HtmlInlineStyleDependency.js

@@ -16,28 +16,48 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").BuildInfo} BuildInfo */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<boolean[]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<boolean[]>} ObjectSerializerContext */
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
+const TRAILING_WHITESPACE_REGEXP = /\s+$/;
+// One pass over the source: each char is replaced once and replacements aren't
+// re-scanned, so this matches the `&`-first sequential escape chain exactly
+// while avoiding two extra full-string scans + intermediate strings.
+const ATTR_ESCAPE_REGEXP = /[&"']/g;
+/** @type {Record<string, string>} */
+const ATTR_ESCAPES = { "&": "&amp;", '"': "&quot;", "'": "&#39;" };
 /**
- * Represents an inline `<style>...</style>` block in an HTML module. The
- * tag's content is fed into webpack's CSS pipeline as a virtual CSS module
- * with `exportType: "text"` so `url()` and `\@import` references are
- * resolved relative to the HTML file. At render time the original content
- * range is replaced with the processed CSS text read from the CSS module's
- * code generation data.
+ * @param {string} c matched character
+ * @returns {string} the HTML-attribute-escaped entity
+ */
+const escapeAttrChar = (c) => ATTR_ESCAPES[c];
+
+/**
+ * Represents inline CSS in an HTML module — either a `<style>...</style>`
+ * block (a stylesheet) or an element's `style="..."` attribute (a CSS
+ * block's contents). The content is fed into webpack's CSS pipeline as a
+ * virtual CSS module with `exportType: "text"` so `url()` and `\@import`
+ * references are resolved relative to the HTML file. At render time the
+ * original content range is replaced with the processed CSS text read from
+ * the CSS module's code generation data.
  */
 class HtmlInlineStyleDependency extends ModuleDependency {
 	/**
 	 * Creates an instance of HtmlInlineStyleDependency.
 	 * @param {string} request virtual request resolving to the inline CSS (data URI)
-	 * @param {Range} range range of the inline CSS content (between `<style>` and `</style>`)
+	 * @param {Range} range range of the inline CSS content (between `<style>` and `</style>`, or the `style` attribute value)
+	 * @param {boolean=} attribute true when the source is a `style="..."` attribute (a block's contents) rather than a `<style>` block (stylesheet)
+	 * @param {boolean=} inAttribute true when the range is an attribute value (decoded on parse, so the processed CSS must be re-escaped on write-back); defaults to `attribute` — differs only for attribute values parsed as full stylesheets
 	 */
-	constructor(request, range) {
+	constructor(request, range, attribute = false, inAttribute = attribute) {
 		super(request);
 		this.range = range;
+		/** @type {boolean} */
+		this.attribute = attribute;
+		/** @type {boolean} */
+		this.inAttribute = inAttribute;
 	}
 
 	get type() {
@@ -45,7 +65,7 @@ class HtmlInlineStyleDependency extends ModuleDependency {
 	}
 
 	get category() {
-		return "html-style";
+		return this.attribute ? "html-style-attribute" : "html-style";
 	}
 
 	/**
@@ -68,6 +88,8 @@ class HtmlInlineStyleDependency extends ModuleDependency {
 	 */
 	serialize(context) {
 		super.serialize(context);
+		context.write(this.attribute);
+		context.write(this.inAttribute);
 	}
 
 	/**
@@ -76,6 +98,8 @@ class HtmlInlineStyleDependency extends ModuleDependency {
 	 */
 	deserialize(context) {
 		super.deserialize(context);
+		this.attribute = context.read();
+		this.inAttribute = context.read();
 	}
 }
 
@@ -106,6 +130,16 @@ HtmlInlineStyleDependency.Template = class HtmlInlineStyleDependencyTemplate ext
 			}
 		}
 
+		// An attribute value was entity-decoded before parsing, so re-escape
+		// the processed CSS to keep the surrounding markup valid in any
+		// quoting context, and drop the trailing newline the CSS generator
+		// appends so the rewritten attribute stays on one line.
+		if (dep.inAttribute) {
+			cssText = cssText
+				.replace(TRAILING_WHITESPACE_REGEXP, "")
+				.replace(ATTR_ESCAPE_REGEXP, escapeAttrChar);
+		}
+
 		source.replace(dep.range[0], dep.range[1] - 1, cssText);
 	}
 };

package/lib/dependencies/ImportContextDependency.js

@@ -10,8 +10,8 @@ const ContextDependency = require("./ContextDependency");
 const ContextDependencyTemplateAsRequireCall = require("./ContextDependencyTemplateAsRequireCall");
 
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Range]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[Range]>} ObjectSerializerContext */
 /** @typedef {import("./ContextDependency").ContextDependencyOptions} ContextDependencyOptions */
 
 class ImportContextDependency extends ContextDependency {
@@ -55,9 +55,7 @@ class ImportContextDependency extends ContextDependency {
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
-		const { write } = context;
-
-		write(this.valueRange);
+		context.write(this.valueRange);
 
 		super.serialize(context);
 	}
@@ -67,11 +65,9 @@ class ImportContextDependency extends ContextDependency {
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
-		const { read } = context;
-
-		this.valueRange = read();
+		this.valueRange = context.read();
 
-		super.deserialize(context);
+		super.deserialize(context.rest);
 	}
 }
 

package/lib/dependencies/ImportDependency.js

@@ -7,11 +7,13 @@
 
 const Dependency = require("../Dependency");
 const makeSerializable = require("../util/makeSerializable");
+const memoize = require("../util/memoize");
 const { ImportPhaseUtils } = require("./ImportPhase");
 const ModuleDependency = require("./ModuleDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../AsyncDependenciesBlock")} AsyncDependenciesBlock */
+/** @typedef {import("../Dependency").GetConditionFn} GetConditionFn */
 /** @typedef {import("../Dependency").RawReferencedExports} RawReferencedExports */
 /** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
@@ -23,8 +25,11 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("./HarmonyImportGuard").DependencyGuard} DependencyGuard */
 /** @typedef {import("./ImportPhase").ImportPhaseType} ImportPhaseType */
 
+const getHarmonyImportGuard = memoize(() => require("./HarmonyImportGuard"));
+
 class ImportDependency extends ModuleDependency {
 	/**
 	 * Creates an instance of ImportDependency.
@@ -37,9 +42,14 @@ class ImportDependency extends ModuleDependency {
 	constructor(request, range, referencedExports, phase, attributes) {
 		super(request);
 		this.range = range;
+		/** @type {RawReferencedExports | null} */
 		this.referencedExports = referencedExports;
+		/** @type {ImportPhaseType} */
 		this.phase = phase;
+		/** @type {ImportAttributes | undefined} */
 		this.attributes = attributes;
+		/** @type {DependencyGuard[] | undefined} */
+		this.branchGuards = undefined;
 	}
 
 	get type() {
@@ -50,6 +60,18 @@ class ImportDependency extends ModuleDependency {
 		return "esm";
 	}
 
+	/**
+	 * Returns function to determine if the connection is active.
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {null | false | GetConditionFn} function to determine if the connection is active
+	 */
+	getCondition(moduleGraph) {
+		const guards = this.branchGuards;
+		if (guards === undefined) return null;
+		return (connection, runtime) =>
+			!getHarmonyImportGuard().isDeadByGuards(guards, moduleGraph, runtime);
+	}
+
 	/**
 	 * Returns an identifier to merge equal requests.
 	 * @returns {string | null} an identifier to merge equal requests
@@ -98,7 +120,8 @@ class ImportDependency extends ModuleDependency {
 			}
 			refs.push({
 				name: referencedExport,
-				canMangle: false
+				canMangle: false,
+				canInline: false
 			});
 		}
 		return refs;
@@ -113,6 +136,7 @@ class ImportDependency extends ModuleDependency {
 		context.write(this.referencedExports);
 		context.write(this.phase);
 		context.write(this.attributes);
+		context.write(this.branchGuards);
 		super.serialize(context);
 	}
 
@@ -125,6 +149,7 @@ class ImportDependency extends ModuleDependency {
 		this.referencedExports = context.read();
 		this.phase = context.read();
 		this.attributes = context.read();
+		this.branchGuards = context.read();
 		super.deserialize(context);
 	}
 }
@@ -144,9 +169,26 @@ ImportDependency.Template = class ImportDependencyTemplate extends (
 	apply(
 		dependency,
 		source,
-		{ runtimeTemplate, module, moduleGraph, chunkGraph, runtimeRequirements }
+		{
+			runtimeTemplate,
+			module,
+			moduleGraph,
+			chunkGraph,
+			runtimeRequirements,
+			runtime
+		}
 	) {
 		const dep = /** @type {ImportDependency} */ (dependency);
+		const connection = moduleGraph.getConnection(dep);
+		// Dead branch: module is excluded and has no id; code is never executed.
+		if (connection && !connection.isTargetActive(runtime)) {
+			source.replace(
+				dep.range[0],
+				dep.range[1] - 1,
+				"Promise.resolve(/* dead branch */)"
+			);
+			return;
+		}
 		const block = /** @type {AsyncDependenciesBlock} */ (
 			moduleGraph.getParentBlock(dep)
 		);

package/lib/dependencies/ImportMetaHotAcceptDependency.js

@@ -20,6 +20,7 @@ class ImportMetaHotAcceptDependency extends ModuleDependency {
 	constructor(request, range) {
 		super(request);
 		this.range = range;
+		/** @type {boolean} */
 		this.weak = true;
 	}
 

package/lib/dependencies/ImportMetaHotDeclineDependency.js

@@ -21,6 +21,7 @@ class ImportMetaHotDeclineDependency extends ModuleDependency {
 		super(request);
 
 		this.range = range;
+		/** @type {boolean} */
 		this.weak = true;
 	}
 

package/lib/dependencies/ImportMetaPlugin.js

@@ -26,6 +26,13 @@ const { propertyAccess } = require("../util/property");
 const ConstDependency = require("./ConstDependency");
 const ModuleInitFragmentDependency = require("./ModuleInitFragmentDependency");
 
+// Loaded at module scope, not inside the parser handler: the async resolver
+// cache tail can run that handler after a test tears down the module registry.
+const WEBPACK_VERSION = Number.parseInt(
+	require("../../package.json").version,
+	10
+);
+
 /** @typedef {import("estree").MemberExpression} MemberExpression */
 /** @typedef {import("estree").Identifier} Identifier */
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
@@ -40,6 +47,29 @@ const ModuleInitFragmentDependency = require("./ModuleInitFragmentDependency");
 
 const PLUGIN_NAME = "ImportMetaPlugin";
 
+const IMPORT_META = "import.meta";
+const IMPORT_META_URL = "import.meta.url";
+const IMPORT_META_WEBPACK = "import.meta.webpack";
+const IMPORT_META_MAIN = "import.meta.main";
+const IMPORT_META_ENV = "import.meta.env";
+const IMPORT_META_DIRNAME = "import.meta.dirname";
+const IMPORT_META_FILENAME = "import.meta.filename";
+
+// Single source of truth for `import.meta` accesses that only exist in ES modules
+// and therefore mark a module as ESM (consumed by HarmonyDetectionParserPlugin).
+// `dirname`/`filename` are resolved by NodeStuffPlugin, the rest here. The webpack
+// pragmas `import.meta.webpackHot`/`webpackContext` are intentionally excluded:
+// they are usable in CommonJS modules and must not force ESM.
+const IMPORT_META_NAMES = [
+	IMPORT_META,
+	IMPORT_META_URL,
+	IMPORT_META_WEBPACK,
+	IMPORT_META_MAIN,
+	IMPORT_META_ENV,
+	IMPORT_META_DIRNAME,
+	IMPORT_META_FILENAME
+];
+
 /** @type {WeakMap<Compilation, { stringify: string, env: Record<string, string> }>} */
 const compilationMetaEnvMap = new WeakMap();
 
@@ -137,7 +167,7 @@ class ImportMetaPlugin {
 						if (importMetaName === "import.meta") return;
 
 						parser.hooks.expression
-							.for("import.meta")
+							.for(IMPORT_META)
 							.tap(PLUGIN_NAME, (metaProperty) => {
 								const dep = new ConstDependency(
 									/** @type {string} */ (importMetaName),
@@ -151,13 +181,10 @@ class ImportMetaPlugin {
 					}
 
 					// import.meta direct
-					const webpackVersion = Number.parseInt(
-						require("../../package.json").version,
-						10
-					);
 					const importMetaUrl = () =>
 						JSON.stringify(getUrl(parser.state.module));
-					const importMetaWebpackVersion = () => JSON.stringify(webpackVersion);
+					const importMetaWebpackVersion = () =>
+						JSON.stringify(WEBPACK_VERSION);
 					/**
 					 * Import meta unknown property.
 					 * @param {Members} members members
@@ -173,7 +200,7 @@ class ImportMetaPlugin {
 					};
 
 					parser.hooks.typeof
-						.for("import.meta")
+						.for(IMPORT_META)
 						.tap(
 							PLUGIN_NAME,
 							toConstantDependency(parser, JSON.stringify("object"))
@@ -185,7 +212,7 @@ class ImportMetaPlugin {
 						}
 					);
 					parser.hooks.expression
-						.for("import.meta")
+						.for(IMPORT_META)
 						.tap(PLUGIN_NAME, (metaProperty) => {
 							/** @type {RawRuntimeRequirements} */
 							const runtimeRequirements = [];
@@ -254,7 +281,9 @@ class ImportMetaPlugin {
 										);
 										break;
 									case "env":
-										str += `env: ${collectImportMetaEnvDefinitions(compilation).stringify},`;
+										str += `env: ${
+											collectImportMetaEnvDefinitions(compilation).stringify
+										},`;
 										break;
 									default:
 										str += `[${JSON.stringify(
@@ -273,22 +302,22 @@ class ImportMetaPlugin {
 							return true;
 						});
 					parser.hooks.evaluateTypeof
-						.for("import.meta")
+						.for(IMPORT_META)
 						.tap(PLUGIN_NAME, evaluateToString("object"));
-					parser.hooks.evaluateIdentifier.for("import.meta").tap(
+					parser.hooks.evaluateIdentifier.for(IMPORT_META).tap(
 						PLUGIN_NAME,
-						evaluateToIdentifier("import.meta", "import.meta", () => [], true)
+						evaluateToIdentifier(IMPORT_META, IMPORT_META, () => [], true)
 					);
 
 					// import.meta.url
 					parser.hooks.typeof
-						.for("import.meta.url")
+						.for(IMPORT_META_URL)
 						.tap(
 							PLUGIN_NAME,
 							toConstantDependency(parser, JSON.stringify("string"))
 						);
 					parser.hooks.expression
-						.for("import.meta.url")
+						.for(IMPORT_META_URL)
 						.tap(PLUGIN_NAME, (expr) => {
 							const dep = new ConstDependency(
 								importMetaUrl(),
@@ -299,10 +328,10 @@ class ImportMetaPlugin {
 							return true;
 						});
 					parser.hooks.evaluateTypeof
-						.for("import.meta.url")
+						.for(IMPORT_META_URL)
 						.tap(PLUGIN_NAME, evaluateToString("string"));
 					parser.hooks.evaluateIdentifier
-						.for("import.meta.url")
+						.for(IMPORT_META_URL)
 						.tap(PLUGIN_NAME, (expr) =>
 							new BasicEvaluatedExpression()
 								.setString(getUrl(parser.state.module))
@@ -311,26 +340,26 @@ class ImportMetaPlugin {
 
 					// import.meta.webpack
 					parser.hooks.expression
-						.for("import.meta.webpack")
+						.for(IMPORT_META_WEBPACK)
 						.tap(
 							PLUGIN_NAME,
 							toConstantDependency(parser, importMetaWebpackVersion())
 						);
 					parser.hooks.typeof
-						.for("import.meta.webpack")
+						.for(IMPORT_META_WEBPACK)
 						.tap(
 							PLUGIN_NAME,
 							toConstantDependency(parser, JSON.stringify("number"))
 						);
 					parser.hooks.evaluateTypeof
-						.for("import.meta.webpack")
+						.for(IMPORT_META_WEBPACK)
 						.tap(PLUGIN_NAME, evaluateToString("number"));
 					parser.hooks.evaluateIdentifier
-						.for("import.meta.webpack")
-						.tap(PLUGIN_NAME, evaluateToNumber(webpackVersion));
+						.for(IMPORT_META_WEBPACK)
+						.tap(PLUGIN_NAME, evaluateToNumber(WEBPACK_VERSION));
 
 					parser.hooks.expression
-						.for("import.meta.main")
+						.for(IMPORT_META_MAIN)
 						.tap(
 							PLUGIN_NAME,
 							toConstantDependency(
@@ -344,24 +373,24 @@ class ImportMetaPlugin {
 							)
 						);
 					parser.hooks.typeof
-						.for("import.meta.main")
+						.for(IMPORT_META_MAIN)
 						.tap(
 							PLUGIN_NAME,
 							toConstantDependency(parser, JSON.stringify("boolean"))
 						);
 					parser.hooks.evaluateTypeof
-						.for("import.meta.main")
+						.for(IMPORT_META_MAIN)
 						.tap(PLUGIN_NAME, evaluateToString("boolean"));
 
 					// import.meta.env
 					parser.hooks.typeof
-						.for("import.meta.env")
+						.for(IMPORT_META_ENV)
 						.tap(
 							PLUGIN_NAME,
 							toConstantDependency(parser, JSON.stringify("object"))
 						);
 					parser.hooks.expressionMemberChain
-						.for("import.meta")
+						.for(IMPORT_META)
 						.tap(PLUGIN_NAME, (expr, members) => {
 							if (members[0] === "env" && members[1]) {
 								const name = members[1];
@@ -378,7 +407,7 @@ class ImportMetaPlugin {
 							}
 						});
 					parser.hooks.expression
-						.for("import.meta.env")
+						.for(IMPORT_META_ENV)
 						.tap(PLUGIN_NAME, (expr) => {
 							const { stringify } =
 								collectImportMetaEnvDefinitions(compilation);
@@ -392,10 +421,10 @@ class ImportMetaPlugin {
 							return true;
 						});
 					parser.hooks.evaluateTypeof
-						.for("import.meta.env")
+						.for(IMPORT_META_ENV)
 						.tap(PLUGIN_NAME, evaluateToString("object"));
 					parser.hooks.evaluateIdentifier
-						.for("import.meta.env")
+						.for(IMPORT_META_ENV)
 						.tap(PLUGIN_NAME, (expr) =>
 							new BasicEvaluatedExpression()
 								.setTruthy()
@@ -405,7 +434,7 @@ class ImportMetaPlugin {
 
 					// Unknown properties
 					parser.hooks.unhandledExpressionMemberChain
-						.for("import.meta")
+						.for(IMPORT_META)
 						.tap(PLUGIN_NAME, (expr, members) => {
 							// unknown import.meta properties should be determined at runtime
 							if (importMeta === "preserve-unknown") {
@@ -442,6 +471,18 @@ class ImportMetaPlugin {
 								expr.property.type ===
 									(expr.computed ? "Literal" : "Identifier")
 							) {
+								const prop = expr.computed
+									? /** @type {import("estree").Literal} */ (expr.property)
+											.value
+									: /** @type {Identifier} */ (expr.property).name;
+								// dirname/filename are resolved by NodeStuffPlugin; main is a runtime value
+								if (
+									prop === "dirname" ||
+									prop === "filename" ||
+									prop === "main"
+								) {
+									return;
+								}
 								return new BasicEvaluatedExpression()
 									.setUndefined()
 									.setRange(/** @type {Range} */ (expr.range));
@@ -461,3 +502,6 @@ class ImportMetaPlugin {
 }
 
 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;

package/lib/dependencies/ImportParserPlugin.js

@@ -12,6 +12,7 @@ const {
 	VariableInfo,
 	getImportAttributes
 } = require("../javascript/JavascriptParser");
+const memoize = require("../util/memoize");
 const traverseDestructuringAssignmentProperties = require("../util/traverseDestructuringAssignmentProperties");
 const ContextDependencyHelpers = require("./ContextDependencyHelpers");
 const { getNonOptionalPart } = require("./HarmonyImportDependency");
@@ -42,6 +43,8 @@ const ImportWeakDependency = require("./ImportWeakDependency");
 /** @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()");
@@ -177,6 +180,7 @@ class ImportParserPlugin {
 	 * @param {JavascriptParserOptions} options options
 	 */
 	constructor(options) {
+		/** @type {JavascriptParserOptions} */
 		this.options = options;
 	}
 
@@ -452,6 +456,20 @@ class ImportParserPlugin {
 						exports = exportsFromEnumerable(importOptions.webpackExports);
 					}
 				}
+				// `worker` is an internal entry option set only for workers
+				if (
+					importOptions.webpackEntryOptions !== undefined &&
+					typeof importOptions.webpackEntryOptions === "object" &&
+					importOptions.webpackEntryOptions !== null &&
+					importOptions.webpackEntryOptions.worker !== undefined
+				) {
+					parser.state.module.addWarning(
+						new UnsupportedFeatureWarning(
+							"`worker` entry option is not supported in `import()`, it only applies to workers (e.g. `new Worker(new URL(...))`).",
+							/** @type {DependencyLocation} */ (expr.loc)
+						)
+					);
+				}
 			}
 
 			if (
@@ -550,6 +568,7 @@ class ImportParserPlugin {
 					dep.optional = Boolean(parser.scope.inTry);
 					depBlock.addDependency(dep);
 					parser.state.current.addBlock(depBlock);
+					getHarmonyImportGuard().attachDependencyGuards(parser, dep);
 				}
 			} else {
 				if (mode === "weak") {

package/lib/dependencies/ImportWeakDependency.js

@@ -29,6 +29,7 @@ class ImportWeakDependency extends ImportDependency {
 	 */
 	constructor(request, range, referencedExports, phase, attributes) {
 		super(request, range, referencedExports, phase, attributes);
+		/** @type {boolean} */
 		this.weak = true;
 	}