webpack 5.108.4 → 5.109.0

package/lib/RuntimeGlobals.js

@@ -15,6 +15,13 @@ module.exports.amdDefine = "__webpack_require__.amdD";
  */
 module.exports.amdOptions = "__webpack_require__.amdO";
 
+/**
+ * analyzable single-chunk `import()` that keeps `ensureChunk` timing and deduplication:
+ * resolves immediately for an installed chunk, else runs the literal import and installs it
+ * Signature: (chunkId, () => Promise) => Promise
+ */
+module.exports.analyzableChunkImport = "__webpack_require__.ei";
+
 /**
  * Creates an async module. The body function must be a async function.
  * "module.exports" will be decorated with an AsyncModulePromise.
@@ -39,6 +46,15 @@ module.exports.asyncModuleDoneSymbol = "__webpack_require__.aD";
  */
 module.exports.asyncModuleExportSymbol = "__webpack_require__.aE";
 
+/**
+ * Drives an async module body written as a generator function (used when the
+ * target environment supports generators but not `async`/`await`).
+ * It runs the generator, resolving each `yield`ed dependency promise, so the
+ * body reads like a plain `async` function without emitting `async`/`await`.
+ * Signature: function(body: GeneratorFunction) => (handleDependencies, result) => void
+ */
+module.exports.asyncModuleGenerator = "__webpack_require__.aG";
+
 /**
  * the baseURI of current document
  */
@@ -54,6 +70,11 @@ module.exports.chunkCallback = "webpackChunk";
  */
 module.exports.chunkName = "__webpack_require__.cn";
 
+/**
+ * wrap and eagerly execute a CommonJS module body, returning its exports
+ */
+module.exports.commonJsWrap = "__webpack_require__.cjs";
+
 /**
  * compatibility get default export
  */
@@ -195,6 +216,12 @@ module.exports.getTrustedTypesPolicy = "__webpack_require__.tt";
  */
 module.exports.getUpdateManifestFilename = "__webpack_require__.hmrF";
 
+/**
+ * the object url of the worklet bootstrap script (sets up `self`, `location` and
+ * a throwing `importScripts` before worklet chunks are added)
+ */
+module.exports.getWorkletBootstrap = "__webpack_require__.wb";
+
 /**
  * the global object
  */
@@ -331,6 +358,12 @@ module.exports.nodeModuleDecorator = "__webpack_require__.nmd";
  */
 module.exports.onChunksLoaded = "__webpack_require__.O";
 
+/**
+ * the asset prefetch function: injects a
+ * `<link rel="prefetch">` for an asset module URL
+ */
+module.exports.prefetchAsset = "__webpack_require__.PA";
+
 /**
  * the chunk prefetch function
  */
@@ -341,6 +374,12 @@ module.exports.prefetchChunk = "__webpack_require__.E";
  */
 module.exports.prefetchChunkHandlers = "__webpack_require__.F";
 
+/**
+ * the asset preload function: injects a
+ * `<link rel="preload">` for an asset module URL
+ */
+module.exports.preloadAsset = "__webpack_require__.LA";
+
 /**
  * the chunk preload function
  */
@@ -402,6 +441,14 @@ module.exports.shareScopeMap = "__webpack_require__.S";
  */
 module.exports.startup = "__webpack_require__.x";
 
