webpack 5.107.1 → 5.108.0

package/lib/SourceMapDevToolPlugin.js

@@ -11,6 +11,7 @@ const Compilation = require("./Compilation");
 const ModuleFilenameHelpers = require("./ModuleFilenameHelpers");
 const ProgressPlugin = require("./ProgressPlugin");
 const SourceMapDevToolModuleOptionsPlugin = require("./SourceMapDevToolModuleOptionsPlugin");
+const { getPresentKinds } = require("./TemplatedPathPlugin");
 const createHash = require("./util/createHash");
 const { dirname, relative } = require("./util/fs");
 const generateDebugId = require("./util/generateDebugId");
@@ -36,17 +37,16 @@ const { makePathsAbsolute } = require("./util/identifier");
 /**
  * Defines the source map task type used by this module.
  * @typedef {object} SourceMapTask
- * @property {Source} asset
  * @property {AssetInfo} assetInfo
  * @property {(string | Module)[]} modules
  * @property {string} source
  * @property {string} file
  * @property {RawSourceMap} sourceMap
+ * @property {Source} mapSource the Source instance whose `sourceAndMap` we called (the current asset or, when its map was already stripped, the pinned original from `originalSources`) — what `clearCache` should target
  * @property {ItemCacheFacade} cacheItem cache item
  */
 
 const METACHARACTERS_REGEXP = /[-[\]\\/{}()*+?.^$|]/g;
-const CONTENT_HASH_DETECT_REGEXP = /\[contenthash(?::\w+)?\]/;
 const CSS_AND_JS_MODULE_EXTENSIONS_REGEXP = /\.((c|m)?js|css)($|\?)/i;
 const CSS_EXTENSION_DETECT_REGEXP = /\.css(?:$|\?)/i;
 const MAP_URL_COMMENT_REGEXP = /\[map\]/g;
@@ -111,12 +111,14 @@ const getOriginalSourceRegistry = (compilation) => {
  * The returned source is read from the asset as it currently stands — that way
  * any `sourceMappingURL` comments appended by earlier plugin instances survive
  * — while the map is taken from the pinned original Source when the current
- * one no longer carries it.
+ * one no longer carries it. `mapSource` identifies which Source instance was
+ * actually queried for the map (the current asset, or the pinned original);
+ * that's the one whose internal caches the caller should release.
  * @param {string} file file name
  * @param {Source} asset source object as currently held by the compilation
  * @param {MapOptions} options map extraction options
  * @param {Map<string, Source>} registry compilation-scoped original-source registry
- * @returns {{ source: string, sourceMap: RawSourceMap } | undefined} extracted pair or `undefined` when no map is recoverable
+ * @returns {{ source: string, sourceMap: RawSourceMap, mapSource: Source } | undefined} extracted pair or `undefined` when no map is recoverable
  */
 const extractSourceAndMap = (file, asset, options, registry) => {
 	/** @type {string | Buffer} */
@@ -139,20 +141,20 @@ const extractSourceAndMap = (file, asset, options, registry) => {
 		// that a later plugin instance (which will see a rewrapped asset
 		// without a map) can recover it on demand.
 		if (!registry.has(file)) registry.set(file, asset);
-	} else {
-		// The current asset (typically a `RawSource` left by an earlier
-		// SourceMapDevToolPlugin instance) has no internal map. Re-extract
-		// the map from the original Source we pinned earlier. We keep using
-		// `source` from the current asset so that any prior wrappers (e.g.
-		// appended sourceMappingURL comments) are preserved.
-		const original = registry.get(file);
-		if (!original) return;
-		sourceMap = original.sourceAndMap
-			? original.sourceAndMap(options).map
-			: original.map(options);
-		if (!sourceMap) return;
+		return { source, sourceMap, mapSource: asset };
 	}
-	return { source, sourceMap };
+	// The current asset (typically a `RawSource` left by an earlier
+	// SourceMapDevToolPlugin instance) has no internal map. Re-extract
+	// the map from the original Source we pinned earlier. We keep using
+	// `source` from the current asset so that any prior wrappers (e.g.
+	// appended sourceMappingURL comments) are preserved.
+	const original = registry.get(file);
+	if (!original) return;
+	sourceMap = original.sourceAndMap
+		? original.sourceAndMap(options).map
+		: original.map(options);
+	if (!sourceMap) return;
+	return { source, sourceMap, mapSource: original };
 };
 
 /**
@@ -177,7 +179,7 @@ const getTaskForFile = (
 ) => {
 	const extracted = extractSourceAndMap(file, asset, options, registry);
 	if (!extracted) return;
-	const { source, sourceMap } = extracted;
+	const { source, sourceMap, mapSource } = extracted;
 	const context = compilation.options.context;
 	const root = compilation.compiler.root;
 	const cachedAbsolutify = makePathsAbsolute.bindContextCache(context, root);
@@ -190,10 +192,10 @@ const getTaskForFile = (
 
 	return {
 		file,
-		asset,
 		source: /** @type {string} */ (source),
 		assetInfo,
 		sourceMap,
+		mapSource,
 		modules,
 		cacheItem
 	};
