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

package/lib/dependencies/ImportDependency.js

@@ -6,12 +6,15 @@
 "use strict";
 
 const Dependency = require("../Dependency");
+const Template = require("../Template");
 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,10 +26,14 @@ 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.
 	 * @param {string} request the request
 	 * @param {Range} range expression range
 	 * @param {RawReferencedExports | null} referencedExports list of referenced exports
@@ -36,9 +43,19 @@ 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;
+		// Range of the `import(specifier, options)` second argument, set only when
+		// it is not a statically extractable attributes object and must therefore
+		// be evaluated and validated at runtime.
+		/** @type {Range | undefined} */
+		this.optionsRange = undefined;
 	}
 
 	get type() {
@@ -50,6 +67,19 @@ class ImportDependency extends ModuleDependency {
 	}
 
 	/**
+	 * 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
 	 */
 	getResourceIdentifier() {
@@ -96,13 +126,15 @@ class ImportDependency extends ModuleDependency {
 			}
 			refs.push({
 				name: referencedExport,
-				canMangle: false
+				canMangle: false,
+				canInline: false
 			});
 		}
 		return refs;
 	}
 
 	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
@@ -110,10 +142,13 @@ class ImportDependency extends ModuleDependency {
 		context.write(this.referencedExports);
 		context.write(this.phase);
 		context.write(this.attributes);
+		context.write(this.branchGuards);
+		context.write(this.optionsRange);
 		super.serialize(context);
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
@@ -121,6 +156,8 @@ class ImportDependency extends ModuleDependency {
 		this.referencedExports = context.read();
 		this.phase = context.read();
 		this.attributes = context.read();
+		this.branchGuards = context.read();
+		this.optionsRange = context.read();
 		super.deserialize(context);
 	}
 }
@@ -131,6 +168,7 @@ ImportDependency.Template = class ImportDependencyTemplate extends (
 	ModuleDependency.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
@@ -139,9 +177,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)
 		);
@@ -153,7 +208,8 @@ ImportDependency.Template = class ImportDependencyTemplate extends (
 			strict: /** @type {BuildMeta} */ (module.buildMeta).strictHarmonyModule,
 			dependency: dep,
 			message: "import()",
-			runtimeRequirements
+			runtimeRequirements,
+			originModule: module
 		});
 
 		// For source phase imports, unwrap the default export
@@ -165,6 +221,39 @@ 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.
+		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, ")");
+			return;
+		}
+
 		source.replace(dep.range[0], dep.range[1] - 1, content);
 	}
 };

package/lib/dependencies/ImportEagerDependency.js

@@ -20,6 +20,7 @@ const ImportDependency = require("./ImportDependency");
 
 class ImportEagerDependency extends ImportDependency {
 	/**
+	 * Creates an instance of ImportEagerDependency.
 	 * @param {string} request the request
 	 * @param {Range} range expression range
 	 * @param {RawReferencedExports | null} referencedExports list of referenced exports
@@ -48,6 +49,7 @@ ImportEagerDependency.Template = class ImportEagerDependencyTemplate extends (
 	ImportDependency.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

package/lib/dependencies/ImportMetaContextDependency.js

@@ -14,6 +14,7 @@ const ModuleDependencyTemplateAsRequireId = require("./ModuleDependencyTemplateA
 
 class ImportMetaContextDependency extends ContextDependency {
 	/**
+	 * Creates an instance of ImportMetaContextDependency.
 	 * @param {ContextDependencyOptions} options options
 	 * @param {Range} range range
 	 */

package/lib/dependencies/ImportMetaContextDependencyParserPlugin.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const WebpackError = require("../WebpackError");
+const WebpackError = require("../errors/WebpackError");
 const {
 	evaluateToIdentifier
 } = require("../javascript/JavascriptParserHelpers");
@@ -28,22 +28,24 @@ const ImportMetaContextDependency = require("./ImportMetaContextDependency");
 /** @typedef {Pick<ContextModuleOptions, "mode" | "recursive" | "regExp" | "include" | "exclude" | "chunkName"> & { groupOptions: RawChunkGroupOptions, exports?: RawReferencedExports }} ImportMetaContextOptions */
 
 /**
+ * Creates a property parse error.
+ * @param {JavascriptParser} parser the parser
  * @param {Property} prop property
  * @param {string} expect except message
  * @returns {WebpackError} error
  */
-function createPropertyParseError(prop, expect) {
+function createPropertyParseError(parser, prop, expect) {
 	return createError(
 		`Parsing import.meta.webpackContext options failed. Unknown value for property ${JSON.stringify(
 			/** @type {Identifier} */
 			(prop.key).name
 		)}, expected type ${expect}.`,
-		/** @type {DependencyLocation} */
-		(prop.value.loc)
+		parser.getLocation(prop.value)
 	);
 }
 
 /**
+ * Creates an error from the provided msg.
  * @param {string} msg message
  * @param {DependencyLocation} loc location
  * @returns {WebpackError} error
@@ -59,6 +61,7 @@ const PLUGIN_NAME = "ImportMetaContextDependencyParserPlugin";
 
 module.exports = class ImportMetaContextDependencyParserPlugin {
 	/**
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {JavascriptParser} parser the parser
 	 * @returns {void}
 	 */
@@ -107,8 +110,7 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 							errors.push(
 								createError(
 									"Parsing import.meta.webpackContext options failed.",
-									/** @type {DependencyLocation} */
-									(optionsNode.loc)
+									parser.getLocation(optionsNode)
 								)
 							);
 							break;
@@ -119,7 +121,7 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 									/** @type {Expression} */ (prop.value)
 								);
 								if (!regExpExpr.isRegExp()) {
-									errors.push(createPropertyParseError(prop, "RegExp"));
+									errors.push(createPropertyParseError(parser, prop, "RegExp"));
 								} else {
 									regExp = /** @type {RegExp} */ (regExpExpr.regExp);
 								}
@@ -130,7 +132,7 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 									/** @type {Expression} */ (prop.value)
 								);
 								if (!regExpExpr.isRegExp()) {
-									errors.push(createPropertyParseError(prop, "RegExp"));
+									errors.push(createPropertyParseError(parser, prop, "RegExp"));
 								} else {
 									include = regExpExpr.regExp;
 								}
