webpack 5.110.2 → 5.111.0

package/lib/dependencies/HarmonyImportDependency.js

@@ -11,11 +11,14 @@ const InitFragment = require("../InitFragment");
 const Template = require("../Template");
 const AwaitDependenciesInitFragment = require("../async-modules/AwaitDependenciesInitFragment");
 const isGeneratorLowered = require("../async-modules/isGeneratorLowered");
+const memoize = require("../util/memoize");
 const { filterRuntime, mergeRuntime } = require("../util/runtime");
 const HarmonyLinkingError = require("./HarmonyLinkingError");
 const { ImportPhase, ImportPhaseUtils } = require("./ImportPhase");
 const ModuleDependency = require("./ModuleDependency");
 
+const getExternalModule = memoize(() => require("../ExternalModule"));
+
 /** @import { ReplaceSource } from "webpack-sources" */
 /**
  * @import {
@@ -97,6 +100,36 @@ const getNonOptionalPart = (members, membersOptionals) => {
 
 /** @typedef {string[]} Ids */
 
+/**
+ * Export names a lazy barrel still defers, so they are missing from its provided
+ * exports without being absent from the module.
+ * @param {Module} module the imported module
+ * @returns {Set<string> | true | undefined} deferred names, true when a deferred star re-export may provide any name, undefined when none
+ */
+const getDeferredExports = (module) => {
+	const factoryMeta = module.factoryMeta;
+	if (factoryMeta === undefined || !factoryMeta.sideEffectFree) return;
+	/** @type {Set<string> | undefined} */
+	let names;
+	for (const dep of module.dependencies) {
+		// TODO remove in webpack 6
+		// These may be missing on custom dependency types not extending the base Dependency
+		if (
+			typeof dep.getLazyUntil !== "function" ||
+			typeof dep.isLazy !== "function"
+		) {
+			continue;
+		}
+		if (!dep.isLazy()) continue;
+		const until = dep.getLazyUntil();
+		if (until === Dependency.LAZY_UNTIL_FALLBACK) return true;
+		if (until !== Dependency.LAZY_UNTIL_ID) continue;
+		if (names === undefined) names = new Set();
+		names.add(/** @type {string} */ (dep.getLazyName()));
+	}
+	return names;
+};
+
 class HarmonyImportDependency extends ModuleDependency {
 	/**
 	 * Creates an instance of HarmonyImportDependency.
@@ -185,9 +218,14 @@ class HarmonyImportDependency extends ModuleDependency {
 		const importedModule = /** @type {Module} */ (moduleGraph.getModule(this));
 		const meta = moduleGraph.getMeta(module);
 
+		// An async external is a promise webpack awaits, not a module record with
+		// an evaluating state, so deferring its namespace would never throw.
 		const isDeferred =
 			ImportPhaseUtils.isDefer(this.phase) &&
-			!(/** @type {BuildMeta} */ (importedModule.buildMeta).async);
+			!(
+				/** @type {BuildMeta} */ (importedModule.buildMeta).async &&
+				importedModule instanceof getExternalModule()
+			);
 
 		const metaKey = isDeferred ? "deferredImportVarMap" : "importVarMap";
 		let importVarMap = meta[metaKey];
@@ -283,48 +321,63 @@ class HarmonyImportDependency extends ModuleDependency {
 				(exportsType !== "default-with-named" || ids[0] !== "default") &&
 				moduleGraph.isExportProvided(importedModule, ids) === false
 			) {
-				// We are sure that it's not provided
-
-				// Try to provide detailed info in the error message
-				let pos = 0;
-				let exportsInfo = moduleGraph.getExportsInfo(importedModule);
-				while (pos < ids.length && exportsInfo) {
-					const id = ids[pos++];
-					const exportInfo = exportsInfo.getReadOnlyExportInfo(id);
-					if (exportInfo.provided === false) {
-						// We are sure that it's not provided
-						const providedExports = exportsInfo.getProvidedExports();
-						const moreInfo = !Array.isArray(providedExports)
-							? " (possible exports unknown)"
-							: providedExports.length === 0
-								? " (module has no exports)"
-								: ` (possible exports: ${providedExports.join(", ")})`;
-						return [
-							new HarmonyLinkingError(
-								`export ${ids
-									.slice(0, pos)
-									.map((id) => `'${id}'`)
-									.join(".")} ${additionalMessage} was not found in '${
-									this.userRequest
-								}'${moreInfo}`
-							)
-						];
+				const deferredExports = getDeferredExports(importedModule);
+
+				if (
+					deferredExports !== true &&
+					(deferredExports === undefined || !deferredExports.has(ids[0]))
+				) {
+					// We are sure that it's not provided
+
+					// Try to provide detailed info in the error message
+					let pos = 0;
+					let exportsInfo = moduleGraph.getExportsInfo(importedModule);
+					while (pos < ids.length && exportsInfo) {
+						const id = ids[pos++];
+						const exportInfo = exportsInfo.getReadOnlyExportInfo(id);
+						if (exportInfo.provided === false) {
+							// We are sure that it's not provided
+							let providedExports = exportsInfo.getProvidedExports();
+							// only the first level names the imported module itself
+							if (
+								pos === 1 &&
+								deferredExports !== undefined &&
+								Array.isArray(providedExports)
+							) {
+								providedExports = [...providedExports, ...deferredExports];
+							}
+							const moreInfo = !Array.isArray(providedExports)
+								? " (possible exports unknown)"
+								: providedExports.length === 0
+									? " (module has no exports)"
+									: ` (possible exports: ${providedExports.join(", ")})`;
+							return [
+								new HarmonyLinkingError(
+									`export ${ids
+										.slice(0, pos)
+										.map((id) => `'${id}'`)
+										.join(".")} ${additionalMessage} was not found in '${
+										this.userRequest
+									}'${moreInfo}`
+								)
+							];
+						}
+						exportsInfo =
+							/** @type {ExportsInfo} */
+							(exportInfo.getNestedExportsInfo());
 					}
-					exportsInfo =
-						/** @type {ExportsInfo} */
-						(exportInfo.getNestedExportsInfo());
-				}
 
-				// General error message
-				return [
-					new HarmonyLinkingError(
-						`export ${ids
-							.map((id) => `'${id}'`)
-							.join(".")} ${additionalMessage} was not found in '${
-							this.userRequest
-						}'`
-					)
-				];
+					// General error message
+					return [
+						new HarmonyLinkingError(
+							`export ${ids
+								.map((id) => `'${id}'`)
+								.join(".")} ${additionalMessage} was not found in '${
+								this.userRequest
+							}'`
+						)
+					];
+				}
 			}
 		}
 		switch (exportsType) {
@@ -468,8 +521,13 @@ HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends
 		}
 
 		const importStatement = dep.getImportStatement(false, templateContext);
+		// A module deferring itself is already evaluating: awaiting it would probe
+		// the deferred namespace and force the evaluation it must not trigger.
+		const isSelfDeferred =
+			ImportPhaseUtils.isDefer(dep.phase) && referencedModule === module;
 		if (
 			referencedModule &&
+			!isSelfDeferred &&
 			templateContext.moduleGraph.isAsync(referencedModule)
 		) {
 			templateContext.initFragments.push(

package/lib/dependencies/HarmonyImportDependencyParserPlugin.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const ImportedBindingAssignmentError = require("../errors/ImportedBindingAssignmentError");
 const WebpackError = require("../errors/WebpackError");
 const getParserHooks = require("../hmr/parserHooks");
 const {
@@ -17,6 +18,7 @@ const HarmonyAcceptDependency = require("./HarmonyAcceptDependency");
 const HarmonyAcceptImportDependency = require("./HarmonyAcceptImportDependency");
 const HarmonyEvaluatedImportSpecifierDependency = require("./HarmonyEvaluatedImportSpecifierDependency");
 const HarmonyExports = require("./HarmonyExports");
+const HarmonyImportBareSideEffectDependency = require("./HarmonyImportBareSideEffectDependency");
 const {
 	ExportPresenceModes,
 	getNonOptionalPart
@@ -310,7 +312,13 @@ class HarmonyImportDependencyParserPlugin {
 				parser.state.current.addError(error);
 			}
 
-			const sideEffectDep = new HarmonyImportSideEffectDependency(
+			// A declaration binding nothing was written for what importing produces,
+			// which for a module emitting its own file is that file.
+			const SideEffectDependency =
+				statement.specifiers.length === 0
+					? HarmonyImportBareSideEffectDependency
+					: HarmonyImportSideEffectDependency;
+			const sideEffectDep = new SideEffectDependency(
 				/** @type {string} */ (source),
 				parser.state.lastHarmonyImportOrder,
 				phase,
@@ -393,11 +401,20 @@ class HarmonyImportDependencyParserPlugin {
 		);
 		// Concatenation would turn the binding into a plain local, losing the
 		// getter-only property whose write throws.
-		parser.hooks.assign.for(harmonySpecifierTag).tap(PLUGIN_NAME, () => {
-			markUsed(/** @type {HarmonySettings} */ (parser.currentTagData));
+		parser.hooks.assign.for(harmonySpecifierTag).tap(PLUGIN_NAME, (expr) => {
+			const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
+			markUsed(settings);
 			/** @type {JavascriptModuleBuildInfo} */
 			(parser.state.module.buildInfo).moduleConcatenationBailout =
 				"assignment to an imported binding";
+			// A named import is written through the namespace's getter-only
+			// property, which throws on its own. A namespace one is the binding
+			// itself, and nothing webpack can emit for it throws, so report it.
+			if (settings.ids.length === 0) {
+				const error = new ImportedBindingAssignmentError(settings.name);
+				error.loc = parser.getLocation(expr);
+				parser.state.module.addError(error);
+			}
 		});
 		parser.hooks.expression
 			.for(harmonySpecifierTag)

package/lib/dependencies/HarmonyImportSpecifierDependency.js

@@ -26,10 +26,11 @@ const HarmonyImportGuard = require("./HarmonyImportGuard");
 const { ImportPhaseUtils } = require("./ImportPhase");
 
 /** @import { ReplaceSource } from "webpack-sources" */
-/** @import { GetConditionFn, ReferencedExports } from "../Dependency" */
+/** @import { GetConditionFn, ReferencedExports, UpdateHashContext } from "../Dependency" */
 /** @import { DependencyTemplateContext } from "../DependencyTemplate" */
 /** @import Module, { BuildMeta } from "../Module" */
 /** @import ModuleGraph from "../ModuleGraph" */
+/** @import Hash from "../util/Hash" */
 /**
  * @import ModuleGraphConnection, {
  * 	ConnectionState
@@ -262,6 +263,28 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		return condition;
 	}
 
+	/**
+	 * Updates the hash with the data contributed by this instance.
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		const { chunkGraph, runtime } = context;
+		const moduleGraph = chunkGraph.moduleGraph;
+		if (!isInlineExportsEnabled(moduleGraph)) return;
+		const module = moduleGraph.getModule(this);
+		if (!module || !isInlineEnabled(module)) return;
+		const ids = this.getIds(moduleGraph);
+		if (ids.length === 0) return;
+		const exportsInfo = moduleGraph.getExportsInfo(module);
+		if (!exportsInfo.hasInlinedUsedName(ids, runtime)) return;
+		const usedName = exportsInfo.getUsedName(ids, runtime);
+		if (usedName instanceof InlinedUsedName) {
+			usedName.updateHash(hash);
+		}
+	}
+
 	/**
 	 * Gets module evaluation side effects state.
 	 * @param {ModuleGraph} moduleGraph the module graph

package/lib/dependencies/HarmonyModulesPlugin.js

@@ -20,6 +20,7 @@ const HarmonyExportExpressionDependency = require("./HarmonyExportExpressionDepe
 const HarmonyExportHeaderDependency = require("./HarmonyExportHeaderDependency");
 const HarmonyExportImportedSpecifierDependency = require("./HarmonyExportImportedSpecifierDependency");
 const HarmonyExportSpecifierDependency = require("./HarmonyExportSpecifierDependency");
+const HarmonyImportBareSideEffectDependency = require("./HarmonyImportBareSideEffectDependency");
 const HarmonyImportDependencyParserPlugin = require("./HarmonyImportDependencyParserPlugin");
 const HarmonyImportSideEffectDependency = require("./HarmonyImportSideEffectDependency");
 const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDependency");
@@ -34,6 +35,7 @@ const TopLevelAwaitDependency = require("./TopLevelAwaitDependency");
  */
 /** @import Compiler from "../Compiler" */
 /** @import Parser from "../javascript/JavascriptParser" */
+/** @import { BuildInfo } from "../Module" */
 
 /**
  * Defines the harmony modules plugin options type used by this module.
@@ -81,6 +83,15 @@ class HarmonyModulesPlugin {
 					new HarmonyImportSideEffectDependency.Template()
 				);
 
+				compilation.dependencyFactories.set(
+					HarmonyImportBareSideEffectDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					HarmonyImportBareSideEffectDependency,
+					new HarmonyImportBareSideEffectDependency.Template()
+				);
+
 				compilation.dependencyFactories.set(
 					HarmonyImportSpecifierDependency,
 					normalModuleFactory
@@ -149,6 +160,15 @@ class HarmonyModulesPlugin {
 						return;
 					}
 
+					if (parserOptions.specNamespaceObject) {
+						// Recorded on the module, because an importer asks the module it
+						// imports whether its namespace is a spec exotic object.
+						parser.hooks.program.tap(PLUGIN_NAME, () => {
+							/** @type {BuildInfo} */
+							(parser.state.module.buildInfo).specNamespaceObject = true;
+						});
+					}
+
 					new HarmonyDetectionParserPlugin().apply(parser);
 					new HarmonyImportDependencyParserPlugin(parserOptions).apply(parser);
 					new HarmonyExportDependencyParserPlugin(parserOptions).apply(parser);

package/lib/dependencies/HtmlEntryDependency.js

@@ -7,6 +7,7 @@
 const {
 	CSS_IMPORT_TYPE,
 	CSS_TYPE,
+	HTML_TYPE,
 	JAVASCRIPT_TYPE
 } = require("../ModuleSourceTypeConstants");
 const ResourceHintPlugin = require("../prefetch/ResourceHintPlugin");
@@ -194,7 +195,12 @@ const getEntrypointChunksInLoadOrder = (entrypoint) => {
 	const chunksLoadedByAncestorTags = new Set();
 	/** @type {Set<import("../ChunkGroup")>} */
 	const visitedGroups = new Set();
-	const walk = (/** @type {import("../ChunkGroup")} */ group) => {
+	/**
+	 * Collects the chunks an ancestor entry's own tags already load.
+	 * @param {import("../ChunkGroup")} group chunk group to walk up from
+	 * @returns {void}
+	 */
+	const walk = (group) => {
 		if (visitedGroups.has(group)) return;
 		visitedGroups.add(group);
 		for (const parent of group.parentsIterable) {
@@ -220,7 +226,12 @@ const getEntrypointChunksInLoadOrder = (entrypoint) => {
 	const ordered = [];
 	/** @type {Set<Chunk>} */
 	const seen = new Set();
-	const push = (/** @type {Chunk | null | undefined} */ chunk) => {
+	/**
+	 * Appends a chunk once, skipping the ones an ancestor entry already loads.
+	 * @param {Chunk | null | undefined} chunk chunk to append
+	 * @returns {void}
+	 */
+	const push = (chunk) => {
 		if (!chunk || seen.has(chunk) || chunk === entryChunk) return;
 		if (chunksLoadedByAncestorTags.has(chunk)) return;
 		seen.add(chunk);
@@ -577,6 +588,47 @@ const buildLinkTag = (rel, attrs) =>
 			: ""
 	}>`;
 
+/**
+ * The chunks a hint means when it names a page: a page loads no JavaScript of
+ * its own, so the hint follows the entries the parser extracted from it.
+ * @param {import("../Compilation")} compilation compilation
+ * @param {Chunk} chunk chunk a hint resolved to
+ * @returns {Chunk[]} the chunks to hint at
+ */
+const resolvePageChunk = (compilation, chunk) => {
+	const { chunkGraph } = compilation;
+	const modules = chunkGraph.getChunkModulesIterableBySourceType(
+		chunk,
+		HTML_TYPE
+	);
+	// A page with a JavaScript side of its own (an `output.library` entry) is
+	// hinted too — `chunkHasJs` can't say so, it holds for any runtime chunk.
+	const javascript = chunkGraph.getChunkModulesIterableBySourceType(
+		chunk,
+		JAVASCRIPT_TYPE
+	);
+	/** @type {Chunk[]} */
+	const chunks = javascript === undefined ? [] : [chunk];
+	// A chunk carrying no page stands for itself; a page stands for the entries
+	// extracted from it, so one that extracted nothing hints nothing.
+	if (modules === undefined) return chunks.length === 0 ? [chunk] : chunks;
+	for (const module of modules) {
+		const { htmlEntries } =
+			/** @type {import("../html/HtmlModule").HtmlModuleBuildInfo} */ (
+				module.buildInfo
+			) || {};
+		if (!htmlEntries) continue;
+		for (const group of Object.values(htmlEntries)) {
+			for (const { entryName } of group) {
+				const entrypoint = compilation.entrypoints.get(entryName);
+				const entryChunk = entrypoint && entrypoint.getEntrypointChunk();
+				if (entryChunk) chunks.push(entryChunk);
+			}
+		}
+	}
+	return chunks;
+};
+
 /**
  * Resolve one `output.html.resourceHints` descriptor to zero or more `<link>`
  * tags. A `chunk`/`entry` reference becomes the emitted chunk URL (a sentinel
@@ -623,6 +675,14 @@ const resolveResourceHint = (desc, ctx) => {
 	} else {
 		return [];
 	}
+	/** @type {Chunk[]} */
+	const hinted = [];
+	for (const chunk of chunks) {
+		for (const resolved of resolvePageChunk(ctx.compilation, chunk)) {
+			hinted.push(resolved);
+		}
+	}
+	chunks = hinted;
 	const kind = desc.as === "style" ? "css" : "javascript";
 	const as = desc.as || (rel === "modulepreload" ? undefined : "script");
 	// A hint targeting another chunk must match how that chunk is fetched, so

package/lib/dependencies/ImportContextDependency.js

@@ -8,11 +8,13 @@
 const makeSerializable = require("../util/makeSerializable");
 const ContextDependency = require("./ContextDependency");
 const ContextDependencyTemplateAsRequireCall = require("./ContextDependencyTemplateAsRequireCall");
+const importOptionsCheck = require("./importOptionsCheck");
 
 /** @import { Range } from "../javascript/JavascriptParser" */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Range]>} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[Range]>} ObjectSerializerContext */
+/** @import { ObjectDeserializerContext, ObjectSerializerContext } from "../serialization/ObjectMiddleware" */
 /** @import { ContextDependencyOptions } from "./ContextDependency" */
+/** @import { ReplaceSource } from "webpack-sources" */
+/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
 
 class ImportContextDependency extends ContextDependency {
 	/**
@@ -26,6 +28,8 @@ class ImportContextDependency extends ContextDependency {
 
 		this.range = range;
 		this.valueRange = valueRange;
+		/** @type {Range | undefined} */
+		this.optionsRange = undefined;
 	}
 
 	get type() {
@@ -56,6 +60,7 @@ class ImportContextDependency extends ContextDependency {
 	 */
 	serialize(context) {
 		context.write(this.valueRange);
+		context.write(this.optionsRange);
 
 		super.serialize(context);
 	}
@@ -66,6 +71,7 @@ class ImportContextDependency extends ContextDependency {
 	 */
 	deserialize(context) {
 		this.valueRange = context.read();
+		this.optionsRange = context.read();
 
 		super.deserialize(context.rest);
 	}
@@ -76,6 +82,40 @@ makeSerializable(
 	"webpack/lib/dependencies/ImportContextDependency"
 );
 
-ImportContextDependency.Template = ContextDependencyTemplateAsRequireCall;
+ImportContextDependency.Template = class ImportContextDependencyTemplate extends (
+	ContextDependencyTemplateAsRequireCall
+) {
+	/**
+	 * Rewrites the call around its request, dropping anything the original one
+	 * carried after it. Overridden where a later argument must be kept.
+	 * @param {ContextDependency} dep the dependency
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {string} moduleExports the expression the request is passed to
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	replaceCall(dep, source, moduleExports, templateContext) {
+		const optionsRange = /** @type {ImportContextDependency} */ (dep)
+			.optionsRange;
+		if (optionsRange === undefined) {
+			super.replaceCall(dep, source, moduleExports, templateContext);
+			return;
+		}
+		// Request then options, in that order; their own source is kept so
+		// nested dependencies in them still get their replacements.
+		const range = /** @type {Range} */ (dep.range);
+		const valueRange = /** @type {Range} */ (dep.valueRange);
+		const check = importOptionsCheck(
+			templateContext.runtimeTemplate,
+			["r", "o"],
+			`${moduleExports}(r)`
+		);
+		source.replace(range[0], valueRange[0] - 1, `(${check})(`);
+		// The options range excludes any parentheses the source had, so a comma
+		// expression would otherwise split into arguments of its own.
+		source.replace(valueRange[1], optionsRange[0] - 1, ", (");
+		source.replace(optionsRange[1], range[1] - 1, "))");
+	}
+};
 
 module.exports = ImportContextDependency;

package/lib/dependencies/ImportDependency.js

@@ -6,11 +6,11 @@
 "use strict";
 
 const Dependency = require("../Dependency");
-const Template = require("../Template");
 const makeSerializable = require("../util/makeSerializable");
 const HarmonyImportGuard = require("./HarmonyImportGuard");
 const { ImportPhaseUtils } = require("./ImportPhase");
 const ModuleDependency = require("./ModuleDependency");
+const importOptionsCheck = require("./importOptionsCheck");
 
 /** @import { ReplaceSource } from "webpack-sources" */
 /** @import AsyncDependenciesBlock from "../AsyncDependenciesBlock" */
@@ -226,35 +226,14 @@ ImportDependency.Template = class ImportDependencyTemplate extends (
 		}
 
 		// A non-static second argument must still be evaluated (for its side
-		// effects and evaluation order) and validated per spec. Keep it in place
-		// and wrap it in an inline validator that mirrors the runtime checks of
-		// the spec's `import(specifier, options)` evaluation.
+		// effects and evaluation order) and checked per spec, so keep it in place
+		// and wrap it.
 		if (dep.optionsRange) {
-			const validator = runtimeTemplate.basicFunction("o", [
-				"try {",
-				Template.indent([
-					"if (o !== undefined) {",
-					Template.indent([
-						'if ((typeof o !== "object" && typeof o !== "function") || o === null) throw new TypeError("The second argument to import() must be an object");',
-						'var a = o["with"];',
-						"if (a !== undefined) {",
-						Template.indent([
-							'if ((typeof a !== "object" && typeof a !== "function") || a === null) throw new TypeError("The \'with\' option must be an object");',
-							"for (var k = Object.keys(a), i = 0; i < k.length; i++) {",
-							Template.indent([
-								'if (typeof a[k[i]] !== "string") throw new TypeError("Import attribute values must be strings");'
-							]),
-							"}"
-						]),
-						"}"
-					]),
-					"}"
-				]),
-				"} catch (e) { return Promise.reject(e); }",
-				`return ${content};`
-			]);
-			source.replace(dep.range[0], dep.optionsRange[0] - 1, `(${validator})(`);
-			source.replace(dep.optionsRange[1], dep.range[1] - 1, ")");
+			const check = importOptionsCheck(runtimeTemplate, ["o"], content);
+			// The options range excludes any parentheses the source had, so a
+			// comma expression would otherwise split into arguments of its own.
+			source.replace(dep.range[0], dep.optionsRange[0] - 1, `(${check})((`);
+			source.replace(dep.optionsRange[1], dep.range[1] - 1, "))");
 			return;
 		}
 

package/lib/dependencies/ImportMetaMainDependency.js

@@ -0,0 +1,104 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const ConstDependency = require("./ConstDependency");
+const NullDependency = require("./NullDependency");
+
+/** @import { ReplaceSource } from "webpack-sources" */
+/** @import Dependency, { UpdateHashContext } from "../Dependency" */
+/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
+/** @import { Range } from "../javascript/JavascriptParser" */
+/**
+ * @import {
+ * 	ObjectDeserializerContext,
+ * 	ObjectSerializerContext
+ * } from "../serialization/ObjectMiddleware"
+ */
+/** @import Hash from "../util/Hash" */
+
+/**
+ * `import.meta.main` asks whether the module is the entry, which needs the
+ * module argument scope hoisting removes. An inner concatenated module is
+ * never an entry module, so it answers with a separate constant expression.
+ */
+class ImportMetaMainDependency extends ConstDependency {
+	/**
+	 * Creates an instance of ImportMetaMainDependency.
+	 * @param {string} expression the expression a module outside a concatenation evaluates
+	 * @param {string} concatenatedExpression the expression an inner concatenated module evaluates
+	 * @param {Range} range the source range
+	 * @param {(string[] | null)=} runtimeRequirements runtime requirements of `expression`
+	 */
+	constructor(expression, concatenatedExpression, range, runtimeRequirements) {
+		super(expression, range, runtimeRequirements);
+		/** @type {string} */
+		this.concatenatedExpression = concatenatedExpression;
+	}
+
+	/**
+	 * Updates the hash with the data contributed by this instance.
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		super.updateHash(hash, context);
+		hash.update(this.concatenatedExpression);
+	}
+
+	/**
+	 * Serializes this instance into the provided serializer context.
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		context.write(this.concatenatedExpression);
+		super.serialize(context);
+	}
+
+	/**
+	 * Restores this instance from the provided deserializer context.
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		this.concatenatedExpression = context.read();
+		super.deserialize(context.rest);
+	}
+}
+
+makeSerializable(
+	ImportMetaMainDependency,
+	"webpack/lib/dependencies/ImportMetaMainDependency"
+);
+
+ImportMetaMainDependency.Template = class ImportMetaMainDependencyTemplate extends (
+	NullDependency.Template
+) {
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, templateContext) {
+		const dep = /** @type {ImportMetaMainDependency} */ (dependency);
+		const concatenated = templateContext.concatenationScope !== undefined;
+		if (!concatenated && dep.runtimeRequirements) {
+			for (const req of dep.runtimeRequirements) {
+				templateContext.runtimeRequirements.add(req);
+			}
+		}
+		const expression = concatenated
+			? dep.concatenatedExpression
+			: dep.expression;
+		const range = /** @type {Range} */ (dep.range);
+		source.replace(range[0], range[1] - 1, expression);
+	}
+};
+
+module.exports = ImportMetaMainDependency;