@depup/webpack-sources 3.3.4-depup.0 → 3.6.0-depup.0

package/README.md

@@ -13,8 +13,8 @@ npm install @depup/webpack-sources
 
 | Field | Value |
 |-------|-------|
-| Original | [webpack-sources](https://www.npmjs.com/package/webpack-sources) @ 3.3.4 |
-| Processed | 2026-03-17 |
+| Original | [webpack-sources](https://www.npmjs.com/package/webpack-sources) @ 3.6.0 |
+| Processed | 2026-09-27 |
 | Smoke test | passed |
 | Deps updated | 0 |
 

package/changes.json

@@ -1,5 +1,5 @@
 {
   "bumped": {},
-  "timestamp": "2026-03-17T16:39:35.097Z",
+  "timestamp": "2026-09-27T01:03:15.009Z",
   "totalUpdated": 0
 }

package/lib/CachedSource.js

@@ -13,6 +13,7 @@ const {
 	isDualStringBufferCachingEnabled,
 } = require("./helpers/stringBufferUtils");
 
+/** @typedef {import("./Source").ClearCacheOptions} ClearCacheOptions */
 /** @typedef {import("./Source").HashLike} HashLike */
 /** @typedef {import("./Source").MapOptions} MapOptions */
 /** @typedef {import("./Source").RawSourceMap} RawSourceMap */
@@ -23,6 +24,7 @@ const {
 /** @typedef {import("./helpers/streamChunks").OnName} OnName */
 /** @typedef {import("./helpers/streamChunks").OnSource} OnSource */
 /** @typedef {import("./helpers/streamChunks").Options} Options */
+/** @typedef {import("./helpers/streamChunks").ScopeBindings} ScopeBindings */
 
 /**
  * @typedef {object} BufferedMap
@@ -55,6 +57,25 @@ const mapToBufferedMap = (map) => {
 	return bufferedMap;
 };
 
+/**
+ * Encodes every string a recorded hash update holds as a buffer, so cached data
+ * handed to a caller carries no big string: a string goes into the serialized
+ * payload, where it is copied in and rebuilt on every deserialization, while a
+ * buffer is carried alongside it. Hashing reads a string as utf8, so the
+ * encoded update hashes the same. It encodes in place, so a source handed out
+ * repeatedly is encoded once, and one that never is keeps its string uncopied.
+ * @param {(string | Buffer)[]=} update recorded hash update
+ * @returns {(string | Buffer)[]=} the update, holding no string
+ */
+const bufferHashUpdate = (update) => {
+	if (update === undefined) return undefined;
+	for (let index = 0; index < update.length; index++) {
+		const item = update[index];
+		if (typeof item === "string") update[index] = Buffer.from(item, "utf8");
+	}
+	return update;
+};
+
 /**
  * @param {null | BufferedMap} bufferedMap buffered map
  * @returns {null | RawSourceMap} map
@@ -75,9 +96,51 @@ const bufferedMapToMap = (bufferedMap) => {
 	return map;
 };
 
-/** @typedef {{ map?: null | RawSourceMap, bufferedMap?: null | BufferedMap }} BufferEntry */
+/**
+ * What replaying an entry streamed for a `scopes` request needs besides its
+ * map. The map only keeps the encoded `scopes` field, so `bindings` holds, by
+ * source index, the bindings each source reported. The field also appended
+ * names to the map, and `names` counts the ones the stream itself reported,
+ * so a replay reports the same names a fresh stream would.
+ * @typedef {object} ScopesReplay
+ * @property {(ScopeBindings | undefined)[]} bindings bindings by source index
+ * @property {number} names number of names the stream reported
+ */
+
+/**
+ * @typedef {{ map?: null | RawSourceMap, bufferedMap?: null | BufferedMap, scopes?: ScopesReplay }} BufferEntry
+ */
 /** @typedef {Map<string, BufferEntry>} BufferedMaps */
 
+const CACHE_KEY_EMPTY = "{}";
+const CACHE_KEY_COLUMNS_FALSE = '{"columns":false}';
+const CACHE_KEY_COLUMNS_TRUE = '{"columns":true}';
+
+/**
+ * Fast-path replacement for `JSON.stringify(options)` when used as a cache
+ * key. MapOptions / streamChunks Options are both small boolean-only shapes
+ * and the overwhelmingly common shapes (`undefined`, `{}`, `{columns}`) can
+ * be keyed without calling `JSON.stringify`, which dominates short-circuit
+ * cache lookups. Falls back to `JSON.stringify` for any other shape so keys
+ * remain compatible with previously cached `BufferedMaps` entries.
+ * @param {undefined | MapOptions | Options} options options
+ * @returns {string} cache key
+ */
+const getCacheKey = (options) => {
+	if (!options) return CACHE_KEY_EMPTY;
+	const { columns } = options;
+	if (
+		/** @type {Options} */ (options).source === undefined &&
+		/** @type {Options} */ (options).finalSource === undefined &&
+		/** @type {MapOptions} */ (options).module === undefined &&
+		/** @type {MapOptions} */ (options).scopes === undefined
+	) {
+		if (columns === undefined) return CACHE_KEY_EMPTY;
+		return columns ? CACHE_KEY_COLUMNS_TRUE : CACHE_KEY_COLUMNS_FALSE;
+	}
+	return JSON.stringify(options);
+};
+
 /**
  * @typedef {object} CachedData
  * @property {boolean=} source source
@@ -95,40 +158,56 @@ class CachedSource extends Source {
 	constructor(source, cachedData) {
 		super();
 		/**
-		 * @private
 		 * @type {Source | (() => Source)}
 		 */
 		this._source = source;
 		/**
-		 * @private
-		 * @type {boolean | undefined}
-		 */
-		this._cachedSourceType = cachedData ? cachedData.source : undefined;
-		/**
-		 * @private
 		 * @type {undefined | string}
 		 */
 		this._cachedSource = undefined;
-		/**
-		 * @private
-		 * @type {Buffer | undefined}
-		 */
-		this._cachedBuffer = cachedData ? cachedData.buffer : undefined;
-		/**
-		 * @private
-		 * @type {number | undefined}
-		 */
-		this._cachedSize = cachedData ? cachedData.size : undefined;
-		/**
-		 * @private
-		 * @type {BufferedMaps}
-		 */
-		this._cachedMaps = cachedData ? cachedData.maps : new Map();
-		/**
-		 * @private
-		 * @type {(string | Buffer)[] | undefined}
-		 */
-		this._cachedHashUpdate = cachedData ? cachedData.hash : undefined;
+		// Split on `cachedData` once instead of re-evaluating the ternary for
+		// every field. Under the interpreter (and CodSpeed's simulation) each
+		// ternary is a separate branch; consolidating cuts the per-instance
+		// branch count roughly in half.
+		if (cachedData) {
+			/**
+			 * @type {boolean | undefined}
+			 */
+			this._cachedSourceType = cachedData.source;
+			/**
+			 * @type {Buffer | undefined}
+			 */
+			this._cachedBuffer = cachedData.buffer;
+			/**
+			 * @type {number | undefined}
+			 */
+			this._cachedSize = cachedData.size;
+			/**
+			 * @type {BufferedMaps | undefined}
+			 */
+			this._cachedMaps = cachedData.maps;
+			/**
+			 * @type {(string | Buffer)[] | undefined}
+			 */
+			this._cachedHashUpdate = cachedData.hash;
+		} else {
+			this._cachedSourceType = undefined;
+			this._cachedBuffer = undefined;
+			this._cachedSize = undefined;
+			this._cachedMaps = undefined;
+			this._cachedHashUpdate = undefined;
+		}
+	}
+
+	/**
+	 * The map cache, created on first use: a source nobody asks a map of holds
+	 * none, since V8 allocates a Map's hash table whether or not it is filled.
+	 * @returns {BufferedMaps} map cache
+	 */
+	_getOrCreateCachedMaps() {
+		const cachedMaps = this._cachedMaps;
+		if (cachedMaps !== undefined) return cachedMaps;
+		return (this._cachedMaps = new Map());
 	}
 
 	/**
@@ -137,26 +216,36 @@ class CachedSource extends Source {
 	getCachedData() {
 		/** @type {BufferedMaps} */
 		const bufferedMaps = new Map();
-		for (const pair of this._cachedMaps) {
-			const [, cacheEntry] = pair;
-			if (cacheEntry.bufferedMap === undefined) {
-				cacheEntry.bufferedMap = mapToBufferedMap(
-					this._getMapFromCacheEntry(cacheEntry),
-				);
+		if (this._cachedMaps !== undefined) {
+			for (const pair of this._cachedMaps) {
+				const [, cacheEntry] = pair;
+				if (cacheEntry.bufferedMap === undefined) {
+					cacheEntry.bufferedMap = mapToBufferedMap(
+						this._getMapFromCacheEntry(cacheEntry),
+					);
+				}
+				/** @type {BufferEntry} */
+				const bufferEntry = {
+					map: undefined,
+					bufferedMap: cacheEntry.bufferedMap,
+				};
+				// Keep the bindings a `scopes` request recorded, so a source
+				// restored from this data replays them without its original.
+				if (cacheEntry.scopes !== undefined) {
+					bufferEntry.scopes = cacheEntry.scopes;
+				}
+				bufferedMaps.set(pair[0], bufferEntry);
 			}
-			bufferedMaps.set(pair[0], {
-				map: undefined,
-				bufferedMap: cacheEntry.bufferedMap,
-			});
 		}
 		return {
-			// We don't want to cache strings
-			// So if we have a caches sources
-			// create a buffer from it and only store
-			// if it was a Buffer or string
-			buffer: this._cachedSource
-				? this.buffer()
-				: /** @type {Buffer} */ (this._cachedBuffer),
+			// `CachedData.buffer` is required (it is the on-disk
+			// serialization format consumed by the
+			// `new CachedSource(source, cachedData)` constructor).
+			// `_cachedBuffer` is populated by `buffer()` calls but a
+			// caller may invoke `getCachedData()` after `clearCache()`
+			// has dropped it; `this.buffer()` rehydrates via the
+			// wrapped source so the contract holds in every state.
+			buffer: this.buffer(),
 			source:
 				this._cachedSourceType !== undefined
 					? this._cachedSourceType
@@ -167,7 +256,7 @@ class CachedSource extends Source {
 							: undefined,
 			size: this._cachedSize,
 			maps: bufferedMaps,
-			hash: this._cachedHashUpdate,
+			hash: bufferHashUpdate(this._cachedHashUpdate),
 		};
 	}
 
@@ -184,15 +273,27 @@ class CachedSource extends Source {
 	 * @returns {SourceValue} source
 	 */
 	source() {
-		const source = this._getCachedSource();
-		if (source !== undefined) return source;
+		// Fully inlined _getCachedSource: both warm- and cold-cache paths skip
+		// the prototype method lookup / stack frame the interpreter would
+		// otherwise pay on every call.
+		if (this._cachedSource !== undefined) return this._cachedSource;
+		const cachedBuffer = this._cachedBuffer;
+		const cachedSourceType = this._cachedSourceType;
+		if (cachedBuffer !== undefined && cachedSourceType !== undefined) {
+			const value = cachedSourceType
+				? cachedBuffer.toString("utf8")
+				: cachedBuffer;
+			if (isDualStringBufferCachingEnabled()) {
+				this._cachedSource = /** @type {string} */ (value);
+			}
+			return /** @type {string} */ (value);
+		}
 		return (this._cachedSource =
 			/** @type {string} */
 			(this.original().source()));
 	}
 
 	/**
-	 * @private
 	 * @param {BufferEntry} cacheEntry cache entry
 	 * @returns {null | RawSourceMap} raw source map
 	 */
@@ -207,7 +308,6 @@ class CachedSource extends Source {
 	}
 
 	/**
-	 * @private
 	 * @returns {undefined | string} cached source
 	 */
 	_getCachedSource() {
@@ -228,6 +328,9 @@ class CachedSource extends Source {
 	 */
 	buffer() {
 		if (this._cachedBuffer !== undefined) return this._cachedBuffer;
+		if (this._cachedBuffers !== undefined) {
+			return (this._cachedBuffer = Buffer.concat(this._cachedBuffers));
+		}
 		if (this._cachedSource !== undefined) {
 			const value = Buffer.isBuffer(this._cachedSource)
 				? this._cachedSource
@@ -251,6 +354,21 @@ class CachedSource extends Source {
 		return value;
 	}
 
+	/**
+	 * @returns {Buffer[]} buffers
+	 */
+	buffers() {
+		if (this._cachedBuffers !== undefined) return this._cachedBuffers;
+		if (this._cachedBuffer !== undefined) {
+			return (this._cachedBuffers = [this._cachedBuffer]);
+		}
+		const original = this.original();
+		if (typeof original.buffers === "function") {
+			return (this._cachedBuffers = original.buffers());
+		}
+		return (this._cachedBuffers = [this.buffer()]);
+	}
+
 	/**
 	 * @returns {number} size
 	 */
@@ -271,8 +389,10 @@ class CachedSource extends Source {
 	 * @returns {SourceAndMap} source and map
 	 */
 	sourceAndMap(options) {
-		const key = options ? JSON.stringify(options) : "{}";
-		const cacheEntry = this._cachedMaps.get(key);
+		const key = getCacheKey(options);
+		const cachedMaps = this._cachedMaps;
+		const cacheEntry =
+			cachedMaps === undefined ? undefined : cachedMaps.get(key);
 		// Look for a cached map
 		if (cacheEntry !== undefined) {
 			// We have a cached map in some representation
@@ -294,7 +414,7 @@ class CachedSource extends Source {
 			map = sourceAndMap.map;
 			this._cachedSource = source;
 		}
-		this._cachedMaps.set(key, {
+		this._getOrCreateCachedMaps().set(key, {
 			map,
 			bufferedMap: undefined,
 		});
@@ -309,19 +429,39 @@ class CachedSource extends Source {
 	 * @returns {GeneratedSourceInfo} generated source info
 	 */
 	streamChunks(options, onChunk, onSource, onName) {
-		const key = options ? JSON.stringify(options) : "{}";
+		const key = getCacheKey(options);
+		const scopes = Boolean(
+			options && /** @type {MapOptions} */ (options).scopes,
+		);
+		const cachedMaps = this._cachedMaps;
+		const cacheEntry =
+			cachedMaps === undefined ? undefined : cachedMaps.get(key);
 		if (
-			this._cachedMaps.has(key) &&
+			cacheEntry !== undefined &&
+			// An entry filled without streaming never saw the bindings, so a
+			// scopes request streams the original once to record them.
+			(!scopes || cacheEntry.scopes !== undefined) &&
 			(this._cachedBuffer !== undefined || this._cachedSource !== undefined)
 		) {
 			const { source, map } = this.sourceAndMap(options);
 			if (map) {
+				const replay = scopes ? cacheEntry.scopes : undefined;
 				return streamChunksOfSourceMap(
 					/** @type {string} */
 					(source),
-					map,
+					replay !== undefined && map.names.length > replay.names
+						? { ...map, names: map.names.slice(0, replay.names) }
+						: map,
 					onChunk,
-					onSource,
+					replay !== undefined
+						? (sourceIndex, source, sourceContent) =>
+								onSource(
+									sourceIndex,
+									source,
+									sourceContent,
+									replay.bindings[sourceIndex],
+								)
+						: onSource,
 					onName,
 					Boolean(options && options.finalSource),
 					true,
@@ -336,17 +476,30 @@ class CachedSource extends Source {
 				Boolean(options && options.finalSource),
 			);
 		}
+		/** @type {ScopesReplay | undefined} */
+		const replay = scopes ? { bindings: [], names: 0 } : undefined;
 		const sourceAndMap = streamAndGetSourceAndMap(
 			this.original(),
 			options,
 			onChunk,
-			onSource,
-			onName,
+			replay !== undefined
+				? (sourceIndex, source, sourceContent, bindings) => {
+						replay.bindings[sourceIndex] = bindings;
+						onSource(sourceIndex, source, sourceContent, bindings);
+					}
+				: onSource,
+			replay !== undefined
+				? (nameIndex, name) => {
+						if (nameIndex >= replay.names) replay.names = nameIndex + 1;
+						onName(nameIndex, name);
+					}
+				: onName,
 		);
 		this._cachedSource = sourceAndMap.source;
-		this._cachedMaps.set(key, {
+		this._getOrCreateCachedMaps().set(key, {
 			map: /** @type {RawSourceMap} */ (sourceAndMap.map),
 			bufferedMap: undefined,
+			scopes: replay,
 		});
 		return sourceAndMap.result;
 	}
@@ -356,19 +509,60 @@ class CachedSource extends Source {
 	 * @returns {RawSourceMap | null} map
 	 */
 	map(options) {
-		const key = options ? JSON.stringify(options) : "{}";
-		const cacheEntry = this._cachedMaps.get(key);
+		const key = getCacheKey(options);
+		const cachedMaps = this._cachedMaps;
+		const cacheEntry =
+			cachedMaps === undefined ? undefined : cachedMaps.get(key);
 		if (cacheEntry !== undefined) {
 			return this._getMapFromCacheEntry(cacheEntry);
 		}
 		const map = this.original().map(options);
-		this._cachedMaps.set(key, {
+		this._getOrCreateCachedMaps().set(key, {
 			map,
 			bufferedMap: undefined,
 		});
 		return map;
 	}
 
+	/**
+	 * Release cached data held by this source. clearCache is a memory
+	 * hint: it never affects correctness or output, only how expensive
+	 * the next read is. Subclasses override; the base is a no-op so
+	 * every Source supports the call. Composite sources always recurse
+	 * into wrapped sources. When the same child is reachable via several
+	 * parents (e.g. modules shared across webpack chunks), pass a shared
+	 * `visited` WeakSet so each subtree is walked at most once.
+	 * Not safe to call concurrently with source/map/sourceAndMap/
+	 * streamChunks/updateHash on the same instance.
+	 * @param {ClearCacheOptions=} options selectors
+	 * @param {WeakSet<Source>=} visited de-duplication set shared across calls
+	 * @returns {void}
+	 */
+	clearCache(options, visited) {
+		if (visited !== undefined && visited.has(this)) return;
+		const clearSource = !options || options.source !== false;
+		const clearMaps = !options || options.maps !== false;
+		if (clearSource) {
+			this._cachedSource = undefined;
+			this._cachedSourceType = undefined;
+			this._cachedBuffer = undefined;
+			this._cachedBuffers = undefined;
+		}
+		if (clearMaps && this._cachedMaps !== undefined) {
+			// Reusing the Map avoids per-call allocation churn when builds
+			// call clearCache thousands of times.
+			this._cachedMaps.clear();
+		}
+		if (typeof this._source !== "function") {
+			let v = visited;
+			if (v === undefined) v = new WeakSet();
+			v.add(this);
+			this._source.clearCache(options, v);
+		} else if (visited !== undefined) {
+			visited.add(this);
+		}
+	}
+
 	/**
 	 * @param {HashLike} hash hash
 	 * @returns {void}

package/lib/CompatSource.js

@@ -7,6 +7,7 @@
 
 const Source = require("./Source");
 
+/** @typedef {import("./Source").ClearCacheOptions} ClearCacheOptions */
 /** @typedef {import("./Source").HashLike} HashLike */
 /** @typedef {import("./Source").MapOptions} MapOptions */
 /** @typedef {import("./Source").RawSourceMap} RawSourceMap */
@@ -17,10 +18,12 @@ const Source = require("./Source");
  * @typedef {object} SourceLike
  * @property {() => SourceValue} source source
  * @property {(() => Buffer)=} buffer buffer
+ * @property {(() => Buffer[])=} buffers buffers
  * @property {(() => number)=} size size
  * @property {((options?: MapOptions) => RawSourceMap | null)=} map map
  * @property {((options?: MapOptions) => SourceAndMap)=} sourceAndMap source and map
  * @property {((hash: HashLike) => void)=} updateHash hash updater
+ * @property {((options?: ClearCacheOptions, visited?: WeakSet<Source>) => void)=} clearCache clear cache
  */
 
 class CompatSource extends Source {
@@ -40,7 +43,6 @@ class CompatSource extends Source {
 	constructor(sourceLike) {
 		super();
 		/**
-		 * @private
 		 * @type {SourceLike}
 		 */
 		this._sourceLike = sourceLike;
@@ -53,6 +55,9 @@ class CompatSource extends Source {
 		return this._sourceLike.source();
 	}
 
+	/**
+	 * @returns {Buffer} buffer
+	 */
 	buffer() {
 		if (typeof this._sourceLike.buffer === "function") {
 			return this._sourceLike.buffer();
@@ -60,6 +65,19 @@ class CompatSource extends Source {
 		return super.buffer();
 	}
 
+	/**
+	 * @returns {Buffer[]} buffers
+	 */
+	buffers() {
+		if (typeof this._sourceLike.buffers === "function") {
+			return this._sourceLike.buffers();
+		}
+		return super.buffers();
+	}
+
+	/**
+	 * @returns {number} size
+	 */
 	size() {
 		if (typeof this._sourceLike.size === "function") {
 			return this._sourceLike.size();
@@ -89,6 +107,29 @@ class CompatSource extends Source {
 		return super.sourceAndMap(options);
 	}
 
+	/**
+	 * Release cached data held by this source. clearCache is a memory
+	 * hint: it never affects correctness or output, only how expensive
+	 * the next read is. Subclasses override; the base is a no-op so
+	 * every Source supports the call. Composite sources always recurse
+	 * into wrapped sources. When the same child is reachable via several
+	 * parents (e.g. modules shared across webpack chunks), pass a shared
+	 * `visited` WeakSet so each subtree is walked at most once.
+	 * Not safe to call concurrently with source/map/sourceAndMap/
+	 * streamChunks/updateHash on the same instance.
+	 * @param {ClearCacheOptions=} options selectors
+	 * @param {WeakSet<Source>=} visited de-duplication set shared across calls
+	 * @returns {void}
+	 */
+	clearCache(options, visited) {
+		if (visited !== undefined && visited.has(this)) return;
+		if (visited !== undefined) visited.add(this);
+		const sourceLike = this._sourceLike;
+		if (typeof sourceLike.clearCache === "function") {
+			sourceLike.clearCache(options, visited);
+		}
+	}
+
 	/**
 	 * @param {HashLike} hash hash
 	 * @returns {void}