webpack 5.108.3 → 5.109.0

package/lib/loaders/loadLoader.js

@@ -0,0 +1,100 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { pathToFileURL } = require("url");
+const LoaderLoadingError = require("../errors/LoaderLoadingError");
+
+/** @typedef {import("./LoaderRunner").LoaderObject} LoaderObject */
+
+/**
+ * Lazily-compiled dynamic `import()`. Built on first use so this file still
+ * parses on Node versions without native `import()` (<13.2), then reused.
+ * @type {((url: URL) => Promise<EXPECTED_ANY>) | undefined}
+ */
+let importModule;
+
+/**
+ * @param {LoaderObject} loader the loader to load into
+ * @param {EXPECTED_ANY} module the loaded module
+ * @param {(err?: Error) => void} callback callback
+ * @returns {void}
+ */
+function handleResult(loader, module, callback) {
+	if (typeof module !== "function" && typeof module !== "object") {
+		return callback(
+			new LoaderLoadingError(
+				`Module '${loader.path}' is not a loader (export function or es6 module)`
+			)
+		);
+	}
+
+	loader.normal = typeof module === "function" ? module : module.default;
+	loader.pitch = module.pitch;
+	loader.raw = module.raw;
+
+	if (
+		typeof loader.normal !== "function" &&
+		typeof loader.pitch !== "function"
+	) {
+		return callback(
+			new LoaderLoadingError(
+				`Module '${loader.path}' is not a loader (must have normal or pitch function)`
+			)
+		);
+	}
+	callback();
+}
+
+/**
+ * @param {LoaderObject} loader the loader to load
+ * @param {(err?: Error) => void} callback callback
+ * @returns {void}
+ */
+function loadLoader(loader, callback) {
+	if (loader.type === "module") {
+		try {
+			if (importModule === undefined) {
+				// `eval` defers parsing `import()` to runtime, so this file stays
+				// loadable on Node versions that can't parse it (<13.2).
+				// eslint-disable-next-line no-eval
+				const dynamicImport = eval("(url) => import(url)");
+				importModule = /** @type {(url: URL) => Promise<EXPECTED_ANY>} */ (
+					dynamicImport
+				);
+			}
+
+			importModule(pathToFileURL(loader.path)).then(
+				(/** @type {EXPECTED_ANY} */ module) => {
+					handleResult(loader, module, callback);
+				},
+				callback
+			);
+		} catch (err) {
+			callback(/** @type {Error} */ (err));
+		}
+		return;
+	}
+
+	let loadedModule;
+	try {
+		loadedModule = require(loader.path);
+	} catch (err) {
+		// node can choke on require when the FD limit is hit; defer to recover.
+		if (
+			err instanceof Error &&
+			/** @type {NodeJS.ErrnoException} */ (err).code === "EMFILE"
+		) {
+			setImmediate(loadLoader, loader, callback);
+			return;
+		}
+		return callback(/** @type {Error} */ (err));
+	}
+
+	return handleResult(loader, loadedModule, callback);
+}
+
+module.exports = loadLoader;

package/lib/node/ReadFileCompileAsyncWasmPlugin.js

@@ -8,12 +8,21 @@
 const { WEBASSEMBLY_MODULE_TYPE_ASYNC } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
+const { getPresentKinds } = require("../TemplatedPathPlugin");
 const AsyncWasmCompileRuntimeModule = require("../wasm-async/AsyncWasmCompileRuntimeModule");
 const AsyncWasmLoadingRuntimeModule = require("../wasm-async/AsyncWasmLoadingRuntimeModule");
 
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
 