@@ -141,7 +143,7 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 									/** @type {Expression} */ (prop.value)
 								);
 								if (!regExpExpr.isRegExp()) {
-									errors.push(createPropertyParseError(prop, "RegExp"));
+									errors.push(createPropertyParseError(parser, prop, "RegExp"));
 								} else {
 									exclude = regExpExpr.regExp;
 								}
@@ -152,7 +154,7 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 									/** @type {Expression} */ (prop.value)
 								);
 								if (!modeExpr.isString()) {
-									errors.push(createPropertyParseError(prop, "string"));
+									errors.push(createPropertyParseError(parser, prop, "string"));
 								} else {
 									mode = /** @type {ContextModuleOptions["mode"]} */ (
 										modeExpr.string
@@ -165,7 +167,7 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 									/** @type {Expression} */ (prop.value)
 								);
 								if (!expr.isString()) {
-									errors.push(createPropertyParseError(prop, "string"));
+									errors.push(createPropertyParseError(parser, prop, "string"));
 								} else {
 									chunkName = expr.string;
 								}
@@ -203,12 +205,16 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 										}
 									} else {
 										errors.push(
-											createPropertyParseError(prop, "string|string[][]")
+											createPropertyParseError(
+												parser,
+												prop,
+												"string|string[][]"
+											)
 										);
 									}
 								} else {
 									errors.push(
-										createPropertyParseError(prop, "string|string[][]")
+										createPropertyParseError(parser, prop, "string|string[][]")
 									);
 								}
 								break;
@@ -222,7 +228,9 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 								} else if (expr.isNumber()) {
 									groupOptions.prefetchOrder = expr.number;
 								} else {
-									errors.push(createPropertyParseError(prop, "boolean|number"));
+									errors.push(
+										createPropertyParseError(parser, prop, "boolean|number")
+									);
 								}
 								break;
 							}
@@ -235,7 +243,9 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 								} else if (expr.isNumber()) {
 									groupOptions.preloadOrder = expr.number;
 								} else {
-									errors.push(createPropertyParseError(prop, "boolean|number"));
+									errors.push(
+										createPropertyParseError(parser, prop, "boolean|number")
+									);
 								}
 								break;
 							}
@@ -255,7 +265,11 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 										);
 								} else {
 									errors.push(
-										createPropertyParseError(prop, '"high"|"low"|"auto"')
+										createPropertyParseError(
+											parser,
+											prop,
+											'"high"|"low"|"auto"'
+										)
 									);
 								}
 								break;
