webpack 5.106.2 → 5.107.1

package/lib/ids/IdHelpers.js

@@ -263,7 +263,8 @@ const getUsedModuleIdsAndModules = (compilation, filter) => {
 			(!filter || filter(module)) &&
 			(chunkGraph.getNumberOfModuleChunks(module) !== 0 ||
 				// CSS modules need IDs even when not in chunks, for generating CSS class names(i.e. [id]-[local])
-				/** @type {BuildMeta} */ (module.buildMeta).isCSSModule)
+				/** @type {BuildMeta} */ (module.buildMeta).isCssModule ||
+				/** @type {BuildMeta} */ (module.buildMeta).needIdInConcatenation)
 		) {
 			modules.push(module);
 		}

package/lib/index.js

@@ -41,6 +41,8 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./Compilation").AssetInfo} AssetInfo */
 /** @typedef {import("./Compilation").EntryOptions} EntryOptions */
 /** @typedef {import("./Compilation").PathData} PathData */
+/** @typedef {import("./Compilation").PathDataChunk} PathDataChunk */
+/** @typedef {import("./Compilation").PathDataModule} PathDataModule */
 /** @typedef {import("./CodeGenerationResults")} CodeGenerationResults */
 /** @typedef {import("./Entrypoint")} Entrypoint */
 /** @typedef {import("./ExternalModuleFactoryPlugin").ExternalItemFunctionCallback} ExternalItemFunctionCallback */