+/**
+ * The wasm runtime inlines `[fullhash]` as a runtime `getFullHash()` call, so
+ * that runtime module must be requested (`[hash]` is the per-module hash here).
+ * @param {string} filename `output.webassemblyModuleFilename`
+ * @returns {boolean} whether it references the compilation `[fullhash]`
+ */
+const usesFullHash = (filename) => getPresentKinds(filename).has("fullhash");
+
 /**
  * Defines the read file compile async wasm plugin options type used by this module.
  * @typedef {object} ReadFileCompileAsyncWasmPluginOptions
@@ -112,6 +121,11 @@ class ReadFileCompileAsyncWasmPlugin {
 					) {
 						return;
 					}
+					if (
+						usesFullHash(compilation.outputOptions.webassemblyModuleFilename)
+					) {
+						set.add(RuntimeGlobals.getFullHash);
+					}
 					compilation.addRuntimeModule(
 						chunk,
 						new AsyncWasmLoadingRuntimeModule({
@@ -133,6 +147,11 @@ class ReadFileCompileAsyncWasmPlugin {
 					) {
 						return;
 					}
+					if (
+						usesFullHash(compilation.outputOptions.webassemblyModuleFilename)
+					) {
+						set.add(RuntimeGlobals.getFullHash);
+					}
 					compilation.addRuntimeModule(
 						chunk,
 						new AsyncWasmCompileRuntimeModule({

package/lib/node/ReadFileCompileWasmPlugin.js

@@ -8,11 +8,20 @@
 const { WEBASSEMBLY_MODULE_TYPE_SYNC } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
+const { getPresentKinds } = require("../TemplatedPathPlugin");
 const WasmChunkLoadingRuntimeModule = require("../wasm-sync/WasmChunkLoadingRuntimeModule");
 
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
 
+/**
+ * The wasm runtime inlines `[fullhash]` as a runtime `getFullHash()` call, so
+ * that runtime module must be requested (`[hash]` is the per-module hash here).
+ * @param {string} filename `output.webassemblyModuleFilename`
+ * @returns {boolean} whether it references the compilation `[fullhash]`
+ */
+const usesFullHash = (filename) => getPresentKinds(filename).has("fullhash");
+
 /**
  * Defines the read file compile wasm plugin options type used by this module.
  * @typedef {object} ReadFileCompileWasmPluginOptions
@@ -113,6 +122,11 @@ class ReadFileCompileWasmPlugin {
 						return;
 					}
 					set.add(RuntimeGlobals.moduleCache);
+					if (
+						usesFullHash(compilation.outputOptions.webassemblyModuleFilename)
+					) {
+						set.add(RuntimeGlobals.getFullHash);
+					}
 					compilation.addRuntimeModule(
 						chunk,
 						new WasmChunkLoadingRuntimeModule({

package/lib/optimize/ConcatenatedModule.js

@@ -26,8 +26,11 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const { DEFAULTS } = require("../config/defaults");
 const { ImportPhaseUtils } = require("../dependencies/ImportPhase");
+const { isCommonJsWrapped } = require("../javascript/JavascriptGenerator");
 const JavascriptParser = require("../javascript/JavascriptParser");
 const {
+	getDeferredCycleModuleIds,
+	getDeferredCycleModules,
 	getMakeDeferredNamespaceModeFromExportsType,
 	getOptimizedDeferredModule
 } = require("../runtime/MakeDeferredNamespaceObjectRuntime");
@@ -82,6 +85,7 @@ const { InlinedUsedName } = require("./InlineExports");
 /** @typedef {import("../Module").RuntimeRequirements} RuntimeRequirements */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../NormalModule")} NormalModule */
 /** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
 /** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
 /** @typedef {import("../RequestShortener")} RequestShortener */