@@ -360,6 +362,25 @@ class SourceMapDevToolPlugin {
 					const tasks = [];
 					let fileIndex = 0;
 
+					// Shared deduplication set for `Source#clearCache` calls below.
+					// Webpack chunks routinely share module-level `CachedSource`
+					// instances. A per-call WeakSet would re-walk those shared
+					// subtrees once per chunk — 50 chunks × thousands of shared
+					// modules in dev/non-minified setups — and worse, every
+					// chunk's `sourceAndMap` would have to recompute the cleared
+					// caches, churning allocations (measured: +700 MB peak RSS,
+					// +6 s wall time on a 50×1000 synthetic build).
+					//
+					// Sharing one set lets each shared subtree be walked exactly
+					// once. The trade-off is that subsequent chunks' `sourceAndMap`
+					// calls can repopulate a shared module's `_cachedMaps` after
+					// its own clear was skipped (because the module is already in
+					// the visited set), leaving at most one populated cache entry
+					// per shared module at the end of the run — bounded to a few
+					// MB even at the scale of #20961. That's strictly preferable
+					// to the alternative's hundreds of MB of transient peak RSS.
+					const clearCacheVisited = new WeakSet();
+
 					asyncLib.each(
 						files,
 						(file, callback) => {
@@ -458,6 +479,44 @@ class SourceMapDevToolPlugin {
 									originalSources
 								);
 
+								// Release the per-instance caches that `sourceAndMap`
+								// just populated. The composed map (and, for
+								// `SourceMapSource`, the parsed `_sourceMapAsObject` /
+								// `_innerSourceMapAsObject`) otherwise sit on the
+								// CachedSource — and every shared child — until phase
+								// 2 replaces the asset, which is what causes the OOM
+								// spike on builds with thousands of chunks
+								// (webpack#20961). Keep `source` since downstream
+								// consumers reading the original asset still need it;
+								// `hash`/`size` default to retained because they're
+								// cheap to keep but expensive to rebuild.
+								// `clearCacheVisited` is shared across every call (see
+								// its declaration above for the rationale).
+								//
+								// Target `task.mapSource` (not `asset.source`): when
+								// `extractSourceAndMap` falls back to the pinned
+								// original (the current asset is a `RawSource` left
+								// by an earlier plugin instance), the `sourceAndMap`
+								// call populated the original's caches, not the
+								// current asset's.
+								//
+								// Feature-detected: `clearCache` landed in
+								// `webpack-sources` 3.5, but `compilation.assets` may
+								// hold `Source`-like instances from a third-party
+								// plugin built against an older copy of
+								// `webpack-sources` (or a hand-rolled implementation).
+								// Calling it unconditionally would throw on those.
+								if (task && typeof task.mapSource.clearCache === "function") {
+									task.mapSource.clearCache(
+										{
+											maps: true,
+											source: false,
+											parsedMap: true
+										},
+										clearCacheVisited
+									);
+								}
+
 								if (task) {
 									const modules = task.modules;
 
@@ -622,10 +681,8 @@ class SourceMapDevToolPlugin {
 									}
 
 									const usesContentHash =
-										sourceMapFilename &&
-										CONTENT_HASH_DETECT_REGEXP.test(sourceMapFilename);
-
-									resetRegexpState(CONTENT_HASH_DETECT_REGEXP);
+										typeof sourceMapFilename === "string" &&
+										getPresentKinds(sourceMapFilename).has("contenthash");
 
 									let outputFile = file;
 									// If SourceMap and asset uses contenthash, avoid a circular dependency by hiding hash in `file`
@@ -698,12 +755,23 @@ class SourceMapDevToolPlugin {
 										outputSourceMap.debugId = debugIdValue;
 									}
 
-									const sourceMapString = JSON.stringify(outputSourceMap);
 									if (sourceMapFilename) {
+										// External `.map` file: hold the serialized map as a
+										// `Buffer` instead of a V8 string. `RawSource` accepts
+										// a buffer directly, and the emitted asset stays in
+										// `compilation.assets` until the build finishes — so
+										// storing the bytes off the V8 heap (where Buffers
+										// live, accounted as `external` memory) avoids keeping
+										// a large V8 string alive for the rest of the build
+										// and reduces heap pressure on `--max-old-space-size`.
+										const sourceMapBuffer = Buffer.from(
+											JSON.stringify(outputSourceMap),
+											"utf8"
+										);
 										const filename = file;
 										const sourceMapContentHash = usesContentHash
 											? createHash(compilation.outputOptions.hashFunction)
-													.update(sourceMapString)
+													.update(sourceMapBuffer)
 													.digest("hex")
 											: undefined;
 
@@ -775,7 +843,7 @@ class SourceMapDevToolPlugin {
 										assetsInfo[file] = assetInfo;
 										compilation.updateAsset(file, asset, assetInfo);
 										// Add source map file to compilation assets and chunk files
-										const sourceMapAsset = new RawSource(sourceMapString);
+										const sourceMapAsset = new RawSource(sourceMapBuffer);
 										const sourceMapAssetInfo = {
 											...sourceMapInfo,
 											development: true
@@ -801,6 +869,16 @@ class SourceMapDevToolPlugin {
 												`${PLUGIN_NAME}: append can't be a function when no filename is provided`
 											);
 										}
+										// Inline data-URL form: `[map]` gets the raw JSON, `[url]`
+										// gets the same JSON base64-encoded. `URL_COMMENT_REGEXP`
+										// is a `/g` regex, so a user `append` template with more
+										// than one `[url]` placeholder would otherwise re-encode
+										// the same JSON per match. Pre-compute both once.
+										const sourceMapString = JSON.stringify(outputSourceMap);
+										const sourceMapBase64 = Buffer.from(
+											sourceMapString,
+											"utf8"
+										).toString("base64");
 										/**
 										 * Add source map as data url to asset
 										 */
@@ -811,10 +889,7 @@ class SourceMapDevToolPlugin {
 												.replace(
 													URL_COMMENT_REGEXP,
 													() =>
-														`data:application/json;charset=utf-8;base64,${Buffer.from(
-															sourceMapString,
-															"utf8"
-														).toString("base64")}`
+														`data:application/json;charset=utf-8;base64,${sourceMapBase64}`
 												)
 										);
 										assets[file] = asset;

package/lib/Stats.js

@@ -16,6 +16,7 @@ class Stats {
 	 * @param {Compilation} compilation webpack compilation
 	 */
 	constructor(compilation) {
+		/** @type {Compilation} */
 		this.compilation = compilation;
 	}
 

package/lib/Template.js

@@ -34,6 +34,10 @@ const NUMBER_OF_IDENTIFIER_START_CHARS = DELTA_A_TO_Z * 2 + 2; // a-z A-Z _ $
 const NUMBER_OF_IDENTIFIER_CONTINUATION_CHARS =
 	NUMBER_OF_IDENTIFIER_START_CHARS + 10; // a-z A-Z _ $ 0-9
 const FUNCTION_CONTENT_REGEX = /^function\s?\(\)\s?\{\r?\n?|\r?\n?\}$/g;
+// JSDoc type annotations exist only to type the runtime template; strip them so
+// they are never emitted into the bundle. Whole-line blocks drop the line too.
+const JSDOC_LINE_REGEX = /^[ \t]*\/\*\*(?:[^*]|\*(?!\/))*\*\/[ \t]*\r?\n/gm;
+const JSDOC_INLINE_REGEX = /\/\*\*(?:[^*]|\*(?!\/))*\*\/[ \t]*/g;
 const INDENT_MULTILINE_REGEX = /^\t/gm;
 const LINE_SEPARATOR_REGEX = /\r?\n/g;
 const IDENTIFIER_NAME_REPLACE_REGEX = /^([^a-z$_])/i;
@@ -102,6 +106,8 @@ class Template {
 	static getFunctionContent(fn) {
 		return fn
 			.toString()
+			.replace(JSDOC_LINE_REGEX, "")
+			.replace(JSDOC_INLINE_REGEX, "")
 			.replace(FUNCTION_CONTENT_REGEX, "")
 			.replace(INDENT_MULTILINE_REGEX, "")
 			.replace(LINE_SEPARATOR_REGEX, "\n");
@@ -126,7 +132,7 @@ class Template {
 	 */
 	static toComment(str) {
 		if (!str) return "";
-		return `/*! ${str.replace(COMMENT_END_REGEX, "* /")} */`;
+		return `/*! ${str.includes("*/") ? str.replace(COMMENT_END_REGEX, "* /") : str} */`;
 	}
 
 	/**
@@ -136,7 +142,7 @@ class Template {
 	 */
 	static toNormalComment(str) {
 		if (!str) return "";
-		return `/* ${str.replace(COMMENT_END_REGEX, "* /")} */`;
+		return `/* ${str.includes("*/") ? str.replace(COMMENT_END_REGEX, "* /") : str} */`;
 	}
 
 	/**