@@ -160,7 +162,9 @@ module.exports = mergeExports(fn, {
 			 */
 			() => {
 				const validateSchema = require("./validateSchema");
-				const webpackOptionsSchema = require("../schemas/WebpackOptions.json");
+				const webpackOptionsSchema =
+					/** @type {EXPECTED_ANY} */
+					(require("../schemas/WebpackOptions.json"));
 
 				return (options) => validateSchema(webpackOptionsSchema, options);
 			}
@@ -222,18 +226,9 @@ module.exports = mergeExports(fn, {
 	get DefinePlugin() {
 		return require("./DefinePlugin");
 	},
-	get DelegatedPlugin() {
-		return require("./DelegatedPlugin");
-	},
 	get Dependency() {
 		return require("./Dependency");
 	},
-	get DllPlugin() {
-		return require("./DllPlugin");
-	},
-	get DllReferencePlugin() {
-		return require("./DllReferencePlugin");
-	},
 	get DynamicEntryPlugin() {
 		return require("./DynamicEntryPlugin");
 	},
@@ -283,9 +278,6 @@ module.exports = mergeExports(fn, {
 			"DEP_WEBPACK_JAVASCRIPT_MODULES_PLUGIN"
 		)();
 	},
-	get LibManifestPlugin() {
-		return require("./LibManifestPlugin");
-	},
 	get LibraryTemplatePlugin() {
 		return util.deprecate(
 			() => require("./LibraryTemplatePlugin"),
@@ -376,7 +368,7 @@ module.exports = mergeExports(fn, {
 		return require("./WatchIgnorePlugin");
 	},
 	get WebpackError() {
-		return require("./WebpackError");
+		return require("./errors/WebpackError");
 	},
 	get WebpackOptionsApply() {
 		return require("./WebpackOptionsApply");
@@ -388,7 +380,7 @@ module.exports = mergeExports(fn, {
 			"DEP_WEBPACK_OPTIONS_DEFAULTER"
 		)();
 	},
-	// TODO webpack 6 deprecate
+	// TODO webpack 6 remove
 	get WebpackOptionsValidationError() {
 		return require("schema-utils").ValidationError;
 	},
@@ -604,6 +596,35 @@ module.exports = mergeExports(fn, {
 		}
 	},
 
+	// TODO remove in webpack 6 in favor of `dll` scope
+	get DelegatedPlugin() {
+		return require("./dll/DelegatedPlugin");
+	},
+	get DllPlugin() {
+		return require("./dll/DllPlugin");
+	},
+	get DllReferencePlugin() {
+		return require("./dll/DllReferencePlugin");
+	},
+	get LibManifestPlugin() {
+		return require("./dll/LibManifestPlugin");
+	},
+
+	dll: {
+		get DelegatedPlugin() {
+			return require("./dll/DelegatedPlugin");
+		},
+		get DllPlugin() {
+			return require("./dll/DllPlugin");
+		},
+		get DllReferencePlugin() {
+			return require("./dll/DllReferencePlugin");
+		},
+		get LibManifestPlugin() {
+			return require("./dll/LibManifestPlugin");
+		}
+	},
+
 	container: {
 		get ContainerPlugin() {
 			return require("./container/ContainerPlugin");

package/lib/javascript/JavascriptModulesPlugin.js

@@ -17,7 +17,6 @@ const {
 	ReplaceSource
 } = require("webpack-sources");
 const Compilation = require("../Compilation");
-const { tryRunOrWebpackError } = require("../HookWebpackError");
 const HotUpdateChunk = require("../HotUpdateChunk");
 const InitFragment = require("../InitFragment");
 const { JAVASCRIPT_TYPE } = require("../ModuleSourceTypeConstants");
@@ -30,6 +29,7 @@ const {
 const NormalModule = require("../NormalModule");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
+const { tryRunOrWebpackError } = require("../errors/HookWebpackError");
 const { last, someInIterable } = require("../util/IterableHelpers");
 const StringXor = require("../util/StringXor");
 const { compareModulesByFullName } = require("../util/comparators");
@@ -48,10 +48,24 @@ const { intersectRuntime } = require("../util/runtime");
 const JavascriptGenerator = require("./JavascriptGenerator");
 const JavascriptParser = require("./JavascriptParser");
 
-/** @typedef {import("eslint-scope").Reference} Reference */
-/** @typedef {import("eslint-scope").Scope} Scope */
-/** @typedef {import("eslint-scope").Variable} Variable */
 /** @typedef {import("estree").Program} Program */
+/** @typedef {import("estree").Node} Node */
+/** @typedef {import("estree").Identifier} Identifier */
+/** @typedef {import("estree").CatchClause} CatchClause */
+/** @typedef {import("estree").ClassDeclaration} ClassDeclaration */
+/** @typedef {import("estree").ClassExpression} ClassExpression */
+/** @typedef {import("estree").FunctionDeclaration} FunctionDeclaration */
+/** @typedef {import("estree").FunctionExpression} FunctionExpression */
+/** @typedef {import("estree").ArrowFunctionExpression} ArrowFunctionExpression */
+/** @typedef {import("estree").VariableDeclarator} VariableDeclarator */
+/** @typedef {import("estree").VariableDeclaration} VariableDeclaration */
+/** @typedef {import("estree").ImportDeclaration} ImportDeclaration */
+/** @typedef {import("estree").ImportSpecifier} ImportSpecifier */
+/** @typedef {import("estree").ImportDefaultSpecifier} ImportDefaultSpecifier */
+/** @typedef {import("estree").ImportNamespaceSpecifier} ImportNamespaceSpecifier */
+/** @typedef {import("estree").AssignmentExpression} AssignmentExpression */
+/** @typedef {import("estree").ForInStatement} ForInStatement */
+/** @typedef {import("estree").ForOfStatement} ForOfStatement */
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../config/defaults").OutputNormalizedWithDefaults} OutputOptions */
 /** @typedef {import("../Chunk")} Chunk */
@@ -69,13 +83,68 @@ const JavascriptParser = require("./JavascriptParser");
 /** @typedef {import("../Module").CodeGenerationResultData} CodeGenerationResultData */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("../TemplatedPathPlugin").TemplatePath} TemplatePath */
-/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../Chunk").ChunkFilenameTemplate} ChunkFilenameTemplate */
+/** @typedef {import("../errors/WebpackError")} WebpackError */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/concatenate").ScopeSet} ScopeSet */
 /** @typedef {import("../util/concatenate").UsedNamesInScopeInfo} UsedNamesInScopeInfo */
 
+// TODO remove these types when we will update `eslint-scope` to the latest version and import them from `eslint-scope`
+/**
+ * @typedef {object} Scope
+ * @property {"block" | "catch" | "class" | "class-field-initializer" | "class-static-block" | "for" | "function" | "function-expression-name" | "global" | "module" | "switch" | "with" | "TDZ"} type
+ * @property {boolean} isStrict
+ * @property {Scope | null} upper
+ * @property {Scope[]} childScopes
+ * @property {Scope} variableScope
+ * @property {Node} block
+ * @property {Variable[]} variables
+ * @property {Map<string, Variable>} set
+ * @property {Reference[]} references
+ * @property {Reference[]} through
+ * @property {boolean} functionExpressionScope
+ * @property {{ variables: Variable[], set: Map<string, Variable> }=} implicit
+ */
+
+/**
+ * @typedef {
+ * | { type: "CatchClause", node: CatchClause, parent: null }
+ * | { type: "ClassName", node: ClassDeclaration | ClassExpression, parent: null }
+ * | { type: "FunctionName", node: FunctionDeclaration | FunctionExpression, parent: null }
+ * | { type: "ImplicitGlobalVariable", node: AssignmentExpression | ForInStatement | ForOfStatement, parent: null }
+ * | { type: "ImportBinding", node: ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier, parent: ImportDeclaration }
+ * | { type: "Parameter", node: FunctionDeclaration | FunctionExpression | ArrowFunctionExpression, parent: null }
+ * | { type: "TDZ", node: any, parent: null }
+ * | { type: "Variable", node: VariableDeclarator, parent: VariableDeclaration }
+ * } DefinitionType
+ */
+
+/** @typedef {DefinitionType & { name: Identifier }} Definition */
+
+/**
+ * @typedef {object} Variable
+ * @property {string} name
+ * @property {Scope} scope
+ * @property {Identifier[]} identifiers
+ * @property {Reference[]} references
+ * @property {Definition[]} defs
+ */
+
+/**
+ * @typedef {object} Reference
+ * @property {Identifier} identifier
+ * @property {Scope} from
+ * @property {Variable | null} resolved
+ * @property {Node | null} writeExpr
+ * @property {boolean} init
+ * @property {() => boolean} isWrite
+ * @property {() => boolean} isRead
+ * @property {() => boolean} isWriteOnly
+ * @property {() => boolean} isReadOnly
+ * @property {() => boolean} isReadWrite
+ */
+
 /** @type {WeakMap<ChunkGraph, WeakMap<Chunk, boolean>>} */
 const chunkHasJsCache = new WeakMap();
 
@@ -360,16 +429,21 @@ class JavascriptModulesPlugin {
 						.tap(PLUGIN_NAME, (options) => {
 							switch (type) {
 								case JAVASCRIPT_MODULE_TYPE_AUTO: {
-									return new JavascriptParser("auto", { parse: options.parse });
+									return new JavascriptParser("auto", {
+										parse: options.parse,
+										typescript: options.typescript
+									});
 								}
 								case JAVASCRIPT_MODULE_TYPE_DYNAMIC: {
 									return new JavascriptParser("script", {
-										parse: options.parse
+										parse: options.parse,
+										typescript: options.typescript
 									});
 								}
 								case JAVASCRIPT_MODULE_TYPE_ESM: {
 									return new JavascriptParser("module", {
-										parse: options.parse
+										parse: options.parse,
+										typescript: options.typescript
 									});
 								}
 							}
@@ -658,7 +732,7 @@ class JavascriptModulesPlugin {
 	 * Gets chunk filename template.
 	 * @param {Chunk} chunk chunk
 	 * @param {OutputOptions} outputOptions output options
-	 * @returns {TemplatePath} used filename template
+	 * @returns {ChunkFilenameTemplate} used filename template
 	 */
 	static getChunkFilenameTemplate(chunk, outputOptions) {
 		if (chunk.filenameTemplate) {
@@ -1353,6 +1427,13 @@ class JavascriptModulesPlugin {
 			// is evaluated.
 			buf.push("// The deferred module cache");
 			buf.push("var __webpack_module_deferred_exports__ = {};");
+			// Per the TC39 import-defer spec, every defer-import call site for
+			// the same module must yield the same Deferred Module Namespace
+			// Exotic Object (and a distinct one from any eager namespace).
+			// Cache the deferred namespace proxy here so calls from different
+			// files share identity.
+			buf.push("// The deferred namespace cache");
+			buf.push("var __webpack_module_deferred_namespace_cache__ = {};");
 			buf.push("");
 		}
 

package/lib/javascript/JavascriptParser.js

@@ -13,6 +13,7 @@ const Parser = require("../Parser");
 const StackedMap = require("../util/StackedMap");
 const binarySearchBounds = require("../util/binarySearchBounds");
 const {
+	CompilerHintNotationRegExp,
 	createMagicCommentContext,
 	webpackCommentRegExp
 } = require("../util/magicComment");
@@ -495,7 +496,7 @@ class JavascriptParser extends Parser {
 	/**
 	 * Creates an instance of JavascriptParser.
 	 * @param {"module" | "script" | "auto"=} sourceType default source type
-	 * @param {{ parse?: ParseFunction }=} options parser options
+	 * @param {{ parse?: ParseFunction, typescript?: boolean }=} options parser options
 	 */
 	constructor(sourceType = "auto", options = {}) {
 		super();
@@ -584,7 +585,7 @@ class JavascriptParser extends Parser {
 				"exportName",
 				"index"
 			]),
-			/** @type {SyncBailHook<[VariableDeclarator, Statement], boolean | void>} */
+			/** @type {SyncBailHook<[VariableDeclarator, VariableDeclaration], boolean | void>} */
 			preDeclarator: new SyncBailHook(["declarator", "statement"]),
 			/** @type {SyncBailHook<[VariableDeclarator, Statement], boolean | void>} */
 			declarator: new SyncBailHook(["declarator", "statement"]),
@@ -1584,8 +1585,8 @@ class JavascriptParser extends Parser {
 			)
 		);
 
-		this.hooks.evaluate.for("CallExpression").tap(CLASS_NAME, (_expr) => {
-			const expr = /** @type {CallExpression} */ (_expr);
+		this.hooks.evaluate.for("CallExpression").tap(CLASS_NAME, (expression) => {
+			const expr = /** @type {CallExpression} */ (expression);
 			if (
 				expr.callee.type === "MemberExpression" &&
 				expr.callee.property.type ===
@@ -1979,6 +1980,21 @@ class JavascriptParser extends Parser {
 			}
 			return this.evaluateExpression(expr.expression);
 		});
+		this.hooks.evaluate.for("SequenceExpression").tap(CLASS_NAME, (_expr) => {
+			const expr = /** @type {SequenceExpression} */ (_expr);
+			if (!expr.range) return;
+			let commentsStartPos = /** @type {Range} */ (expr.range)[0];
+			for (let i = 0; i < expr.expressions.length - 1; i++) {
+				const item = expr.expressions[i];
+				if (!item.range) return;
+				if (!this.isPure(item, commentsStartPos)) return;
+				commentsStartPos = /** @type {Range} */ (item.range)[1];
+			}
+			const last = expr.expressions[expr.expressions.length - 1];
+			const evaluated = this.evaluateExpression(last);
+			if (!evaluated.isCompileTimeValue()) return;
+			return evaluated.setRange(/** @type {Range} */ (expr.range));
+		});
 	}
 
 	/**
@@ -3848,6 +3864,37 @@ class JavascriptParser extends Parser {
 	 * @param {NewExpression} expression new expression
 	 */
 	walkNewExpression(expression) {
+		// TODO: not a webpack bug — `acorn-import-phases` accepts
+		// `new import.defer(...)` / `new import.source(...)` even though
+		// `ImportCall` is a `CallExpression` per spec and is therefore not a
+		// valid `new` operand. Acorn rejects bare `new import(...)` correctly.
+		// Drop this block once the upstream plugin (or acorn itself) reports
+		// the SyntaxError. Parenthesized forms (`new (import.defer(...))`)
+		// produce the same AST shape, so we look at the source between `new`
+		// and the callee (with comments stripped) to keep them valid.
+		if (
+			expression.callee.type === "ImportExpression" &&
+			typeof this.state.source === "string"
+		) {
+			const newStart = /** @type {Range} */ (expression.range)[0];
+			const calleeStart = /** @type {Range} */ (expression.callee.range)[0];
+			const between = this.state.source
+				.slice(newStart, calleeStart)
+				.replace(/\/\*[\s\S]*?\*\//g, "")
+				.replace(/\/\/[^\n]*/g, "");
+			if (!between.includes("(")) {
+				const err =
+					/** @type {SyntaxError & { loc?: { line: number, column: number } }} */
+					(new SyntaxError("import call cannot be the target of `new`"));
+				if (expression.loc) {
+					err.loc = {
+						line: expression.loc.start.line,
+						column: expression.loc.start.column
+					};
+				}
+				throw err;
+			}
+		}
 		const result = this.callHooksForExpression(
 			this.hooks.new,
 			expression.callee,
@@ -4214,10 +4261,10 @@ class JavascriptParser extends Parser {
 		if (expression.object.type === "MemberExpression") {
 			// optimize the case where expression.object is a MemberExpression too.
 			// we can keep info here when calling walkMemberExpression directly
-			const property =
-				/** @type {Identifier} */
-				(expression.property).name ||
-				`${/** @type {Literal} */ (expression.property).value}`;
+			// Read the property from `members` (already extracted by
+			// extractMemberExpressionChain) since the AST node may be a
+			// TemplateLiteral, which has neither .name nor .value.
+			const property = members[members.length - 1];
 			name = name.slice(0, -property.length - 1);
 			members.pop();
 			const result = this.callHooksForInfo(
@@ -4849,6 +4896,9 @@ class JavascriptParser extends Parser {
 
 		if (Buffer.isBuffer(source)) {
 			source = source.toString("utf8");
+			// Keep `state.source` as a string so downstream walkers can read
+			// the original text without re-decoding the Buffer on every use.
+			state.source = source;
 		}
 
 		let ast;
@@ -4908,6 +4958,7 @@ class JavascriptParser extends Parser {
 			this.destructuringAssignmentProperties = new WeakMap();
 			this.detectMode(ast.body);
 			this.modulePreWalkStatements(ast.body);
+			this.prevStatement = undefined;
 			this.preWalkStatements(ast.body);
 			this.prevStatement = undefined;
 			this.blockPreWalkStatements(ast.body);
@@ -4954,8 +5005,8 @@ class JavascriptParser extends Parser {
 			.for(expr.type)
 			.call(expr, commentsStartPos);
 		if (typeof result === "boolean") return result;
+		// TODO handle more cases
 		switch (expr.type) {
-			// TODO handle more cases
 			case "ClassDeclaration":
 			case "ClassExpression": {
 				if (expr.body.type !== "ClassBody") return false;
@@ -5008,9 +5059,15 @@ class JavascriptParser extends Parser {
 				});
 			}
 			case "TemplateLiteral":
-				return expr.expressions.every((expr) =>
-					this.isPure(expr, /** @type {Range} */ (expr.range)[0])
-				);
+				// Thread `commentsStartPos` through the interpolations so a
+				// /*#__PURE__*/ comment that sits inside `${ ... }` (or before
+				// the first interpolation) is part of the scanned range when
+				// the inner expression's purity is evaluated.
+				return expr.expressions.every((e) => {
+					const pureFlag = this.isPure(e, commentsStartPos);
+					commentsStartPos = /** @type {Range} */ (e.range)[1];
+					return pureFlag;
+				});
 			case "FunctionDeclaration":
 			case "FunctionExpression":
 			case "ArrowFunctionExpression":
@@ -5025,6 +5082,78 @@ class JavascriptParser extends Parser {
 					this.isPure(decl.init, /** @type {Range} */ (decl.range)[0])
 				);
 
+			case "ArrayExpression":
+				return expr.elements.every((element) => {
+					if (element === null) return true;
+					if (element.type === "SpreadElement") return false;
+					const pureFlag = this.isPure(element, commentsStartPos);
+					commentsStartPos = /** @type {Range} */ (element.range)[1];
+					return pureFlag;
+				});
+
+			case "ObjectExpression": {
+				return expr.properties.every((property) => {
+					if (property.type === "SpreadElement") return false;
+
+					if (
+						property.computed &&
+						!this.isPure(property.key, commentsStartPos)
+					) {
+						return false;
+					}
+
+					const pureFlag = this.isPure(
+						/** @type {Exclude<Property["value"], AssignmentPattern | ObjectPattern | ArrayPattern | RestElement>} */
+						(property.value),
+						/** @type {Range} */ (property.key.range)[1]
+					);
+					commentsStartPos = /** @type {Range} */ (property.range)[1];
+					return pureFlag;
+				});
+			}
+
+			case "ChainExpression":
+				return this.isPure(expr.expression, commentsStartPos);
+
+			case "UnaryExpression":
+				// Safe unary operators — produce their result without invoking
+				// user code on the operand:
+				//   - `typeof` returns a type tag and never throws, even for
+				//     undeclared identifiers; no coercion.
+				//   - `void` evaluates the operand and discards it, returning
+				//     `undefined`; pure iff the operand is pure.
+				//   - `!` coerces via ToBoolean, which is defined to not call
+				//     any user code (objects → true, etc.).
+				// Other operators (`+`, `-`, `~`, `delete`) fall through to
+				// the generic evaluator which can still recognize literal
+				// cases (e.g. `-1`, `+5`).
+				if (
+					expr.operator === "typeof" ||
+					expr.operator === "void" ||
+					expr.operator === "!"
+				) {
+					return this.isPure(expr.argument, commentsStartPos);
+				}
+				break;
+
+			case "MetaProperty":
+				return true;
+
+			case "BinaryExpression":
+				// Strict (in)equality compares without coercion and never invokes
+				// user code on its operands, so the result is pure iff both sides
+				// are pure. All other binary operators may invoke `valueOf` /
+				// `toString` / `[Symbol.hasInstance]` / Proxy traps and fall through
+				// to the generic evaluator, which can still recognize the cases
+				// where both sides evaluate to known primitive literals.
+				if (expr.operator === "===" || expr.operator === "!==") {
+					return (
+						this.isPure(expr.left, commentsStartPos) &&
+						this.isPure(expr.right, /** @type {Range} */ (expr.left.range)[1])
+					);
+				}
+				break;
+
 			case "ConditionalExpression":
 				return (
 					this.isPure(expr.test, commentsStartPos) &&
@@ -5060,7 +5189,28 @@ class JavascriptParser extends Parser {
 					]).some(
 						(comment) =>
 							comment.type === "Block" &&
-							/^\s*(?:#|@)__PURE__\s*$/.test(comment.value)
+							CompilerHintNotationRegExp.Pure.test(comment.value)
+					);
+				if (!pureFlag) return false;
+				commentsStartPos = /** @type {Range} */ (expr.callee.range)[1];
+				return expr.arguments.every((arg) => {
+					if (arg.type === "SpreadElement") return false;
+					const pureFlag = this.isPure(arg, commentsStartPos);
+					commentsStartPos = /** @type {Range} */ (arg.range)[1];
+					return pureFlag;
+				});
+			}
+
+			case "NewExpression": {
+				const pureFlag =
+					/** @type {Range} */ (expr.range)[0] - commentsStartPos > 12 &&
+					this.getComments([
+						commentsStartPos,
+						/** @type {Range} */ (expr.range)[0]
+					]).some(
+						(comment) =>
+							comment.type === "Block" &&
+							CompilerHintNotationRegExp.Pure.test(comment.value)
 					);
 				if (!pureFlag) return false;
 				commentsStartPos = /** @type {Range} */ (expr.callee.range)[1];
@@ -5071,6 +5221,26 @@ class JavascriptParser extends Parser {
 					return pureFlag;
 				});
 			}
+
+			case "TaggedTemplateExpression": {
+				const pureFlag =
+					/** @type {Range} */ (expr.range)[0] - commentsStartPos > 12 &&
+					this.getComments([
+						commentsStartPos,
+						/** @type {Range} */ (expr.range)[0]
+					]).some(
+						(comment) =>
+							comment.type === "Block" &&
+							CompilerHintNotationRegExp.Pure.test(comment.value)
+					);
+				if (!pureFlag) return false;
+				commentsStartPos = /** @type {Range} */ (expr.tag.range)[1];
+				return expr.quasi.expressions.every((e) => {
+					const pureFlag = this.isPure(e, commentsStartPos);
+					commentsStartPos = /** @type {Range} */ (e.range)[1];
+					return pureFlag;
+				});
+			}
 		}
 		const evaluated = this.evaluateExpression(expr);
 		return !evaluated.couldHaveSideEffects();
@@ -5380,9 +5550,20 @@ class JavascriptParser extends Parser {
 		const memberRanges = [];
 		while (expr.type === "MemberExpression") {
 			if (expr.computed) {
-				if (expr.property.type !== "Literal") break;
-				members.push(`${expr.property.value}`); // the literal
-				memberRanges.push(/** @type {Range} */ (expr.object.range)); // the range of the expression fragment before the literal
+				const prop = expr.property;
+				if (prop.type === "Literal") {
+					members.push(`${prop.value}`); // the literal
+				} else if (
+					prop.type === "TemplateLiteral" &&
+					prop.expressions.length === 0 &&
+					typeof prop.quasis[0].value.cooked === "string"
+				) {
+					// `[`url`]` is statically a string just like `["url"]`
+					members.push(prop.quasis[0].value.cooked);
+				} else {
+					break;
+				}
+				memberRanges.push(/** @type {Range} */ (expr.object.range)); // the range of the expression fragment before the property
 			} else {
 				if (expr.property.type !== "Identifier") break;
 				members.push(expr.property.name); // the identifier

package/lib/javascript/JavascriptParserHelpers.js

@@ -5,8 +5,8 @@
 
 "use strict";
 
-const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
 const ConstDependency = require("../dependencies/ConstDependency");
+const UnsupportedFeatureWarning = require("../errors/UnsupportedFeatureWarning");
 const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 
 /** @typedef {import("estree").Expression} Expression */

package/lib/json/JsonParser.js

@@ -10,7 +10,7 @@ const JsonExportsDependency = require("../dependencies/JsonExportsDependency");
 const parseJson = require("../util/parseJson");
 const JsonData = require("./JsonData");
 
-/** @typedef {import("../../declarations/plugins/JsonModulesPluginParser").JsonModulesPluginParserOptions} JsonModulesPluginParserOptions */
+/** @typedef {import("../../declarations/WebpackOptions").JsonParserOptions} JsonParserOptions */
 /** @typedef {import("../Module").BuildInfo} BuildInfo */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../Parser").ParserState} ParserState */
@@ -28,11 +28,11 @@ const JsonData = require("./JsonData");
 class JsonParser extends Parser {
 	/**
 	 * Creates an instance of JsonParser.
-	 * @param {JsonModulesPluginParserOptions} options parser options
+	 * @param {JsonParserOptions} options parser options
 	 */
 	constructor(options = {}) {
 		super();
-		/** @type {JsonModulesPluginParserOptions} */
+		/** @type {JsonParserOptions} */
 		this.options = options;
 	}
 
@@ -47,22 +47,13 @@ class JsonParser extends Parser {
 			source = source.toString("utf8");
 		}
 
-		/** @type {typeof parseJson} */
 		const parseFn =
 			typeof this.options.parse === "function" ? this.options.parse : parseJson;
 		/** @type {Buffer | JsonValue | undefined} */
-		let data;
-		try {
-			data =
-				typeof source === "object"
-					? source
-					: parseFn(source[0] === "\uFEFF" ? source.slice(1) : source);
-		} catch (err) {
-			throw new Error(
-				`Cannot parse JSON: ${/** @type {Error} */ (err).message}`,
-				{ cause: err }
-			);
-		}
+		const data =
+			typeof source === "object"
+				? source
+				: parseFn(source[0] === "\uFEFF" ? source.slice(1) : source);
 		const jsonData = new JsonData(/** @type {Buffer | JsonValue} */ (data));
 		const buildInfo = /** @type {BuildInfo} */ (state.module.buildInfo);
 		buildInfo.jsonData = jsonData;

package/lib/library/AbstractLibraryPlugin.js

@@ -249,7 +249,7 @@ class AbstractLibraryPlugin {
 	 * @returns {T} preprocess as needed by overriding
 	 */
 	parseOptions(library) {
-		const AbstractMethodError = require("../AbstractMethodError");
+		const AbstractMethodError = require("../errors/AbstractMethodError");
 
 		throw new AbstractMethodError();
 	}

package/lib/library/EnableLibraryPlugin.js

@@ -249,7 +249,7 @@ class EnableLibraryPlugin {
 								compiler.hooks.thisCompilation.tap(
 									"WarnFalseIifeUmdPlugin",
 									(compilation) => {
-										const FalseIIFEUmdWarning = require("../FalseIIFEUmdWarning");
+										const FalseIIFEUmdWarning = require("./FalseIIFEUmdWarning");
 
 										compilation.warnings.push(new FalseIIFEUmdWarning());
 									}