@@ -153,6 +157,7 @@ if (!ReferencerClass.prototype.PropertyDefinition) {
  * @property {"concatenated"} type
  * @property {Module} module
  * @property {number} index
+ * @property {boolean=} cjsWrapped a "weird" CommonJS module executed via the CJS wrapper runtime helper with real module/exports objects
  * @property {Program | undefined} ast
  * @property {Source | undefined} internalSource
  * @property {ReplaceSource | undefined} source
@@ -354,6 +359,9 @@ const getFinalBinding = (
 	if (exportName.length === 0) {
 		switch (exportsType) {
 			case "default-only":
+				// a concatenated CommonJS module has no runtime exports object;
+				// its fake namespace is built over the generated namespace object
+				if (info.type === "concatenated") neededNamespaceObjects.add(info);
 				if (deferred) info.deferredNamespaceObjectUsed = true;
 				else info.interopNamespaceObject2Used = true;
 				return {
@@ -367,6 +375,7 @@ const getFinalBinding = (
 					exportName
 				};
 			case "default-with-named":
+				if (info.type === "concatenated") neededNamespaceObjects.add(info);
 				if (deferred) info.deferredNamespaceObjectUsed = true;
 				else info.interopNamespaceObjectUsed = true;
 				return {
@@ -657,7 +666,9 @@ const getFinalBinding = (
 					alreadyVisited
 				);
 			}
-			if (info.namespaceExportSymbol) {
+			// A wrapped module resolves every export through its live exports
+			// alias (namespaceObjectName), same as namespaceExportSymbol modules.
+			if (info.namespaceExportSymbol || info.cjsWrapped) {
 				const usedName = /** @type {ExportName} */ (
 					exportsInfo.getUsedName(exportName, runtime)
 				);
@@ -985,8 +996,19 @@ class ConcatenatedModule extends Module {
 
 		for (const m of this._modules) {
 			// populate cacheable
-			if (!(/** @type {BuildInfo} */ (m.buildInfo).cacheable)) {
+			const { cacheable, notCacheableReasons } = /** @type {BuildInfo} */ (
+				m.buildInfo
+			);
+			if (!cacheable) {
 				this.buildInfo.cacheable = false;
+				if (notCacheableReasons) {
+					const reasons =
+						this.buildInfo.notCacheableReasons ||
+						(this.buildInfo.notCacheableReasons = []);
+					for (const reason of notCacheableReasons) {
+						if (!reasons.includes(reason)) reasons.push(reason);
+					}
+				}
 			}
 
 			// populate dependencies
@@ -1517,7 +1539,7 @@ class ConcatenatedModule extends Module {
 
 		// get all global names
 		for (const info of modulesWithInfo) {
-			if (info.type === "concatenated") {
+			if (info.type === "concatenated" && !info.cjsWrapped) {
 				// ignore symbols from moduleScope
 				if (info.moduleScope) {
 					ignoredScopes.add(info.moduleScope);
@@ -1707,6 +1729,23 @@ class ConcatenatedModule extends Module {
 			);
 			switch (info.type) {
 				case "concatenated": {
+					if (info.cjsWrapped) {
+						// Wrapped modules expose one shared-scope name: the final
+						// exports object used as the namespace.
+						const namespaceObjectName = findNewName(
+							"namespaceObject",
+							allUsedNames,
+							namespaceObjectUsedNames,
+							info.module.readableIdentifier(requestShortener)
+						);
+						allUsedNames.add(namespaceObjectName);
+						topLevelDeclarations.add(namespaceObjectName);
+						info.namespaceObjectName = namespaceObjectName;
+						// Route every binding to the live exports alias and skip the
+						// materialized namespace object generated for other modules.
+						info.namespaceExportSymbol = namespaceObjectName;
+						break;
+					}
 					const variables = /** @type {Scope} */ (info.moduleScope).variables;
 					for (const variable of variables) {
 						const name = variable.name;
@@ -1843,7 +1882,7 @@ class ConcatenatedModule extends Module {
 
 		// Find and replace references to modules
 		for (const info of moduleToInfoMap.values()) {
-			if (info.type === "concatenated") {
+			if (info.type === "concatenated" && !info.cjsWrapped) {
 				const globalScope = /** @type {Scope} */ (info.globalScope);
 				// group references by name
 				/** @type {Map<string, Reference[]>} */
@@ -2081,7 +2120,9 @@ class ConcatenatedModule extends Module {
 				if (!usedName) continue;
 				if (usedName instanceof InlinedUsedName) {
 					nsObj.push(
-						`\n  ${propertyName(exportInfo.name)}: ${runtimeTemplate.returningFunction(
+						`\n  ${propertyName(
+							exportInfo.name
+						)}: ${runtimeTemplate.returningFunction(
 							usedName.render(
 								Template.toNormalComment(
 									`inlined export ${propertyAccess([exportInfo.name])}`
@@ -2094,7 +2135,9 @@ class ConcatenatedModule extends Module {
 					// import variable; concatenated ones resolve to an internal binding.
 					const finalName =
 						info.type === "external"
-							? `${/** @type {string} */ (info.name)}${propertyAccess([usedName])}`
+							? `${/** @type {string} */ (info.name)}${propertyAccess([
+									usedName
+								])}`
 							: getFinalName(
 									moduleGraph,
 									info,
@@ -2112,9 +2155,9 @@ class ConcatenatedModule extends Module {
 									true
 								);
 					nsObj.push(
-						`\n  ${propertyName(exportInfo.name)}: ${runtimeTemplate.returningFunction(
-							finalName
-						)}`
+						`\n  ${propertyName(
+							exportInfo.name
+						)}: ${runtimeTemplate.returningFunction(finalName)}`
 					);
 				}
 			}
@@ -2131,7 +2174,9 @@ class ConcatenatedModule extends Module {
 			escapeNamespaceObjectSources.set(
 				info,
 				`
-// NAMESPACE OBJECT (decoupled): ${info.module.readableIdentifier(requestShortener)}
+// NAMESPACE OBJECT (decoupled): ${info.module.readableIdentifier(
+					requestShortener
+				)}
 var ${name} = {};
 ${RuntimeGlobals.makeNamespaceObject}(${name});
 ${defineGetters}`
@@ -2154,7 +2199,9 @@ ${defineGetters}`
 					// TODO: Replace with the inlined value directly at the call site
 					if (usedName instanceof InlinedUsedName) {
 						nsObj.push(
-							`\n  ${propertyName(exportInfo.name)}: ${runtimeTemplate.returningFunction(
+							`\n  ${propertyName(
+								exportInfo.name
+							)}: ${runtimeTemplate.returningFunction(
 								usedName.render(
 									Template.toNormalComment(
 										`inlined export ${propertyAccess([exportInfo.name])}`
@@ -2180,9 +2227,9 @@ ${defineGetters}`
 							true
 						);
 						nsObj.push(
-							`\n  ${propertyName(usedName)}: ${runtimeTemplate.returningFunction(
-								finalName
-							)}`
+							`\n  ${propertyName(
+								usedName
+							)}: ${runtimeTemplate.returningFunction(finalName)}`
 						);
 					}
 				}
@@ -2232,6 +2279,16 @@ ${defineGetters}`
 					),
 					// an async module will opt-out of the concat module optimization.
 					[],
+					// A closure member absorbed into this concatenation shares this
+					// module's runtime id (and thus its `evaluating` flag); resolve it
+					// to that id instead of the member's now-absent standalone id.
+					getDeferredCycleModuleIds(
+						getDeferredCycleModules(moduleGraph, info.module),
+						(mod) =>
+							moduleToInfoMap.has(mod)
+								? chunkGraph.getModuleId(this)
+								: chunkGraph.getModuleId(mod)
+					),
 					runtimeRequirements
 				);
 				runtimeRequirements.add(RuntimeGlobals.require);
@@ -2269,7 +2326,18 @@ ${defineGetters}`
 					result.add(
 						`\n;// ${info.module.readableIdentifier(requestShortener)}\n`
 					);
-					result.add(/** @type {ReplaceSource} */ (info.source));
+					if (info.cjsWrapped) {
+						// Real CommonJS semantics via the runtime helper: it calls the
+						// body with this = exports and returns the final module.exports.
+						runtimeRequirements.add(RuntimeGlobals.commonJsWrap);
+						result.add(
+							`var ${info.namespaceObjectName} = /*#__PURE__*/${RuntimeGlobals.commonJsWrap}(function(${info.module.moduleArgument}, ${info.module.exportsArgument}) {\n`
+						);
+						result.add(/** @type {ReplaceSource} */ (info.source));
+						result.add("\n});\n");
+					} else {
+						result.add(/** @type {ReplaceSource} */ (info.source));
+					}
 					if (info.chunkInitFragments) {
 						for (const f of info.chunkInitFragments) chunkInitFragments.push(f);
 					}
@@ -2403,6 +2471,33 @@ ${defineGetters}`
 		if (info.type === "concatenated") {
 			const m = info.module;
 			try {
+				if (info.cjsWrapped) {
+					// A wrapped module renders its normal module source (real
+					// module/exports objects, own module ids) inside an IIFE, so it
+					// needs no concatenation scope, reference rewriting, or scope
+					// analysis — the wrapper isolates its top-level declarations.
+					const codeGenResult = m.codeGeneration({
+						dependencyTemplates,
+						runtimeTemplate,
+						moduleGraph,
+						chunkGraph,
+						runtime,
+						runtimes,
+						codeGenerationResults,
+						sourceTypes: JAVASCRIPT_TYPES
+					});
+					const source =
+						/** @type {Source} */
+						(codeGenResult.sources.get(JAVASCRIPT_TYPE));
+					const data = codeGenResult.data;
+					info.runtimeRequirements =
+						/** @type {ReadOnlyRuntimeRequirements} */
+						(codeGenResult.runtimeRequirements);
+					info.internalSource = source;
+					info.source = new ReplaceSource(source);
+					info.chunkInitFragments = data && data.get("chunkInitFragments");
+					return;
+				}
 				// Create a concatenation scope to track and capture information
 				const concatenationScope = new ConcatenationScope(
 					modulesMap,
@@ -2434,11 +2529,17 @@ ${defineGetters}`
 				let ast;
 
 				try {
+					const { experiments } = this.compilation.options;
+
 					({ ast } = JavascriptParser._parse(
 						code,
 						{
 							sourceType: "module",
-							ranges: true
+							ranges: true,
+							// generated code contains phase imports when the experiments are on
+							importPhases: Boolean(
+								experiments.deferImport || experiments.sourceImport
+							)
 						},
 						JavascriptParser._getModuleParseFunction(this.compilation, m)
 					));
@@ -2511,6 +2612,9 @@ ${defineGetters}`
 							type: "concatenated",
 							module: info.module,
 							index,
+							cjsWrapped: isCommonJsWrapped(
+								/** @type {NormalModule} */ (info.module)
+							),
 							ast: undefined,
 							chunkInitFragments: undefined,
 							internalSource: undefined,

package/lib/optimize/FlagIncludedChunksPlugin.js

@@ -76,6 +76,12 @@ class FlagIncludedChunksPlugin {
 					chunkModulesHash.set(chunk, hash);
 				}
 
+				// Chunks that received an included id and need their `ids` re-sorted
+				// once, after all pushes — instead of re-sorting on every push
+				// inside the nested loop below (https://github.com/webpack/webpack/issues/18837).
+				/** @type {Set<Chunk>} */
+				const chunksWithIncludedIds = new Set();
+
 				for (const chunkA of chunks) {
 					const chunkAHash =
 						/** @type {number} */
@@ -125,11 +131,15 @@ class FlagIncludedChunksPlugin {
 
 						/** @type {ChunkId[]} */
 						(chunkB.ids).push(/** @type {ChunkId} */ (chunkA.id));
-						// https://github.com/webpack/webpack/issues/18837
-						/** @type {ChunkId[]} */
-						(chunkB.ids).sort(compareIds);
+						chunksWithIncludedIds.add(chunkB);
 					}
 				}
+
+				// Sort each affected chunk's ids once (https://github.com/webpack/webpack/issues/18837).
+				for (const chunk of chunksWithIncludedIds) {
+					/** @type {ChunkId[]} */
+					(chunk.ids).sort(compareIds);
+				}
 			});
 		});
 	}

package/lib/optimize/InnerGraphPlugin.js

@@ -80,6 +80,9 @@ class InnerGraphPlugin {
 					 * @param {Expression} sup sup
 					 */
 					const onUsageSuper = (sup) => {
+						// the callback fires after parsing, when the parser can no
+						// longer map offsets — take the location now
+						const loc = parser.getLocation(sup);
 						innerGraph.onUsage(parser.state, (usedByExports, module) => {
 							switch (usedByExports) {
 								case undefined:
@@ -90,7 +93,7 @@ class InnerGraphPlugin {
 										/** @type {Range} */
 										(sup.range)
 									);
-									dep.loc = /** @type {DependencyLocation} */ (sup.loc);
+									dep.loc = loc;
 									dep.usedByExports = usedByExports;
 									addPureDependency(module, dep);
 									break;
@@ -205,30 +208,36 @@ class InnerGraphPlugin {
 
 					// The following hooks are used during prewalking:
 
-					parser.hooks.preStatement.tap(PLUGIN_NAME, (statement) => {
-						if (!innerGraph.isEnabled(parser.state)) return;
+					parser.hooks.preStatementByType
+						.for("FunctionDeclaration")
+						.tap(PLUGIN_NAME, (statement) => {
+							if (!innerGraph.isEnabled(parser.state)) return;
 
-						if (
-							parser.scope.topLevelScope === true &&
-							statement.type === "FunctionDeclaration"
-						) {
-							const name = statement.id ? statement.id.name : "*default*";
-							const symbol = /** @type {TopLevelSymbol} */ (
-								innerGraph.tagTopLevelSymbol(
-									parser,
-									name,
-									parser.isPure(
-										statement,
-										/** @type {Range} */ (statement.range)[0]
+							if (
+								parser.scope.topLevelScope === true &&
+								statement.type === "FunctionDeclaration"
+							) {
+								const name = statement.id ? statement.id.name : "*default*";
+								const symbol = /** @type {TopLevelSymbol} */ (
+									innerGraph.tagTopLevelSymbol(
+										parser,
+										name,
+										parser.isPure(
+											statement,
+											/** @type {Range} */ (statement.range)[0]
+										)
 									)
-								)
-							);
-							statementWithTopLevelSymbol.set(statement, symbol);
-							return true;
-						}
-					});
+								);
+								statementWithTopLevelSymbol.set(statement, symbol);
+								return true;
+							}
+						});
 
-					parser.hooks.blockPreStatement.tap(PLUGIN_NAME, (statement) => {
+					/**
+					 * @param {import("estree").Statement | import("estree").ModuleDeclaration | import("estree").MaybeNamedFunctionDeclaration | import("estree").MaybeNamedClassDeclaration} statement statement
+					 * @returns {boolean | void} true when handled
+					 */
+					const blockPreStatementHandler = (statement) => {
 						if (!innerGraph.isEnabled(parser.state)) return;
 
 						if (parser.scope.topLevelScope === true) {
@@ -288,7 +297,13 @@ class InnerGraphPlugin {
 								}
 							}
 						}
-					});
+					};
+					parser.hooks.blockPreStatementByType
+						.for("ClassDeclaration")
+						.tap(PLUGIN_NAME, blockPreStatementHandler);
+					parser.hooks.blockPreStatementByType
+						.for("ExportDefaultDeclaration")
+						.tap(PLUGIN_NAME, blockPreStatementHandler);
 
 					parser.hooks.preDeclarator.tap(PLUGIN_NAME, (decl, statement) => {
 						if (!innerGraph.isEnabled(parser.state)) return;
@@ -363,6 +378,9 @@ class InnerGraphPlugin {
 								innerGraph.setTopLevelSymbol(parser.state, symbol);
 								const purePart = statementPurePart.get(statement);
 								if (purePart) {
+									// the callback fires after parsing, when the parser can no
+									// longer map offsets — take the location now
+									const loc = parser.getLocation(statement);
 									innerGraph.onUsage(parser.state, (usedByExports, module) => {
 										switch (usedByExports) {
 											case undefined:
@@ -372,9 +390,7 @@ class InnerGraphPlugin {
 												const dep = new PureExpressionDependency(
 													/** @type {Range} */ (purePart.range)
 												);
-												dep.loc =
-													/** @type {DependencyLocation} */
-													(statement.loc);
+												dep.loc = loc;
 												dep.usedByExports = usedByExports;
 												addPureDependency(module, dep);
 												break;
@@ -439,6 +455,9 @@ class InnerGraphPlugin {
 									) {
 										innerGraph.setTopLevelSymbol(parser.state, symbol);
 										if (element.type !== "MethodDefinition" && element.static) {
+											// the callback fires after parsing, when the parser can
+											// no longer map offsets — take the location now
+											const loc = parser.getLocation(expression);
 											innerGraph.onUsage(
 												parser.state,
 												(usedByExports, module) => {
@@ -450,9 +469,7 @@ class InnerGraphPlugin {
 															const dep = new PureExpressionDependency(
 																/** @type {Range} */ (expression.range)
 															);
-															dep.loc =
-																/** @type {DependencyLocation} */
-																(expression.loc);
+															dep.loc = loc;
 															dep.usedByExports = usedByExports;
 															addPureDependency(module, dep);
 															break;
@@ -484,6 +501,9 @@ class InnerGraphPlugin {
 										onUsageSuper(decl.init.superClass);
 									}
 								} else {
+									// the callback fires after parsing, when the parser can no
+									// longer map offsets — take the location now
+									const loc = parser.getLocation(decl);
 									innerGraph.onUsage(parser.state, (usedByExports, module) => {
 										switch (usedByExports) {
 											case undefined:
@@ -496,7 +516,7 @@ class InnerGraphPlugin {
 														(decl.init).range
 													)
 												);
-												dep.loc = /** @type {DependencyLocation} */ (decl.loc);
+												dep.loc = loc;
 												dep.usedByExports = usedByExports;
 												addPureDependency(module, dep);
 												break;