@depup/webpack 5.106.0-depup.0 → 5.109.0-depup.0

package/lib/ContextModule.js

@@ -7,7 +7,6 @@
 
 const { OriginalSource, RawSource } = require("webpack-sources");
 const AsyncDependenciesBlock = require("./AsyncDependenciesBlock");
-const { makeWebpackError } = require("./HookWebpackError");
 const Module = require("./Module");
 const {
 	JAVASCRIPT_TYPE,
@@ -16,11 +15,12 @@ const {
 const { JAVASCRIPT_MODULE_TYPE_DYNAMIC } = require("./ModuleTypeConstants");
 const RuntimeGlobals = require("./RuntimeGlobals");
 const Template = require("./Template");
-const WebpackError = require("./WebpackError");
 const {
 	getOutgoingAsyncModules
 } = require("./async-modules/AsyncModuleHelpers");
 const { ImportPhase, ImportPhaseUtils } = require("./dependencies/ImportPhase");
+const { makeWebpackError } = require("./errors/HookWebpackError");
+const WebpackError = require("./errors/WebpackError");
 const {
 	compareLocations,
 	compareModulesById,
@@ -34,6 +34,7 @@ const {
 	parseResource
 } = require("./util/identifier");
 const makeSerializable = require("./util/makeSerializable");
+const { propertyAccess } = require("./util/property");
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
@@ -48,6 +49,7 @@ const makeSerializable = require("./util/makeSerializable");
 /** @typedef {import("./Dependency")} Dependency */
 /** @typedef {import("./Dependency").RawReferencedExports} RawReferencedExports */
 /** @typedef {import("./Generator").SourceTypes} SourceTypes */
+/** @typedef {import("./FileSystemInfo").Snapshot} Snapshot */
 /** @typedef {import("./Module").BuildCallback} BuildCallback */
 /** @typedef {import("./Module").BuildInfo} BuildInfo */
 /** @typedef {import("./Module").FileSystemDependencies} FileSystemDependencies */
@@ -65,8 +67,8 @@ const makeSerializable = require("./util/makeSerializable");
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("./dependencies/ContextElementDependency")} ContextElementDependency */
 /** @typedef {import("./javascript/JavascriptParser").ImportAttributes} ImportAttributes */
-/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext<[string, boolean]>} ObjectDeserializerContext */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext<[string, boolean]>} ObjectSerializerContext */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("./dependencies/ImportPhase").ImportPhaseType} ImportPhaseType */
 
@@ -89,6 +91,11 @@ const makeSerializable = require("./util/makeSerializable");
  * @property {string | null=} layer
  * @property {ImportAttributes=} attributes
  * @property {ImportPhaseType=} phase
+ * @property {string[]=} patterns glob patterns for import.meta.glob
+ * @property {string=} requestContext importer context for import.meta.glob
+ * @property {string=} importName import selection for import.meta.glob
+ * @property {boolean=} exhaustive exhaustive mode for import.meta.glob
+ * @property {boolean=} caseSensitive case-sensitive matching for import.meta.glob
  */
 
 /**
@@ -121,6 +128,14 @@ const makeSerializable = require("./util/makeSerializable");
 /** @typedef {Record<string, ModuleId>} UserRequestMap */
 /** @typedef {Record<ModuleId, ModuleId[]>} UserRequestsMap */
 