@@ -265,7 +279,9 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 									/** @type {Expression} */ (prop.value)
 								);
 								if (!recursiveExpr.isBoolean()) {
-									errors.push(createPropertyParseError(prop, "boolean"));
+									errors.push(
+										createPropertyParseError(parser, prop, "boolean")
+									);
 								} else {
 									recursive = /** @type {boolean} */ (recursiveExpr.bool);
 								}
@@ -277,7 +293,7 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 										`Parsing import.meta.webpackContext options failed. Unknown property ${JSON.stringify(
 											prop.key.name
 										)}.`,
-										/** @type {DependencyLocation} */ (optionsNode.loc)
+										parser.getLocation(optionsNode)
 									)
 								);
 						}
@@ -303,7 +319,7 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 					},
 					/** @type {Range} */ (expr.range)
 				);
-				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				dep.loc = parser.getLocation(expr);
 				dep.optional = Boolean(parser.scope.inTry);
 				parser.state.current.addDependency(dep);
 				return true;

package/lib/dependencies/ImportMetaContextPlugin.js

@@ -12,6 +12,9 @@ const {
 const ContextElementDependency = require("./ContextElementDependency");
 const ImportMetaContextDependency = require("./ImportMetaContextDependency");
 const ImportMetaContextDependencyParserPlugin = require("./ImportMetaContextDependencyParserPlugin");
+const ImportMetaGlobDependency = require("./ImportMetaGlobDependency");
+const ImportMetaGlobDependencyParserPlugin = require("./ImportMetaGlobDependencyParserPlugin");
+const { isImportMetaFieldEnabled } = require("./ImportMetaPlugin");
 
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../Compiler")} Compiler */
@@ -19,9 +22,31 @@ const ImportMetaContextDependencyParserPlugin = require("./ImportMetaContextDepe
 
 const PLUGIN_NAME = "ImportMetaContextPlugin";
 
+/** @type {(parserOptions: JavascriptParserOptions) => boolean} */
+const isImportMetaContextEnabled = (parserOptions) => {
+	const importMeta = parserOptions.importMeta;
+	if (
+		Boolean(importMeta) &&
+		typeof importMeta === "object" &&
+		Object.prototype.hasOwnProperty.call(importMeta, "webpackContext")
+	) {
+		return isImportMetaFieldEnabled(importMeta, "webpackContext");
+	}
+	if (parserOptions.importMetaContext === false) {
+		return false;
+	}
+	return isImportMetaFieldEnabled(importMeta, "webpackContext");
+};
+
+// Gated only by the `importMeta.glob` field — independent of the legacy
+// `importMetaContext` toggle, which controls `import.meta.webpackContext`.
+/** @type {(parserOptions: JavascriptParserOptions) => boolean} */
+const isImportMetaGlobEnabled = (parserOptions) =>
+	isImportMetaFieldEnabled(parserOptions.importMeta, "glob");
+
 class ImportMetaContextPlugin {
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -37,25 +62,32 @@ class ImportMetaContextPlugin {
 					ImportMetaContextDependency,
 					new ImportMetaContextDependency.Template()
 				);
+				compilation.dependencyFactories.set(
+					ImportMetaGlobDependency,
+					contextModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					ImportMetaGlobDependency,
+					new ImportMetaGlobDependency.Template()
+				);
 				compilation.dependencyFactories.set(
 					ContextElementDependency,
 					normalModuleFactory
 				);
 
 				/**
+				 * Handles the hook callback for this code path.
 				 * @param {Parser} parser parser parser
 				 * @param {JavascriptParserOptions} parserOptions parserOptions
 				 * @returns {void}
 				 */
 				const handler = (parser, parserOptions) => {
-					if (
-						parserOptions.importMetaContext !== undefined &&
-						!parserOptions.importMetaContext
-					) {
-						return;
+					if (isImportMetaContextEnabled(parserOptions)) {
+						new ImportMetaContextDependencyParserPlugin().apply(parser);
+					}
+					if (isImportMetaGlobEnabled(parserOptions)) {
+						new ImportMetaGlobDependencyParserPlugin().apply(parser);
 					}
-
-					new ImportMetaContextDependencyParserPlugin().apply(parser);
 				};
 
 				normalModuleFactory.hooks.parser

package/lib/dependencies/ImportMetaGlobDependency.js

@@ -0,0 +1,81 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Natsu @xiaoxiaojx
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const ContextDependency = require("./ContextDependency");
+const ModuleDependencyTemplateAsRequireId = require("./ModuleDependencyTemplateAsRequireId");
+
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("./ContextDependency").ContextDependencyOptions} ContextDependencyOptions */
+
+/**
+ * @typedef {ContextDependencyOptions & {
+ * patterns: string[],
+ * requestContext: string,
+ * importName?: string,
+ * exhaustive?: boolean,
+ * caseSensitive?: boolean,
+ * }} ImportMetaGlobDependencyOptions
+ */
+
+class ImportMetaGlobDependency extends ContextDependency {
+	/**
+	 * @param {ImportMetaGlobDependencyOptions} options options
+	 * @param {Range} range range
+	 */
+	constructor(options, range) {
+		super(options, options ? options.requestContext : undefined);
+
+		this.range = range;
+	}
+
+	get category() {
+		return "esm";
+	}
+
+	get type() {
+		return `import.meta.glob ${this.options.mode}`;
+	}
+
+	/**
+	 * Returns an identifier to merge equal requests.
+	 * @returns {string | null} an identifier to merge equal requests
+	 */
+	getResourceIdentifier() {
+		const {
+			patterns,
+			request,
+			recursive,
+			mode,
+			exhaustive,
+			caseSensitive,
+			importName,
+			referencedExports
+		} = /** @type {ImportMetaGlobDependencyOptions} */ (this.options);
+		return (
+			`context${this.getContext() || ""}|glob request${request} ` +
+			`${recursive} ${patterns.join(",")} ` +
+			`${mode}${exhaustive ? " exhaustive" : ""}` +
+			`${caseSensitive === false ? " case-insensitive" : ""}` +
+			`${importName ? ` import:${importName}` : ""}` +
+			`${
+				referencedExports
+					? ` referencedExports:${JSON.stringify(referencedExports)}`
+					: ""
+			}`
+		);
+	}
+}
+
+makeSerializable(
+	ImportMetaGlobDependency,
+	"webpack/lib/dependencies/ImportMetaGlobDependency"
+);
+
+ImportMetaGlobDependency.Template = ModuleDependencyTemplateAsRequireId;
+
+module.exports = ImportMetaGlobDependency;

package/lib/dependencies/ImportMetaGlobDependencyParserPlugin.js

@@ -0,0 +1,78 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Natsu @xiaoxiaojx
+*/
+
+"use strict";
+
+const {
+	evaluateToIdentifier
+} = require("../javascript/JavascriptParserHelpers");
+const ImportMetaGlobDependency = require("./ImportMetaGlobDependency");
+const { parseImportMetaGlobCall } = require("./ImportMetaGlobHelpers");
+
+/** @typedef {import("estree").CallExpression} CallExpression */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+
+const PLUGIN_NAME = "ImportMetaGlobDependencyParserPlugin";
+
+module.exports = class ImportMetaGlobDependencyParserPlugin {
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
+	 * @param {JavascriptParser} parser the parser
+	 * @returns {void}
+	 */
+	apply(parser) {
+		parser.hooks.evaluateIdentifier
+			.for("import.meta.glob")
+			.tap(PLUGIN_NAME, (expr) =>
+				evaluateToIdentifier(
+					"import.meta.glob",
+					"import.meta",
+					() => ["glob"],
+					true
+				)(expr)
+			);
+		parser.hooks.call.for("import.meta.glob").tap(PLUGIN_NAME, (expr) => {
+			const {
+				options: globOptions,
+				errors,
+				warnings
+			} = parseImportMetaGlobCall(/** @type {CallExpression} */ (expr), parser);
+			for (const warning of warnings) {
+				parser.state.module.addWarning(warning);
+			}
+			if (errors.length) {
+				for (const error of errors) parser.state.current.addError(error);
+				return;
+			}
+			if (!globOptions) return;
+			const dep = new ImportMetaGlobDependency(
+				{
+					request: `${globOptions.baseDir}${globOptions.query}`,
+					recursive: globOptions.recursive,
+					regExp: false,
+					patterns: globOptions.patterns,
+					requestContext: globOptions.requestContext,
+					importName: globOptions.importName,
+					exhaustive: globOptions.exhaustive,
+					caseSensitive: globOptions.caseSensitive,
+					referencedExports: globOptions.referencedExports,
+					namespaceObject:
+						/** @type {import("../Module").BuildMeta} */
+						(parser.state.module.buildMeta).strictHarmonyModule
+							? "strict"
+							: true,
+					mode: globOptions.mode,
+					category: "esm"
+				},
+				globOptions.range
+			);
+			dep.loc = parser.getLocation(expr);
+			dep.optional = Boolean(parser.scope.inTry);
+			parser.state.current.addDependency(dep);
+			return true;
+		});
+	}
+};