webpack 5.110.0 → 5.110.2

package/lib/util/removeBOM.js

@@ -5,12 +5,17 @@
 
 "use strict";
 
+const { decodeVLQ, encodeVLQ } = require("./createMappings");
+
+/** @import { RawSourceMap } from "webpack-sources" */
+/** @import { Result } from "../NormalModule" */
+
 /**
  * Returns result without BOM.
  * @param {string | Buffer} strOrBuffer string or buffer
  * @returns {string | Buffer} result without BOM
  */
-module.exports = (strOrBuffer) => {
+const removeBOM = (strOrBuffer) => {
 	if (typeof strOrBuffer === "string" && strOrBuffer.charCodeAt(0) === 0xfeff) {
 		return strOrBuffer.slice(1);
 	} else if (
@@ -24,3 +29,79 @@ module.exports = (strOrBuffer) => {
 
 	return strOrBuffer;
 };
+
+/**
+ * A BOM occupies generated column 0 of the first line, so a map describing
+ * BOM-prefixed content starts that line at column 1 or later. Removing the BOM
+ * moves the line one column left; the segments after the first are encoded
+ * relative to it, so only the first is rewritten. A map already starting at
+ * column 0 describes the content without its BOM and is left alone.
+ * @param {string} mappings VLQ encoded `mappings` of a map for BOM-prefixed content
+ * @returns {string} `mappings` for the same content without its BOM
+ */
+const shiftMappings = (mappings) => {
+	const { value, end } = decodeVLQ(mappings, 0);
+	if (end === 0 || value <= 0) return mappings;
+	return encodeVLQ(value - 1) + mappings.slice(end);
+};
+
+/**
+ * Adjust a source map that accompanied BOM-prefixed content for the removal of
+ * that BOM. Anything without VLQ `mappings` is passed through untouched, as is
+ * a map declaring a version other than 3 — earlier versions spell `mappings`
+ * differently. A map that declares no version at all is taken as version 3.
+ * @param {(string | RawSourceMap)=} sourceMap the map, as an object or as JSON
+ * @returns {(string | RawSourceMap)=} the adjusted map
+ */
+const adjustSourceMapForRemovedBOM = (sourceMap) => {
+	if (!sourceMap) return sourceMap;
+
+	if (typeof sourceMap === "string") {
+		/** @type {RawSourceMap} */
+		let parsed;
+		try {
+			parsed = JSON.parse(sourceMap);
+		} catch (_err) {
+			return sourceMap;
+		}
+		const adjusted = adjustSourceMapForRemovedBOM(parsed);
+		return adjusted === parsed ? sourceMap : JSON.stringify(adjusted);
+	}
+
+	if (sourceMap.version !== undefined && sourceMap.version !== 3) {
+		return sourceMap;
+	}
+
+	if (typeof sourceMap.mappings !== "string") return sourceMap;
+
+	const mappings = shiftMappings(sourceMap.mappings);
+
+	return mappings === sourceMap.mappings
+		? sourceMap
+		: { ...sourceMap, mappings };
+};
+
+/**
+ * @param {Result} result a loader result: content, an optional source map, extra info
+ * @returns {Result} the result with a leading BOM removed from its content and its source map kept in sync
+ */
+const removeBOMFromResult = (result) => {
+	const content = result[0];
+	const withoutBOM = removeBOM(content);
+
+	if (withoutBOM === content) return result;
+
+	// Copied rather than rebuilt, so a result carrying no source map keeps its
+	// arity.
+	const adjusted = /** @type {Result} */ ([...result]);
+
+	adjusted[0] = withoutBOM;
+
+	if (adjusted[1]) adjusted[1] = adjustSourceMapForRemovedBOM(adjusted[1]);
+
+	return adjusted;
+};
+
+module.exports.adjustSourceMapForRemovedBOM = adjustSourceMapForRemovedBOM;
+module.exports.removeBOM = removeBOM;
+module.exports.removeBOMFromResult = removeBOMFromResult;

package/lib/wasm-async/AsyncWasmCompileRuntimeModule.js

@@ -11,11 +11,12 @@ const Template = require("../Template");
 const { fullHashPathData } = require("../wasm/wasmModuleFilename");
 
 /** @import Chunk from "../Chunk" */
+/** @import ChunkGraph from "../ChunkGraph" */
 /** @import Compilation from "../Compilation" */
 /** @import { RuntimeSpec } from "../util/runtime" */
 
 /** @typedef {(wasmModuleSrcPath: string) => string} GenerateBeforeLoadBinaryCode */
-/** @typedef {(wasmModuleSrcPath: string, runtime: RuntimeSpec) => string} GenerateLoadBinaryCode */
+/** @typedef {(wasmModuleSrcPath: string, runtime: RuntimeSpec, analyzable: boolean) => string} GenerateLoadBinaryCode */
 /** @typedef {() => string} GenerateBeforeCompileStreaming */
 
 /**
@@ -69,7 +70,7 @@ class AsyncWasmCompileRuntimeModule extends RuntimeModule {
 		// Analyzable output bakes the binary's URL into the call site instead.
 		const analyzable = runtimeTemplate.supportsAnalyzable(
 			"wasm",
-			undefined,
+			/** @type {ChunkGraph} */ (this.chunkGraph),
 			undefined,
 			chunk.runtime
 		);
@@ -92,7 +93,8 @@ class AsyncWasmCompileRuntimeModule extends RuntimeModule {
 
 		const loader = this.generateLoadBinaryCode(
 			wasmModuleSrcPath,
-			chunk.runtime
+			chunk.runtime,
+			analyzable
 		);
 
 		// Fallback path: fetch -> arrayBuffer -> WebAssembly.compile

package/lib/wasm-async/AsyncWasmLoadingRuntimeModule.js

@@ -11,11 +11,12 @@ const Template = require("../Template");
 const { fullHashPathData } = require("../wasm/wasmModuleFilename");
 
 /** @import Chunk from "../Chunk" */
+/** @import ChunkGraph from "../ChunkGraph" */
 /** @import Compilation from "../Compilation" */
 /** @import { RuntimeSpec } from "../util/runtime" */
 
 /** @typedef {(wasmModuleSrcPath: string) => string} GenerateBeforeLoadBinaryCode */
-/** @typedef {(wasmModuleSrcPath: string, runtime: RuntimeSpec) => string} GenerateLoadBinaryCode */
+/** @typedef {(wasmModuleSrcPath: string, runtime: RuntimeSpec, analyzable: boolean) => string} GenerateLoadBinaryCode */
 /** @typedef {() => string} GenerateBeforeInstantiateStreaming */
 
 /**
@@ -70,7 +71,7 @@ class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
 		// Analyzable output bakes the binary's URL into the call site instead.
 		const analyzable = runtimeTemplate.supportsAnalyzable(
 			"wasm",
-			undefined,
+			/** @type {ChunkGraph} */ (this.chunkGraph),
 			undefined,
 			chunk.runtime
 		);
@@ -93,7 +94,8 @@ class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
 
 		const loader = this.generateLoadBinaryCode(
 			wasmModuleSrcPath,
-			chunk.runtime
+			chunk.runtime,
+			analyzable
 		);
 		const fallback = [
 			`.then(${runtimeTemplate.returningFunction("x.arrayBuffer()", "x")})`,

package/lib/wasm-async/AsyncWebAssemblyJavascriptGenerator.js

@@ -302,7 +302,9 @@ class AsyncWebAssemblyJavascriptGenerator extends Generator {
 	 * @returns {Source | null} generated code
 	 */
 	generateError(error, module, generateContext) {
-		return new RawSource(`throw new Error(${JSON.stringify(error.message)});`);
+		return new RawSource(
+			Generator.throwBuildErrorCode(error, "WebAssembly.CompileError")
+		);
 	}
 }
 

package/lib/wasm-async/UniversalCompileAsyncWasmPlugin.js

@@ -67,31 +67,26 @@ class UniversalCompileAsyncWasmPlugin {
 			// per call: it depends on parse results, so it is not settled while the plugin
 			// is being applied.
 			/**
-			 * @param {RuntimeSpec} runtime the runtime this loader serves
+			 * @param {boolean} analyzable whether the call site bakes a complete URL
 			 * @returns {string} the argument to hand the reader
 			 */
-			const wasmUrlArg = (runtime) =>
-				compilation.runtimeTemplate.supportsAnalyzable(
-					"wasm",
-					undefined,
-					undefined,
-					runtime
-				)
+			const wasmUrlArg = (analyzable) =>
+				analyzable
 					? "wasmUrl"
 					: compilation.runtimeTemplate.importMetaUrl("wasmUrl");
 			/**
 			 * Generates the runtime expression that fetches the binary in browsers
 			 * or reads it from the filesystem in Node.js.
-			 * @type {(path: string, runtime: RuntimeSpec) => string}
+			 * @type {(path: string, runtime: RuntimeSpec, analyzable: boolean) => string}
 			 */
-			const generateLoadBinaryCode = (path, runtime) =>
+			const generateLoadBinaryCode = (path, runtime, analyzable) =>
 				Template.asString([
 					"(useFetch",
-					Template.indent([`? fetch(${wasmUrlArg(runtime)})`]),
+					Template.indent([`? fetch(${wasmUrlArg(analyzable)})`]),
 					Template.indent([
 						": Promise.all([import('fs'), import('url')]).then(([{ readFile }, { URL }]) => new Promise((resolve, reject) => {",
 						Template.indent([
-							`readFile(${wasmUrlArg(runtime)}, (err, buffer) => {`,
+							`readFile(${wasmUrlArg(analyzable)}, (err, buffer) => {`,
 							Template.indent([
 								"if (err) return reject(err);",
 								"",

package/lib/wasm-sync/WebAssemblyJavascriptGenerator.js

@@ -231,7 +231,9 @@ class WebAssemblyJavascriptGenerator extends Generator {
 	 * @returns {Source | null} generated code
 	 */
 	generateError(error, module, generateContext) {
-		return new RawSource(`throw new Error(${JSON.stringify(error.message)});`);
+		return new RawSource(
+			Generator.throwBuildErrorCode(error, "WebAssembly.CompileError")
+		);
 	}
 }
 

package/lib/web/FetchCompileAsyncWasmPlugin.js

@@ -91,12 +91,14 @@ class FetchCompileAsyncWasmPlugin {
 					}
 					const baked = compilation.runtimeTemplate.supportsAnalyzable(
 						"wasm",
-						undefined,
+						chunkGraph,
 						undefined,
 						chunk.runtime
 					);
-					const analyzable =
-						compilation.runtimeTemplate.supportsAnalyzable("wasm-relative");
+					const analyzable = compilation.runtimeTemplate.supportsAnalyzable(
+						"wasm-relative",
+						chunkGraph
+					);
 					// A baked URL carries the public path already, and a settled one is written
 					// out below; only a path nothing but the global knows asks for it.
 					const constant =
@@ -151,12 +153,14 @@ class FetchCompileAsyncWasmPlugin {
 					}
 					const baked = compilation.runtimeTemplate.supportsAnalyzable(
 						"wasm",
-						undefined,
+						chunkGraph,
 						undefined,
 						chunk.runtime
 					);
-					const analyzable =
-						compilation.runtimeTemplate.supportsAnalyzable("wasm-relative");
+					const analyzable = compilation.runtimeTemplate.supportsAnalyzable(
+						"wasm-relative",
+						chunkGraph
+					);
 					// A baked URL carries the public path already, and a settled one is written
 					// out below; only a path nothing but the global knows asks for it.
 					const constant =

package/lib/web/FetchCompileWasmPlugin.js

@@ -99,8 +99,10 @@ class FetchCompileWasmPlugin {
 						return;
 					}
 					set.add(RuntimeGlobals.moduleCache);
-					const analyzable =
-						compilation.runtimeTemplate.supportsAnalyzable("wasm-relative");
+					const analyzable = compilation.runtimeTemplate.supportsAnalyzable(
+						"wasm-relative",
+						chunkGraph
+					);
 					const constant = analyzable
 						? undefined
 						: compilation.runtimeTemplate.constantPublicPath();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webpack",
-  "version": "5.110.0",
+  "version": "5.110.2",
   "description": "Packs ECMAScript/CommonJs/AMD modules for the browser. Allows you to split your codebase into multiple bundles, which can be loaded on demand. Supports loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.",
   "homepage": "https://github.com/webpack/webpack",
   "bugs": "https://github.com/webpack/webpack/issues",

package/types.d.ts

@@ -355,6 +355,18 @@ declare interface AllCodeGenerationSchemas {
 	 */
 	"share-init": [{ shareScope: string; initStage: number; init: string }];
 }
+declare interface AnalyzableChunkUrls {
+	/**
+	 * the urls that could be written, by chunk id
+	 */
+	urls: Map<ChunkId, string>;
+
+	/**
+	 * false when some chunk kept the runtime form, whose
+	 * ids the consumer then still resolves through the runtime name lookup
+	 */
+	complete: boolean;
+}
 type AnalyzableForm =
 	"import" | "url" | "url-runtime" | "url-inline" | "wasm" | "wasm-relative";
 type AnyLoaderContext = NormalModuleLoaderContext<any> &
@@ -6108,13 +6120,14 @@ declare interface DefaultHandlerOptions {
 	estimatedTime?: boolean;
 	phaseTimings?: boolean;
 }
-
-declare interface DeferredEmbeddedSource {
-	source: string;
-	build: (answer?: string) => string;
+type DeferredEmbeddedSource = DeferredWrite & {
 	type: string;
 	hostType: string;
 	as?: string;
+};
+declare interface DeferredWrite {
+	source: string;
+	build: (answer?: string) => string;
 }
 type DefineConfigInput =
 	| Configuration
@@ -8130,6 +8143,12 @@ declare abstract class ExportInfo {
 		resolveTargetFilter?: (target: TargetItemWithConnection) => boolean
 	): undefined | TargetItemWithConnection;
 
+	/**
+	 * Returns whether resolving the target leads back to this export, which
+	 * `getTarget` cannot express as it reports a cycle as "no target".
+	 */
+	hasCircularTarget(moduleGraph: ModuleGraph): boolean;
+
 	/**
 	 * Move the target forward as long resolveTargetFilter is fulfilled
 	 */
@@ -8169,6 +8188,7 @@ declare abstract class ExportMode {
 	items: null | NormalReexportItem[];
 	name: null | string;
 	partialNamespaceExportInfo: null | ExportInfo;
+	circular: boolean;
 	ignored: null | Set<string>;
 	hidden?: null | Set<string>;
 	userRequest: null | string;
@@ -9482,6 +9502,14 @@ declare class Generator {
 	static byType(map: {
 		[index: string]: undefined | Generator;
 	}): ByTypeGenerator;
+
+	/**
+	 * Returns the statement a module that failed to build throws when executed.
+	 */
+	static throwBuildErrorCode(
+		error: Error,
+		parseErrorConstructor?: string
+	): string;
 }
 declare interface GeneratorOptions {
 	[index: string]: any;
@@ -9884,6 +9912,9 @@ declare class HarmonyImportDependencyTemplate extends DependencyTemplate {
 		referencedModule: Module
 	): undefined | string | boolean | SortableSet<string>;
 }
+declare abstract class HarmonyImportSideEffectDependency extends HarmonyImportDependency {
+	unusedSpecifiers?: UnusedSpecifiers;
+}
 declare interface HarmonySettings {
 	ids: string[];
 	source: string;
@@ -9892,6 +9923,16 @@ declare interface HarmonySettings {
 	await: boolean;
 	attributes?: ImportAttributes;
 	phase: ImportPhaseType;
+
+	/**
+	 * whether the binding is referenced anywhere
+	 */
+	used: boolean;
+
+	/**
+	 * the statement's own dependency
+	 */
+	dependency?: HarmonyImportSideEffectDependency;
 }
 declare abstract class HarmonyStarExportsList {
 	dependencies: HarmonyExportImportedSpecifierDependency[];
@@ -26081,10 +26122,24 @@ declare abstract class RuntimeTemplate {
 	 */
 	chunkRootOutputDir(chunk: Chunk, enforceRelative: boolean): string;
 
+	/**
+	 * Static literal specifier (already quoted) for the `new URL(<here>, import.meta.url)`
+	 * a worker or worklet entry chunk bakes to, or `null` to keep the runtime form. The
+	 * gate and the build are asked together so every call site agrees on both — the
+	 * `new Worker(...)` emit, and the resource hint `ResourceHintPlugin` spells for it.
+	 */
+	getAnalyzableWorkerUrl(
+		overridePublicPath: undefined | string,
+		chunk: Chunk,
+		module: Module,
+		chunkGraph: ChunkGraph,
+		runtimeRequirements: Set<string>
+	): null | string;
+
 	/**
 	 * Static `new URL(<file>, import.meta.url)` for every stylesheet a runtime can load,
-	 * keyed by chunk id, or `null` when any of them has to keep the runtime
-	 * `publicPath + getChunkCssFilename(id)` form. Both the runtime module reading them
+	 * keyed by chunk id — one that cannot be named leaves the map incomplete, and its
+	 * id keeps the runtime `publicPath + getChunkCssFilename(id)` form. Both the runtime module reading them
 	 * and the plugin declaring what it needs ask this, so the two always agree. The
 	 * runtime hands an absolute url string to `link.href`, and so does this — the browser
 	 * resolves the element against the document, which is not where the chunk sits, and
@@ -26096,13 +26151,13 @@ declare abstract class RuntimeTemplate {
 		chunkGraph: ChunkGraph,
 		runtimeRequirements: ReadonlySet<string>,
 		consumingModule?: Module
-	): null | Map<ChunkId, string>;
+	): null | AnalyzableChunkUrls;
 
 	/**
 	 * Static `new URL(<file>, import.meta.url).href` for every javascript chunk a
 	 * runtime can hint at with `<link rel="prefetch"/"modulepreload">`, keyed by chunk
-	 * id, or `null` when any of them has to keep the runtime
-	 * `publicPath + getChunkScriptFilename(id)` form. Both the runtime module reading
+	 * id — one that cannot be named leaves the map incomplete, and its id keeps the
+	 * runtime `publicPath + getChunkScriptFilename(id)` form. Both the runtime module reading
 	 * them and the plugin declaring what it needs ask this, so the two always agree.
 	 */
 	analyzableChunkScriptUrls(
@@ -26110,7 +26165,7 @@ declare abstract class RuntimeTemplate {
 		chunkGraph: ChunkGraph,
 		runtimeRequirements: ReadonlySet<string>,
 		consumingModule?: Module
-	): null | Map<ChunkId, string>;
+	): null | AnalyzableChunkUrls;
 
 	/**
 	 * Static `new URL(<file>, import.meta.url)` for the binary emitted for an async wasm
@@ -27148,6 +27203,10 @@ declare class SourceProcessorSyntaxClass_1 extends SourceProcessorClass<
 > {
 	constructor();
 	static PrintContext: typeof PrintContext;
+	static declineDeferredWrites: (
+		text: string,
+		writes: DeferredWrite[]
+	) => string;
 	static deferredWrite: (id: number) => string;
 }
 
@@ -27217,6 +27276,10 @@ declare class SourceProcessorSyntaxClass_2 extends SourceProcessorClass<
 > {
 	constructor();
 	static PrintContext: typeof PrintContext;
+	static declineDeferredWrites: (
+		text: string,
+		writes: DeferredWrite[]
+	) => string;
 	static deferredWrite: (id: number) => string;
 }
 declare interface SourceTable {
@@ -28755,6 +28818,10 @@ declare interface TsconfigPathsMap {
 declare const UNDEFINED_MARKER: unique symbol;
 declare interface URL_url extends URL {}
 type UnsafeCacheData = KnownUnsafeCacheData & Record<string, any>;
+declare interface UnusedSpecifiers {
+	exportPresenceMode: ExportPresenceMode;
+	specifiers: [string[], string][];
+}
 declare interface UpdateHashContextDependency {
 	chunkGraph: ChunkGraph;
 	runtime: RuntimeSpec;