+/**
+ * Defines the build info properties specific to context modules.
+ * @typedef {object} KnownContextModuleBuildInfo
+ * @property {(Snapshot | null)=} snapshot
+ */
+
+/** @typedef {BuildInfo & KnownContextModuleBuildInfo} ContextModuleBuildInfo */
+
 class ContextModule extends Module {
 	/**
 	 * @param {ResolveDependencies} resolveDependencies function to get dependencies in this context
@@ -156,10 +171,15 @@ class ContextModule extends Module {
 			};
 		}
 
+		// Redeclared with the context module specific shape
+		/** @type {ContextModuleBuildInfo | undefined} */
+		this.buildInfo = undefined;
+
 		// Info from Factory
 		/** @type {ResolveDependencies | undefined} */
 		this.resolveDependencies = resolveDependencies;
 		if (options && options.resolveOptions !== undefined) {
+			/** @type {ResolveOptions | undefined} */
 			this.resolveOptions = options.resolveOptions;
 		}
 
@@ -167,11 +187,14 @@ class ContextModule extends Module {
 			throw new Error("options.mode is a required option");
 		}
 
+		/** @type {string} */
 		this._identifier = this._createIdentifier();
+		/** @type {boolean} */
 		this._forceBuild = true;
 	}
 
 	/**
+	 * Returns the source types this module can generate.
 	 * @returns {SourceTypes} types available (do not mutate)
 	 */
 	getSourceTypes() {
@@ -209,7 +232,14 @@ class ContextModule extends Module {
 		const str = stripSlash
 			? regexString.source + regexString.flags
 			: `${regexString}`;
-		return str.replace(/!/g, "%21").replace(/\|/g, "%7C");
+		// Escape chars that are structural in the identifier/source-name URL
+		// (`!`/`|` separators, `?` query, `#` fragment) so a regex like
+		// `(?:a|b)` isn't misread and truncated when it becomes a source name.
+		return str
+			.replace(/!/g, "%21")
+			.replace(/\|/g, "%7C")
+			.replace(/\?/g, "%3F")
+			.replace(/#/g, "%23");
 	}
 
 	_createIdentifier() {
@@ -236,6 +266,11 @@ class ContextModule extends Module {
 		}
 		if (this.options.regExp) {
 			identifier += `|${this._prettyRegExp(this.options.regExp, false)}`;
+		} else if (this.options.patterns) {
+			identifier += `|patterns: ${this.options.patterns.join(", ")}`;
+		}
+		if (this.options.requestContext) {
+			identifier += `|requestContext: ${this.options.requestContext}`;
 		}
 		if (this.options.include) {
 			identifier += `|include: ${this._prettyRegExp(
@@ -254,6 +289,15 @@ class ContextModule extends Module {
 				this.options.referencedExports
 			)}`;
 		}
+		if (this.options.importName) {
+			identifier += `|import: ${this.options.importName}`;
+		}
+		if (this.options.exhaustive) {
+			identifier += "|exhaustive";
+		}
+		if (this.options.caseSensitive === false) {
+			identifier += "|case-insensitive";
+		}
 		if (this.options.chunkName) {
 			identifier += `|chunkName: ${this.options.chunkName}`;
 		}
@@ -280,6 +324,7 @@ class ContextModule extends Module {
 	}
 
 	/**
+	 * Returns the unique identifier used to reference this module.
 	 * @returns {string} a unique identifier of the module
 	 */
 	identifier() {
@@ -287,6 +332,7 @@ class ContextModule extends Module {
 	}
 
 	/**
+	 * Returns a human-readable identifier for this module.
 	 * @param {RequestShortener} requestShortener the request shortener
 	 * @returns {string} a user readable identifier of the module
 	 */
@@ -320,6 +366,17 @@ class ContextModule extends Module {
 		}
 		if (this.options.regExp) {
 			identifier += ` ${this._prettyRegExp(this.options.regExp)}`;
+		} else if (this.options.patterns) {
+			identifier += ` patterns: ${this.options.patterns.join(", ")}`;
+		}
+		if (this.options.requestContext) {
+			identifier += ` requestContext: ${this.options.requestContext}`;
+		}
+		if (this.options.exhaustive) {
+			identifier += " exhaustive";
+		}
+		if (this.options.caseSensitive === false) {
+			identifier += " case-insensitive";
 		}
 		if (this.options.include) {
 			identifier += ` include: ${this._prettyRegExp(this.options.include)}`;
@@ -353,6 +410,7 @@ class ContextModule extends Module {
 	}
 
 	/**
+	 * Gets the library identifier.
 	 * @param {LibIdentOptions} options options
 	 * @returns {LibIdent | null} an identifier for library inclusion
 	 */
@@ -398,6 +456,17 @@ class ContextModule extends Module {
 		}
 		if (this.options.regExp) {
 			identifier += ` ${this._prettyRegExp(this.options.regExp)}`;
+		} else if (this.options.patterns) {
+			identifier += ` patterns: ${this.options.patterns.join(", ")}`;
+		}
+		if (this.options.requestContext) {
+			identifier += ` requestContext: ${this.options.requestContext}`;
+		}
+		if (this.options.exhaustive) {
+			identifier += " exhaustive";
+		}
+		if (this.options.caseSensitive === false) {
+			identifier += " case-insensitive";
 		}
 		if (this.options.include) {
 			identifier += ` include: ${this._prettyRegExp(this.options.include)}`;
@@ -415,6 +484,7 @@ class ContextModule extends Module {
 	}
 
 	/**
+	 * Invalidates the cached state associated with this value.
 	 * @returns {void}
 	 */
 	invalidateBuild() {
@@ -422,6 +492,7 @@ class ContextModule extends Module {
 	}
 
 	/**
+	 * Checks whether the module needs to be rebuilt for the current build state.
 	 * @param {NeedBuildContext} context context info
 	 * @param {NeedBuildCallback} callback callback function, returns true, if the module needs a rebuild
 	 * @returns {void}
@@ -430,7 +501,7 @@ class ContextModule extends Module {
 		// build if enforced
 		if (this._forceBuild) return callback(null, true);
 
-		const buildInfo = /** @type {BuildInfo} */ (this.buildInfo);
+		const buildInfo = /** @type {ContextModuleBuildInfo} */ (this.buildInfo);
 
 		// always build when we have no snapshot and context
 		if (!buildInfo.snapshot) {
@@ -443,6 +514,7 @@ class ContextModule extends Module {
 	}
 
 	/**
+	 * Builds the module using the provided compilation context.
 	 * @param {WebpackOptions} options webpack options
 	 * @param {Compilation} compilation the compilation
 	 * @param {ResolverWithOptions} resolver the resolver
@@ -457,9 +529,18 @@ class ContextModule extends Module {
 			exportsType: "default",
 			defaultObject: "redirect-warn"
 		};
+
+		// Respect the global module parser `overrideStrict` option
+		const overrideStrict =
+			options.module.parser &&
+			options.module.parser.javascript &&
+			options.module.parser.javascript.overrideStrict;
+
 		this.buildInfo = {
+			strict: overrideStrict ? overrideStrict === "strict" : undefined,
 			snapshot: undefined
 		};
+
 		this.dependencies.length = 0;
 		this.blocks.length = 0;
 		const startTime = Date.now();
@@ -576,6 +657,7 @@ class ContextModule extends Module {
 	}
 
 	/**
+	 * Adds the provided file dependencies to the module.
 	 * @param {FileSystemDependencies} fileDependencies set where file dependencies are added to
 	 * @param {FileSystemDependencies} contextDependencies set where context dependencies are added to
 	 * @param {FileSystemDependencies} missingDependencies set where missing dependencies are added to
@@ -701,11 +783,13 @@ class ContextModule extends Module {
 
 	/**
 	 * @param {FakeMap | FakeMapType} fakeMap fake map
+	 * @param {RuntimeTemplate=} runtimeTemplate the runtime template
 	 * @returns {string} fake map init statement
 	 */
-	getFakeMapInitStatement(fakeMap) {
+	getFakeMapInitStatement(fakeMap, runtimeTemplate) {
+		const decl = runtimeTemplate ? runtimeTemplate.renderConst() : "var";
 		return typeof fakeMap === "object"
-			? `var fakeMap = ${JSON.stringify(fakeMap, null, "\t")};`
+			? `${decl} fakeMap = ${JSON.stringify(fakeMap, null, "\t")};`
 			: "";
 	}
 
@@ -743,11 +827,13 @@ class ContextModule extends Module {
 
 	/**
 	 * @param {false | UserRequestsMap} asyncDepsMap fake map
+	 * @param {RuntimeTemplate=} runtimeTemplate the runtime template
 	 * @returns {string} async deps map init statement
 	 */
-	getModuleDeferredAsyncDepsMapInitStatement(asyncDepsMap) {
+	getModuleDeferredAsyncDepsMapInitStatement(asyncDepsMap, runtimeTemplate) {
+		const decl = runtimeTemplate ? runtimeTemplate.renderConst() : "var";
 		return typeof asyncDepsMap === "object"
-			? `var asyncDepsMap = ${JSON.stringify(asyncDepsMap, null, "\t")};`
+			? `${decl} asyncDepsMap = ${JSON.stringify(asyncDepsMap, null, "\t")};`
 			: "";
 	}
 
@@ -797,23 +883,25 @@ class ContextModule extends Module {
 	 * @param {Dependency[]} dependencies dependencies
 	 * @param {ModuleId} id module id
 	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @param {RuntimeTemplate=} runtimeTemplate the runtime template
 	 * @returns {string} source code
 	 */
-	getSyncSource(dependencies, id, chunkGraph) {
+	getSyncSource(dependencies, id, chunkGraph, runtimeTemplate) {
 		const map = this.getUserRequestMap(dependencies, chunkGraph);
 		const fakeMap = this.getFakeMap(dependencies, chunkGraph);
 		const returnModuleObject = this.getReturnModuleObjectSource(fakeMap);
+		const cst = runtimeTemplate ? runtimeTemplate.renderConst() : "var";
 
-		return `var map = ${JSON.stringify(map, null, "\t")};
-${this.getFakeMapInitStatement(fakeMap)}
+		return `${cst} map = ${JSON.stringify(map, null, "\t")};
+${this.getFakeMapInitStatement(fakeMap, runtimeTemplate)}
 
 function webpackContext(req) {
-	var id = webpackContextResolve(req);
+	${cst} id = webpackContextResolve(req);
 	return ${returnModuleObject};
 }
 function webpackContextResolve(req) {
 	if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
-		var e = new Error("Cannot find module '" + req + "'");
+		${cst} e = new Error("Cannot find module '" + req + "'");
 		e.code = 'MODULE_NOT_FOUND';
 		throw e;
 	}
@@ -831,20 +919,22 @@ webpackContext.id = ${JSON.stringify(id)};`;
 	 * @param {Dependency[]} dependencies dependencies
 	 * @param {ModuleId} id module id
 	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @param {RuntimeTemplate=} runtimeTemplate the runtime template
 	 * @returns {string} source code
 	 */
-	getWeakSyncSource(dependencies, id, chunkGraph) {
+	getWeakSyncSource(dependencies, id, chunkGraph, runtimeTemplate) {
 		const map = this.getUserRequestMap(dependencies, chunkGraph);
 		const fakeMap = this.getFakeMap(dependencies, chunkGraph);
 		const returnModuleObject = this.getReturnModuleObjectSource(fakeMap);
+		const cst = runtimeTemplate ? runtimeTemplate.renderConst() : "var";
 
-		return `var map = ${JSON.stringify(map, null, "\t")};
-${this.getFakeMapInitStatement(fakeMap)}
+		return `${cst} map = ${JSON.stringify(map, null, "\t")};
+${this.getFakeMapInitStatement(fakeMap, runtimeTemplate)}
 
 function webpackContext(req) {
-	var id = webpackContextResolve(req);
+	${cst} id = webpackContextResolve(req);
 	if(!${RuntimeGlobals.moduleFactories}[id]) {
-		var e = new Error("Module '" + req + "' ('" + id + "') is not available (weak dependency)");
+		${cst} e = new Error("Module '" + req + "' ('" + id + "') is not available (weak dependency)");
 		e.code = 'MODULE_NOT_FOUND';
 		throw e;
 	}
@@ -852,7 +942,7 @@ function webpackContext(req) {
 }
 function webpackContextResolve(req) {
 	if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
-		var e = new Error("Cannot find module '" + req + "'");
+		${cst} e = new Error("Cannot find module '" + req + "'");
 		e.code = 'MODULE_NOT_FOUND';
 		throw e;
 	}
@@ -886,10 +976,11 @@ module.exports = webpackContext;`;
 			true,
 			asyncDepsMap ? "asyncDepsMap[id]" : undefined
 		);
+		const cst = runtimeTemplate.renderConst();
 
-		return `var map = ${JSON.stringify(map, null, "\t")};
-${this.getFakeMapInitStatement(fakeMap)}
-${this.getModuleDeferredAsyncDepsMapInitStatement(asyncDepsMap)}
+		return `${cst} map = ${JSON.stringify(map, null, "\t")};
+${this.getFakeMapInitStatement(fakeMap, runtimeTemplate)}
+${this.getModuleDeferredAsyncDepsMapInitStatement(asyncDepsMap, runtimeTemplate)}
 
 function webpackAsyncContext(req) {
 	return webpackAsyncContextResolve(req).then(${runtimeTemplate.basicFunction(
@@ -897,7 +988,7 @@ function webpackAsyncContext(req) {
 		[
 			`if(!${RuntimeGlobals.moduleFactories}[id]) {`,
 			Template.indent([
-				'var e = new Error("Module \'" + req + "\' (\'" + id + "\') is not available (weak dependency)");',
+				`${cst} e = new Error("Module '" + req + "' ('" + id + "') is not available (weak dependency)");`,
 				"e.code = 'MODULE_NOT_FOUND';",
 				"throw e;"
 			]),
@@ -912,7 +1003,7 @@ function webpackAsyncContextResolve(req) {
 	return Promise.resolve().then(${runtimeTemplate.basicFunction("", [
 		`if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {`,
 		Template.indent([
-			'var e = new Error("Cannot find module \'" + req + "\'");',
+			`${cst} e = new Error("Cannot find module '" + req + "'");`,
 			"e.code = 'MODULE_NOT_FOUND';",
 			"throw e;"
 		]),
@@ -952,9 +1043,10 @@ module.exports = webpackAsyncContext;`;
 			"id"
 		);
 
-		return `var map = ${JSON.stringify(map, null, "\t")};
-${this.getFakeMapInitStatement(fakeMap)}
-${this.getModuleDeferredAsyncDepsMapInitStatement(asyncDepsMap)}
+		const cst = runtimeTemplate.renderConst();
+		return `${cst} map = ${JSON.stringify(map, null, "\t")};
+${this.getFakeMapInitStatement(fakeMap, runtimeTemplate)}
+${this.getModuleDeferredAsyncDepsMapInitStatement(asyncDepsMap, runtimeTemplate)}
 
 function webpackAsyncContext(req) {
 	return webpackAsyncContextResolve(req).then(${thenFunction});
@@ -965,7 +1057,7 @@ function webpackAsyncContextResolve(req) {
 	return Promise.resolve().then(${runtimeTemplate.basicFunction("", [
 		`if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {`,
 		Template.indent([
-			'var e = new Error("Cannot find module \'" + req + "\'");',
+			`${cst} e = new Error("Cannot find module '" + req + "'");`,
 			"e.code = 'MODULE_NOT_FOUND';",
 			"throw e;"
 		]),
@@ -1019,9 +1111,10 @@ module.exports = webpackAsyncContext;`;
 			"id"
 		);
 
-		return `var map = ${JSON.stringify(map, null, "\t")};
-${this.getFakeMapInitStatement(fakeMap)}
-${this.getModuleDeferredAsyncDepsMapInitStatement(asyncDepsMap)}
+		const cst = runtimeTemplate.renderConst();
+		return `${cst} map = ${JSON.stringify(map, null, "\t")};
+${this.getFakeMapInitStatement(fakeMap, runtimeTemplate)}
+${this.getModuleDeferredAsyncDepsMapInitStatement(asyncDepsMap, runtimeTemplate)}
 
 function webpackAsyncContext(req) {
 	return webpackAsyncContextResolve(req).then(${thenFunction});
@@ -1030,7 +1123,7 @@ function webpackAsyncContextResolve(req) {
 	return ${promise}.then(${runtimeTemplate.basicFunction("", [
 		`if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {`,
 		Template.indent([
-			'var e = new Error("Cannot find module \'" + req + "\'");',
+			`${cst} e = new Error("Cannot find module '" + req + "'");`,
 			"e.code = 'MODULE_NOT_FOUND';",
 			"throw e;"
 		]),
@@ -1140,7 +1233,8 @@ module.exports = webpackAsyncContext;`;
 		}
 
 		const chunksPosition = hasFakeMap ? 2 : 1;
-		const asyncDepsPosition = chunksPosition + 1;
+		// No chunks slot is pushed when `hasNoChunk`, so `asyncDeps` sits at `chunksPosition`.
+		const asyncDepsPosition = hasNoChunk ? chunksPosition : chunksPosition + 1;
 		const requestPrefix = hasNoChunk
 			? "Promise.resolve()"
 			: hasMultipleOrNoChunks
@@ -1153,6 +1247,7 @@ module.exports = webpackAsyncContext;`;
 			shortMode ? "invalid" : "ids[1]"
 		);
 
+		const cst = runtimeTemplate.renderConst();
 		const webpackAsyncContext =
 			requestPrefix === "Promise.resolve()"
 				? `
@@ -1160,12 +1255,12 @@ function webpackAsyncContext(req) {
 	return Promise.resolve().then(${runtimeTemplate.basicFunction("", [
 		`if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {`,
 		Template.indent([
-			'var e = new Error("Cannot find module \'" + req + "\'");',
+			`${cst} e = new Error("Cannot find module '" + req + "'");`,
 			"e.code = 'MODULE_NOT_FOUND';",
 			"throw e;"
 		]),
 		"}",
-		shortMode ? "var id = map[req];" : "var ids = map[req], id = ids[0];",
+		shortMode ? `${cst} id = map[req];` : `${cst} ids = map[req], id = ids[0];`,
 		`return ${returnModuleObject};`
 	])});
 }`
@@ -1173,7 +1268,7 @@ function webpackAsyncContext(req) {
 	try {
 		if(!${RuntimeGlobals.hasOwnProperty}(map, req)) {
 			return Promise.resolve().then(${runtimeTemplate.basicFunction("", [
-				'var e = new Error("Cannot find module \'" + req + "\'");',
+				`${cst} e = new Error("Cannot find module '" + req + "'");`,
 				"e.code = 'MODULE_NOT_FOUND';",
 				"throw e;"
 			])});
@@ -1182,11 +1277,11 @@ function webpackAsyncContext(req) {
 		return Promise.reject(err);
 	}
 
-	var ids = map[req], id = ids[0];
+	${cst} ids = map[req], id = ids[0];
 	return ${requestPrefix}.then(${runtimeTemplate.returningFunction(returnModuleObject)});
 }`;
 
-		return `var map = ${JSON.stringify(map, null, "\t")};
+		return `${cst} map = ${JSON.stringify(map, null, "\t")};
 ${webpackAsyncContext}
 webpackAsyncContext.keys = ${runtimeTemplate.returningFunction(
 			"Object.keys(map)"
@@ -1202,7 +1297,7 @@ module.exports = webpackAsyncContext;`;
 	 */
 	getSourceForEmptyContext(id, runtimeTemplate) {
 		return `function webpackEmptyContext(req) {
-	var e = new Error("Cannot find module '" + req + "'");
+	${runtimeTemplate.renderConst()} e = new Error("Cannot find module '" + req + "'");
 	e.code = 'MODULE_NOT_FOUND';
 	throw e;
 }
@@ -1222,7 +1317,7 @@ module.exports = webpackEmptyContext;`;
 	// Here Promise.resolve().then() is used instead of new Promise() to prevent
 	// uncaught exception popping up in devtools
 	return Promise.resolve().then(${runtimeTemplate.basicFunction("", [
-		'var e = new Error("Cannot find module \'" + req + "\'");',
+		`${runtimeTemplate.renderConst()} e = new Error("Cannot find module '" + req + "'");`,
 		"e.code = 'MODULE_NOT_FOUND';",
 		"throw e;"
 	])});
@@ -1233,13 +1328,196 @@ webpackEmptyAsyncContext.id = ${JSON.stringify(id)};
 module.exports = webpackEmptyAsyncContext;`;
 	}
 
+	/**
+	 * @returns {string | undefined} import property access
+	 */
+	getImportPropertyAccess() {
+		const importName = this.options.importName;
+		if (!importName || importName === "*") return;
+		return propertyAccess([importName]);
+	}
+
+	/**
+	 * @param {number} index index
+	 * @param {string} userRequest user request
+	 * @param {string} value value expression
+	 * @param {string[]} entries entries
+	 * @returns {void}
+	 */
+	appendGlobMapEntry(index, userRequest, value, entries) {
+		entries.push(`\n  ${JSON.stringify(userRequest)}: ${value}`);
+	}
+
+	/**
+	 * @param {string} entries entries
+	 * @returns {string} object export source
+	 */
+	getGlobObjectExportSource(entries) {
+		return `\nmodule.exports = {${entries}\n};\n`;
+	}
+
+	/**
+	 * @returns {string} empty object export source
+	 */
+	getEmptyObjectExportSource() {
+		return "\nmodule.exports = {};\n";
+	}
+
+	/**
+	 * @param {AsyncDependenciesBlock[]} blocks blocks
+	 * @param {ImportPhaseType} phase import phase
+	 * @param {object} context context
+	 * @param {RuntimeTemplate} context.runtimeTemplate runtime template
+	 * @param {ChunkGraph} context.chunkGraph chunk graph
+	 * @param {RuntimeRequirements=} context.runtimeRequirements runtime requirements
+	 * @returns {string} glob lazy source
+	 */
+	getGlobLazySource(
+		blocks,
+		phase,
+		{ runtimeTemplate, chunkGraph, runtimeRequirements }
+	) {
+		if (!blocks || blocks.length === 0) {
+			return this.getEmptyObjectExportSource();
+		}
+		const moduleGraph = chunkGraph.moduleGraph;
+		const globImportAccess = this.getImportPropertyAccess();
+		/** @type {RuntimeRequirements} */
+		const localRuntimeRequirements = runtimeRequirements || new Set();
+		/** @type {{ userRequest: string, block: AsyncDependenciesBlock, dependency: ContextElementDependency }[]} */
+		const blockInfo = blocks
+			.map((block) => {
+				const dependency =
+					/** @type {ContextElementDependency} */
+					(block.dependencies[0]);
+				return {
+					userRequest: dependency.userRequest,
+					block,
+					dependency
+				};
+			})
+			.sort((a, b) =>
+				a.userRequest < b.userRequest
+					? -1
+					: a.userRequest > b.userRequest
+						? 1
+						: 0
+			);
+		/** @type {string[]} */
+		const entries = [];
+		for (let i = 0; i < blockInfo.length; i++) {
+			const info = blockInfo[i];
+			let importPromise = runtimeTemplate.moduleNamespacePromise({
+				chunkGraph,
+				block: info.block,
+				module: /** @type {Module} */ (moduleGraph.getModule(info.dependency)),
+				request: info.userRequest,
+				message: "import.meta.glob",
+				strict: this.options.namespaceObject === "strict",
+				dependency: info.dependency,
+				runtimeRequirements: localRuntimeRequirements
+			});
+			if (globImportAccess) {
+				importPromise = `${importPromise}.then(function(m) { return m${globImportAccess}; })`;
+			}
+			this.appendGlobMapEntry(
+				i,
+				info.userRequest,
+				`function() { return ${importPromise}; }`,
+				entries
+			);
+		}
+		return this.getGlobObjectExportSource(entries.join(","));
+	}
+
+	/**
+	 * @param {Dependency[]} dependencies dependencies
+	 * @param {ChunkGraph} chunkGraph chunk graph
+	 * @param {RuntimeTemplate} runtimeTemplate runtime template
+	 * @returns {string} glob sync source
+	 */
+	getGlobSyncSource(dependencies, chunkGraph, runtimeTemplate) {
+		if (!dependencies || dependencies.length === 0) {
+			return this.getEmptyObjectExportSource();
+		}
+		const moduleGraph = chunkGraph.moduleGraph;
+		const fakeMap = this.getFakeMap(dependencies, chunkGraph);
+		const returnModuleObject = this.getReturnModuleObjectSource(fakeMap);
+		const globImportAccess = this.getImportPropertyAccess();
+		const sortedDependencies =
+			/** @type {import("./dependencies/ContextElementDependency")[]} */
+			(dependencies).sort((a, b) =>
+				a.userRequest < b.userRequest
+					? -1
+					: a.userRequest > b.userRequest
+						? 1
+						: 0
+			);
+		/** @type {string[]} */
+		const entries = [];
+		let index = 0;
+		for (const dep of sortedDependencies) {
+			const module = moduleGraph.getModule(dep);
+			let moduleExpr;
+			if (module) {
+				const moduleId = chunkGraph.getModuleId(module);
+				moduleExpr = `(function() { var id = ${JSON.stringify(moduleId)}; return ${returnModuleObject}; })()`;
+				if (globImportAccess) {
+					moduleExpr += globImportAccess;
+				}
+			} else {
+				moduleExpr = `undefined /* ${JSON.stringify(dep.userRequest)} */`;
+			}
+			this.appendGlobMapEntry(index++, dep.userRequest, moduleExpr, entries);
+		}
+		const fakeMapInit = this.getFakeMapInitStatement(fakeMap, runtimeTemplate);
+		return `${fakeMapInit}\n${this.getGlobObjectExportSource(entries.join(","))}`;
+	}
+
 	/**
 	 * @param {string} asyncMode module mode
 	 * @param {ImportPhaseType} phase import phase
 	 * @param {CodeGenerationContext} context context info
 	 * @returns {string} the source code
 	 */
-	getSourceString(asyncMode, phase, { runtimeTemplate, chunkGraph }) {
+	getGlobSourceString(asyncMode, phase, context) {
+		if (asyncMode === "lazy") {
+			if (this.blocks && this.blocks.length > 0) {
+				return this.getGlobLazySource(this.blocks, phase, context);
+			}
+			return this.getEmptyObjectExportSource();
+		}
+		if (this.dependencies && this.dependencies.length > 0) {
+			return this.getGlobSyncSource(
+				this.dependencies,
+				context.chunkGraph,
+				context.runtimeTemplate
+			);
+		}
+		return this.getEmptyObjectExportSource();
+	}
+
+	/**
+	 * @param {string} asyncMode module mode
+	 * @param {ImportPhaseType} phase import phase
+	 * @param {CodeGenerationContext & { runtimeRequirements?: RuntimeRequirements }} context context info
+	 * @returns {string} the source code
+	 */
+	getSourceString(asyncMode, phase, context) {
+		if (this.options.patterns) {
+			return this.getGlobSourceString(asyncMode, phase, context);
+		}
+		return this.getContextSourceString(asyncMode, phase, context);
+	}
+
+	/**
+	 * @param {string} asyncMode module mode
+	 * @param {ImportPhaseType} phase import phase
+	 * @param {CodeGenerationContext & { runtimeRequirements?: RuntimeRequirements }} context context info
+	 * @returns {string} the source code
+	 */
+	getContextSourceString(asyncMode, phase, context) {
+		const { runtimeTemplate, chunkGraph } = context;
 		const id = /** @type {ModuleId} */ (chunkGraph.getModuleId(this));
 		if (asyncMode === "lazy") {
 			if (this.blocks && this.blocks.length > 0) {
@@ -1283,10 +1561,20 @@ module.exports = webpackEmptyAsyncContext;`;
 			this.dependencies &&
 			this.dependencies.length > 0
 		) {
-			return this.getWeakSyncSource(this.dependencies, id, chunkGraph);
+			return this.getWeakSyncSource(
+				this.dependencies,
+				id,
+				chunkGraph,
+				runtimeTemplate
+			);
 		}
 		if (this.dependencies && this.dependencies.length > 0) {
-			return this.getSyncSource(this.dependencies, id, chunkGraph);
+			return this.getSyncSource(
+				this.dependencies,
+				id,
+				chunkGraph,
+				runtimeTemplate
+			);
 		}
 		return this.getSourceForEmptyContext(id, runtimeTemplate);
 	}
@@ -1311,12 +1599,15 @@ module.exports = webpackEmptyAsyncContext;`;
 	}
 
 	/**
+	 * Generates code and runtime requirements for this module.
 	 * @param {CodeGenerationContext} context context for code generation
 	 * @returns {CodeGenerationResult} result
 	 */
 	codeGeneration(context) {
 		const { chunkGraph, compilation } = context;
 
+		/** @type {RuntimeRequirements} */
+		const set = new Set();
 		/** @type {Sources} */
 		const sources = new Map();
 		sources.set(
@@ -1325,13 +1616,11 @@ module.exports = webpackEmptyAsyncContext;`;
 				this.getSourceString(
 					this.options.mode,
 					this.options.phase || ImportPhase.Evaluation,
-					context
+					{ ...context, runtimeRequirements: set }
 				),
 				compilation
 			)
 		);
-		/** @type {RuntimeRequirements} */
-		const set = new Set();
 		const allDeps =
 			this.dependencies.length > 0
 				? /** @type {ContextElementDependency[]} */ [...this.dependencies]
@@ -1370,6 +1659,7 @@ module.exports = webpackEmptyAsyncContext;`;
 	}
 
 	/**
+	 * Returns the estimated size for the requested source type.
 	 * @param {string=} type the source type for which the size should be estimated
 	 * @returns {number} the estimated size of the module (must be non-zero)
 	 */
@@ -1386,23 +1676,23 @@ module.exports = webpackEmptyAsyncContext;`;
 	}
 
 	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
-		const { write } = context;
-		write(this._identifier);
-		write(this._forceBuild);
+		context.write(this._identifier).write(this._forceBuild);
 		super.serialize(context);
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
-		const { read } = context;
-		this._identifier = read();
-		this._forceBuild = read();
-		super.deserialize(context);
+		this._identifier = context.read();
+		const c1 = context.rest;
+		this._forceBuild = c1.read();
+		super.deserialize(c1.rest);
 	}
 }