+/**
+ * marker requirement that adds the startup runtime module which fires
+ * `<link rel="prefetch|preload">` for `new URL(..., import.meta.url)`
+ * assets with `webpackPrefetch` / `webpackPreload` hints, before any
+ * chunk module evaluates
+ */
+module.exports.startupAssetHints = "__webpack_require__.SAH";
+
 /**
  * method to startup an entrypoint with needed chunks.
  * Signature: (moduleId: Id, chunkIds: Id[]) => any.

package/lib/RuntimePlugin.js

@@ -9,9 +9,11 @@ const RuntimeGlobals = require("./RuntimeGlobals");
 const { getPresentKinds } = require("./TemplatedPathPlugin");
 const RuntimeRequirementsDependency = require("./dependencies/RuntimeRequirementsDependency");
 const JavascriptModulesPlugin = require("./javascript/JavascriptModulesPlugin");
+const AsyncModuleGeneratorRuntimeModule = require("./runtime/AsyncModuleGeneratorRuntimeModule");
 const AsyncModuleRuntimeModule = require("./runtime/AsyncModuleRuntimeModule");
 const AutoPublicPathRuntimeModule = require("./runtime/AutoPublicPathRuntimeModule");
 const BaseUriRuntimeModule = require("./runtime/BaseUriRuntimeModule");
+const CommonJsWrapRuntimeModule = require("./runtime/CommonJsWrapRuntimeModule");
 const CompatGetDefaultExportRuntimeModule = require("./runtime/CompatGetDefaultExportRuntimeModule");
 const CompatRuntimeModule = require("./runtime/CompatRuntimeModule");
 const CreateFakeNamespaceObjectRuntimeModule = require("./runtime/CreateFakeNamespaceObjectRuntimeModule");
@@ -22,6 +24,7 @@ const EnsureChunkRuntimeModule = require("./runtime/EnsureChunkRuntimeModule");
 const GetChunkFilenameRuntimeModule = require("./runtime/GetChunkFilenameRuntimeModule");
 const GetMainFilenameRuntimeModule = require("./runtime/GetMainFilenameRuntimeModule");
 const GetTrustedTypesPolicyRuntimeModule = require("./runtime/GetTrustedTypesPolicyRuntimeModule");
+const GetWorkletBootstrapRuntimeModule = require("./runtime/GetWorkletBootstrapRuntimeModule");
 const GlobalRuntimeModule = require("./runtime/GlobalRuntimeModule");
 const HasOwnPropertyRuntimeModule = require("./runtime/HasOwnPropertyRuntimeModule");
 const LoadScriptRuntimeModule = require("./runtime/LoadScriptRuntimeModule");
@@ -77,6 +80,7 @@ const GLOBALS_ON_REQUIRE = [
 	RuntimeGlobals.scriptNonce,
 	RuntimeGlobals.uncaughtErrorHandler,
 	RuntimeGlobals.asyncModule,
+	RuntimeGlobals.asyncModuleGenerator,
 	RuntimeGlobals.wasmInstances,
 	RuntimeGlobals.instantiateWasm,
 	RuntimeGlobals.shareScopeMap,
@@ -261,6 +265,12 @@ class RuntimePlugin {
 					);
 					return true;
 				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.commonJsWrap)
+				.tap(PLUGIN_NAME, (chunk) => {
+					compilation.addRuntimeModule(chunk, new CommonJsWrapRuntimeModule());
+					return true;
+				});
 			compilation.hooks.runtimeRequirementInTree
 				.for(RuntimeGlobals.setAnonymousDefaultName)
 				.tap(PLUGIN_NAME, (chunk) => {
@@ -289,8 +299,11 @@ class RuntimePlugin {
 
 					if (publicPath === "auto") {
 						const module = new AutoPublicPathRuntimeModule();
+						// A worklet chunk reads `import.meta.url`, so it needs neither the
+						// worker-scope detection nor the `globalThis` polyfill.
 						if (
 							scriptType !== "module" &&
+							!(entryOptions && entryOptions.worklet) &&
 							!outputOptions.environment.globalThis
 						) {
 							set.add(RuntimeGlobals.global);
@@ -324,6 +337,16 @@ class RuntimePlugin {
 					);
 					return true;
 				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.asyncModuleGenerator)
+				.tap(PLUGIN_NAME, (chunk, set) => {
+					set.add(RuntimeGlobals.asyncModule);
+					compilation.addRuntimeModule(
+						chunk,
+						new AsyncModuleGeneratorRuntimeModule()
+					);
+					return true;
+				});
 			compilation.hooks.runtimeRequirementInTree
 				.for(RuntimeGlobals.systemContext)
 				.tap(PLUGIN_NAME, (chunk) => {
@@ -375,6 +398,16 @@ class RuntimePlugin {
 					);
 					return true;
 				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.getWorkletBootstrap)
+				.tap(PLUGIN_NAME, (chunk, set) => {
+					set.add(RuntimeGlobals.baseURI);
+					compilation.addRuntimeModule(
+						chunk,
+						new GetWorkletBootstrapRuntimeModule()
+					);
+					return true;
+				});
 			compilation.hooks.runtimeRequirementInTree
 				.for(RuntimeGlobals.getChunkCssFilename)
 				.tap(PLUGIN_NAME, (chunk, set, { chunkGraph }) => {

package/lib/RuntimeTemplate.js

@@ -6,6 +6,16 @@
 "use strict";
 
 const InitFragment = require("./InitFragment");
+const {
+	JAVASCRIPT_TYPE,
+	RUNTIME_TYPE
+} = require("./ModuleSourceTypeConstants");
+const {
+	WEBPACK_MODULE_TYPE_CONSUME_SHARED_MODULE,
+	WEBPACK_MODULE_TYPE_FALLBACK,
+	WEBPACK_MODULE_TYPE_PROVIDE,
+	WEBPACK_MODULE_TYPE_REMOTE
+} = require("./ModuleTypeConstants");
 const RuntimeGlobals = require("./RuntimeGlobals");
 const Template = require("./Template");
 const {
@@ -14,11 +24,14 @@ const {
 const { ImportPhaseUtils } = require("./dependencies/ImportPhase");
 const { InlinedUsedName } = require("./optimize/InlineExports");
 const {
+	getDeferredCycleModuleIds,
+	getDeferredCycleModules,
 	getMakeDeferredNamespaceModeFromExportsType,
 	getOptimizedDeferredModule
 } = require("./runtime/MakeDeferredNamespaceObjectRuntime");
 const { equals } = require("./util/ArrayHelpers");
 const compileBooleanMatcher = require("./util/compileBooleanMatcher");
+const { getUndoPath, toJsStringLiteral } = require("./util/identifier");
 const memoize = require("./util/memoize");
 const { propertyAccess, propertyName } = require("./util/property");
 const { forEachRuntime, subtractRuntime } = require("./util/runtime");
@@ -29,6 +42,28 @@ const getHarmonyImportDependency = memoize(() =>
 const getImportDependency = memoize(() =>
 	require("./dependencies/ImportDependency")
 );
+const getJavascriptModulesPlugin = memoize(() =>
+	require("./javascript/JavascriptModulesPlugin")
+);
+const getModuleHotAcceptDependency = memoize(() =>
+	require("./dependencies/ModuleHotAcceptDependency")
+);
+const getAPIPlugin = memoize(() => require("./APIPlugin"));
+
+// Module-federation module types whose chunks load through the federation runtime.
+/** @type {Set<string>} */
+const FEDERATION_MODULE_TYPES = new Set([
+	WEBPACK_MODULE_TYPE_REMOTE,
+	WEBPACK_MODULE_TYPE_PROVIDE,
+	WEBPACK_MODULE_TYPE_CONSUME_SHARED_MODULE,
+	WEBPACK_MODULE_TYPE_FALLBACK
+]);
+
+// Any `[hash]`/`[fullhash]`/`[chunkhash]`/`[contenthash]` token, incl. a `:<length>`
+// or `:<digest>[:<length>]` suffix (e.g. `[contenthash:base64:8]`). Its value is only
+// resolved after code generation, so a filename using one can't be an inline literal.
+const HASH_IN_FILENAME = /\[(?:full|chunk|content)?hash(?::[^\]]+)?\]/;
+const HASH_IN_FILENAME_GLOBAL = /\[(?:full|chunk|content)?hash(?::[^\]]+)?\]/g;
 
 /** @typedef {import("./config/defaults").OutputNormalizedWithDefaults} OutputOptions */
 /** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
@@ -192,6 +227,10 @@ class RuntimeTemplate {
 		return this.outputOptions.environment.asyncFunction;
 	}
 
+	supportsGenerator() {
+		return this.outputOptions.environment.generator;
+	}
+
 	supportsOptionalChaining() {
 		return this.outputOptions.environment.optionalChaining;
 	}
@@ -228,6 +267,24 @@ class RuntimeTemplate {
 		return this.outputOptions.environment.module;
 	}
 
+	supportsModulePreload() {
+		return this.outputOptions.environment.modulePreload;
+	}
+
+	supportsAnalyzableEsm() {
+		// `eval` devtool wraps each module in `eval(...)`, where `import.meta` is a
+		// syntax error, so the literal `new URL(…, import.meta.url)` form can't be used.
+		const { devtool } = this.compilation.options;
+		return (
+			this.isModule() &&
+			this.supportsEcmaScriptModuleSyntax() &&
+			!(typeof devtool === "string" && devtool.includes("eval")) &&
+			// A runtime `__webpack_public_path__` override can't be reflected in a
+			// baked literal, so keep the runtime form that reads `__webpack_require__.p`.
+			!getAPIPlugin().usesRuntimePublicPathOverride(this.compilation)
+		);
+	}
+
 	supportTemplateLiteral() {
 		return this.outputOptions.environment.templateLiteral;
 	}
@@ -805,6 +862,7 @@ class RuntimeTemplate {
 	 * @param {boolean=} options.weak if the dependency is weak (will create a nice error message)
 	 * @param {Dependency} options.dependency dependency
 	 * @param {RuntimeRequirements} options.runtimeRequirements if set, will be filled with runtime requirements
+	 * @param {Module=} options.originModule the module the `import()` is emitted into
 	 * @returns {string} the promise expression
 	 */
 	moduleNamespacePromise({
@@ -816,7 +874,8 @@ class RuntimeTemplate {
 		strict,
 		weak,
 		dependency,
-		runtimeRequirements
+		runtimeRequirements,
+		originModule
 	}) {
 		if (!module) {
 			return this.missingModulePromise({
@@ -846,7 +905,8 @@ class RuntimeTemplate {
 			chunkGraph,
 			block,
 			message,
-			runtimeRequirements
+			runtimeRequirements,
+			originModule
 		});
 
 		/** @type {string} */
@@ -1123,6 +1183,10 @@ class RuntimeTemplate {
 				moduleId,
 				exportsType,
 				Array.from(outgoingAsyncModules, (mod) => chunkGraph.getModuleId(mod)),
+				getDeferredCycleModuleIds(
+					getDeferredCycleModules(moduleGraph, module),
+					(mod) => chunkGraph.getModuleId(mod)
+				),
 				runtimeRequirements
 			)};\n`;
 
@@ -1218,7 +1282,9 @@ class RuntimeTemplate {
 							"Can't inline the exports of defer imported module"
 						);
 					}
-					const access = `${importVar}.a${propertyAccess(Array.isArray(used) ? used : [used])}`;
+					const access = `${importVar}.a${propertyAccess(
+						Array.isArray(used) ? used : [used]
+					)}`;
 					if (isCall || asiSafe === undefined) {
 						return access;
 					}
@@ -1446,9 +1512,16 @@ class RuntimeTemplate {
 	 * @param {string} options.message the message
 	 * @param {ChunkGraph} options.chunkGraph the chunk graph
 	 * @param {RuntimeRequirements} options.runtimeRequirements if set, will be filled with runtime requirements
+	 * @param {Module=} options.originModule the module the `import()` is emitted into
 	 * @returns {string} expression
 	 */
-	blockPromise({ block, message, chunkGraph, runtimeRequirements }) {
+	blockPromise({
+		block,
+		message,
+		chunkGraph,
+		runtimeRequirements,
+		originModule
+	}) {
 		if (!block) {
 			const comment = this.comment({
 				message
@@ -1469,12 +1542,25 @@ class RuntimeTemplate {
 			message,
 			chunkName: block.chunkName
 		});
+		// A `fetchPriority` hint rides on the runtime `ensureChunk(id, priority)` call;
+		// the analyzable literal `import()` can't carry it, so keep the runtime form.
+		const fetchPriority = chunkGroup.options.fetchPriority;
 		if (chunks.length === 1) {
+			const analyzable = fetchPriority
+				? null
+				: this._analyzableChunkImport(
+						chunks[0],
+						comment,
+						runtimeRequirements,
+						originModule,
+						chunkGraph
+					);
+			if (analyzable !== null) {
+				return analyzable;
+			}
 			const chunkId = JSON.stringify(chunks[0].id);
 			runtimeRequirements.add(RuntimeGlobals.ensureChunk);
 
-			const fetchPriority = chunkGroup.options.fetchPriority;
-
 			if (fetchPriority) {
 				runtimeRequirements.add(RuntimeGlobals.hasFetchPriority);
 			}
@@ -1483,30 +1569,232 @@ class RuntimeTemplate {
 				fetchPriority ? `, ${JSON.stringify(fetchPriority)}` : ""
 			})`;
 		} else if (chunks.length > 0) {
-			runtimeRequirements.add(RuntimeGlobals.ensureChunk);
-
-			const fetchPriority = chunkGroup.options.fetchPriority;
-
 			if (fetchPriority) {
 				runtimeRequirements.add(RuntimeGlobals.hasFetchPriority);
 			}
 
+			let needEnsureChunk = false;
 			/**
-			 * Returns require chunk id code.
+			 * Analyzable `import()` for a solely-owned JS chunk, else runtime ensureChunk.
 			 * @param {Chunk} chunk chunk
 			 * @returns {string} require chunk id code
 			 */
-			const requireChunkId = (chunk) =>
-				`${RuntimeGlobals.ensureChunk}(${JSON.stringify(chunk.id)}${
+			const requireChunkId = (chunk) => {
+				const analyzable = fetchPriority
+					? null
+					: this._analyzableChunkImport(
+							chunk,
+							"",
+							runtimeRequirements,
+							originModule,
+							chunkGraph
+						);
+				if (analyzable !== null) return analyzable;
+				needEnsureChunk = true;
+				return `${RuntimeGlobals.ensureChunk}(${JSON.stringify(chunk.id)}${
 					fetchPriority ? `, ${JSON.stringify(fetchPriority)}` : ""
 				})`;
-			return `Promise.all(${comment.trim()}[${chunks
-				.map(requireChunkId)
-				.join(", ")}])`;
+			};
+			const items = chunks.map(requireChunkId);
+			if (needEnsureChunk) {
+				runtimeRequirements.add(RuntimeGlobals.ensureChunk);
+			}
+			return `Promise.all(${comment.trim()}[${items.join(", ")}])`;
 		}
 		return `Promise.resolve(${comment.trim()})`;
 	}
 
+	/**
+	 * For ESM module output, load a single statically-named chunk through the
+	 * `analyzableChunkImport` helper — a literal `import("./chunk.js")` other bundlers
+	 * and webpack itself can follow, wrapped to keep `ensureChunk` timing and deduplication.
+	 * Returns `null` to fall back to the runtime `ensureChunk` form.
+	 * @param {Chunk} chunk the chunk to load
+	 * @param {string} comment leading comment (chunk name / message)
+	 * @param {RuntimeRequirements} runtimeRequirements runtime requirements
+	 * @param {Module=} originModule the module the `import()` is emitted into
+	 * @param {ChunkGraph=} chunkGraph the chunk graph
+	 * @returns {string | null} the import expression, or `null`
+	 */
+	_analyzableChunkImport(
+		chunk,
+		comment,
+		runtimeRequirements,
+		originModule,
+		chunkGraph
+	) {
+		const { outputOptions } = this;
+		if (
+			!outputOptions.module ||
+			outputOptions.chunkFormat !== "module" ||
+			outputOptions.importFunctionName !== "import" ||
+			chunk.id === null ||
+			!originModule ||
+			!chunkGraph
+		) {
+			return null;
+		}
+		// HMR wraps `ensureChunk` (`.e`) to track in-flight loads and relies on it being
+		// present in the runtime; the analyzable `import()` (`.ei`) replaces `.e` and would
+		// leave a lazy-compilation proxy's own `.e` call undefined, so keep the runtime form.
+		// A runtime `__webpack_public_path__` override likewise can't reach a baked literal.
+		if (
+			this.compilation.dependencyFactories.has(
+				getModuleHotAcceptDependency()
+			) ||
+			getAPIPlugin().usesRuntimePublicPathOverride(this.compilation)
+		) {
+			return null;
+		}
+		// A worker entry loads its own chunks through the worker runtime; keep that path.
+		for (const originChunk of chunkGraph.getModuleChunksIterable(
+			originModule
+		)) {
+			const entryOptions = originChunk.getEntryOptions();
+			if (entryOptions && entryOptions.worker) {
+				return null;
+			}
+		}
+		// Only a chunk that is loaded solely through this `import()` and holds pure JS:
+		// a shared chunk (splitChunks / module federation) or one with css/wasm/other
+		// assets needs the runtime's deduplication and per-type loaders, so keep it.
+		if (chunk.getNumberOfGroups() !== 1) {
+			return null;
+		}
+		// Prefetch/preload children (incl. CSS-only preload) are injected by the runtime
+		// `.f` handlers when the chunk loads, which the analyzable `import()` bypasses —
+		// keep the runtime form for them.
+		if (
+			chunk.hasChildByOrder(chunkGraph, "prefetch", true) ||
+			chunk.hasChildByOrder(chunkGraph, "preload", true) ||
+			chunk.hasChildByOrder(chunkGraph, "cssPreload", true)
+		) {
+			return null;
+		}
+		for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
+			// Module federation (remote/shared/provide) loads through its own runtime.
+			if (FEDERATION_MODULE_TYPES.has(module.type)) {
+				return null;
+			}
+			for (const type of chunkGraph.getModuleSourceTypes(module)) {
+				if (type !== JAVASCRIPT_TYPE && type !== RUNTIME_TYPE) {
+					return null;
+				}
+			}
+		}
+		// Relative to the consuming chunk (`import.meta.url`) for `auto`, else an
+		// absolute publicPath prefix.
+		const specifier = this._getAnalyzableChunkSpecifier(
+			undefined,
+			chunk,
+			originModule,
+			chunkGraph
+		);
+		// `import()` needs a resolvable specifier — relative (`./`, `../`), absolute (`/`)
+		// or a URL scheme. A bare one (empty/relative publicPath) is treated as a package,
+		// so keep the runtime form. (`new URL(...)` callers accept bare, resolving vs base.)
+		if (
+			specifier === null ||
+			!/^"(?:\.{0,2}\/|[a-zA-Z][\w+.-]*:)/.test(specifier)
+		) {
+			return null;
+		}
+		runtimeRequirements.add(RuntimeGlobals.analyzableChunkImport);
+		// Drop-in for `ensureChunk(id)`: the literal `import()` can be statically
+		// followed, the helper keeps webpack's install timing and deduplication.
+		return `${RuntimeGlobals.analyzableChunkImport}(${JSON.stringify(
+			chunk.id
+		)}, () => import(${comment}${specifier}))`;
+	}
+
+	/**
+	 * Computes the `../`-path from the consuming module's chunk(s) back to the output
+	 * root, so a chunk or asset can be referenced relative to `import.meta.url`. Returns
+	 * `null` when the module lives in chunks of different depths (no single path works).
+	 * @param {Module} module the consuming module
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @returns {string | null} relative undo path, or `null` when ambiguous
+	 */
+	_getModuleUndoPath(module, chunkGraph) {
+		const { compilation } = this;
+		const { outputOptions } = compilation;
+		const outputPath = /** @type {string} */ (outputOptions.path);
+		/** @type {string | null} */
+		let result = null;
+		let found = false;
+		for (const chunk of chunkGraph.getModuleChunksIterable(module)) {
+			const template = getJavascriptModulesPlugin().getChunkFilenameTemplate(
+				chunk,
+				outputOptions
+			);
+			const chunkName = compilation.getPath(
+				// Hashes aren't known during code generation and only sit in the basename
+				// (never a directory), so neutralize them — only the `../` depth matters.
+				typeof template === "string"
+					? template.replace(HASH_IN_FILENAME_GLOBAL, "x")
+					: template,
+				{ chunk, contentHashType: JAVASCRIPT_TYPE }
+			);
+			const undo = getUndoPath(chunkName, outputPath, true);
+			if (!found) {
+				result = undo;
+				found = true;
+			} else if (result !== undo) {
+				return null;
+			}
+		}
+		return found ? result : null;
+	}
+
+	/**
+	 * Static literal specifier (already quoted) for a `new URL(<here>, import.meta.url)`
+	 * or `import(<here>)` pointing at `chunk`'s JS file, or `null` when it can't be known
+	 * statically — a content hash in the filename, or a dynamic/templated publicPath.
+	 * @param {string | undefined} overridePublicPath per-dependency public path (wins over `output.publicPath`)
+	 * @param {Chunk} chunk the chunk to reference
+	 * @param {Module} consumingModule the module the reference is emitted into
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @returns {string | null} a JS string literal, or `null` to fall back to the runtime form
+	 */
+	_getAnalyzableChunkSpecifier(
+		overridePublicPath,
+		chunk,
+		consumingModule,
+		chunkGraph
+	) {
+		const { compilation } = this;
+		const { outputOptions } = compilation;
+		const filenameTemplate =
+			getJavascriptModulesPlugin().getChunkFilenameTemplate(
+				chunk,
+				outputOptions
+			);
+		if (
+			typeof filenameTemplate !== "string" ||
+			HASH_IN_FILENAME.test(filenameTemplate)
+		) {
+			return null;
+		}
+		const filename = compilation.getPath(filenameTemplate, {
+			chunk,
+			contentHashType: JAVASCRIPT_TYPE
+		});
+		if (overridePublicPath) {
+			return overridePublicPath.includes("[")
+				? null
+				: toJsStringLiteral(overridePublicPath + filename);
+		}
+		const { publicPath } = outputOptions;
+		if (publicPath === "auto") {
+			const undo = this._getModuleUndoPath(consumingModule, chunkGraph);
+			return undo === null ? null : toJsStringLiteral(undo + filename);
+		}
+		if (typeof publicPath === "string" && !publicPath.includes("[")) {
+			return toJsStringLiteral(publicPath + filename);
+		}
+		return null;
+	}
+
 	/**
 	 * Async module factory.
 	 * @param {object} options options

package/lib/UseStrictPlugin.js

@@ -52,7 +52,7 @@ class UseStrictPlugin {
 								"",
 								/** @type {Range} */ (firstNode.range)
 							);
-							dep.loc = /** @type {DependencyLocation} */ (firstNode.loc);
+							dep.loc = parser.getLocation(firstNode);
 							parser.state.module.addPresentationalDependency(dep);
 							/** @type {BuildInfo} */
 							(parser.state.module.buildInfo).strict = true;

package/lib/WebpackIsIncludedPlugin.js

@@ -67,7 +67,7 @@ class WebpackIsIncludedPlugin {
 								/** @type {string} */ (request.string),
 								/** @type {Range} */ (expr.range)
 							);
-							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+							dep.loc = parser.getLocation(expr);
 							parser.state.module.addDependency(dep);
 							return true;
 						});