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

package/lib/ConcatSource.js

@@ -11,6 +11,7 @@ const { getMap, getSourceAndMap } = require("./helpers/getFromStreamChunks");
 const streamChunks = require("./helpers/streamChunks");
 
 /** @typedef {import("./CompatSource").SourceLike} SourceLike */
+/** @typedef {import("./Source").ClearCacheOptions} ClearCacheOptions */
 /** @typedef {import("./Source").HashLike} HashLike */
 /** @typedef {import("./Source").MapOptions} MapOptions */
 /** @typedef {import("./Source").RawSourceMap} RawSourceMap */
@@ -33,15 +34,19 @@ class ConcatSource extends Source {
 	constructor(...args) {
 		super();
 		/**
-		 * @private
 		 * @type {Child[]}
 		 */
 		this._children = [];
 
-		for (const item of args) {
+		// Indexed loops avoid the iterator-protocol overhead `for...of`
+		// pays per element. Hot during webpack's emit when many
+		// ConcatSources are constructed/flattened.
+		for (let i = 0, l = args.length; i < l; i++) {
+			const item = args[i];
 			if (item instanceof ConcatSource) {
-				for (const child of item._children) {
-					this._children.push(child);
+				const children = item._children;
+				for (let j = 0, jl = children.length; j < jl; j++) {
+					this._children.push(children[j]);
 				}
 			} else {
 				this._children.push(item);
@@ -49,7 +54,6 @@ class ConcatSource extends Source {
 		}
 
 		/**
-		 * @private
 		 * @type {boolean}
 		 */
 		this._isOptimized = args.length === 0;
@@ -69,8 +73,9 @@ class ConcatSource extends Source {
 	 */
 	add(item) {
 		if (item instanceof ConcatSource) {
-			for (const child of item._children) {
-				this._children.push(child);
+			const children = item._children;
+			for (let i = 0, l = children.length; i < l; i++) {
+				this._children.push(children[i]);
 			}
 		} else {
 			this._children.push(item);
@@ -83,17 +88,38 @@ class ConcatSource extends Source {
 	 * @returns {void}
 	 */
 	addAllSkipOptimizing(items) {
-		for (const item of items) {
-			this._children.push(item);
+		for (let i = 0, l = items.length; i < l; i++) {
+			this._children.push(items[i]);
 		}
 	}
 
+	/**
+	 * @returns {Buffer} buffer
+	 */
 	buffer() {
+		return Buffer.concat(this.buffers());
+	}
+
+	/**
+	 * @returns {Buffer[]} buffers
+	 */
+	buffers() {
 		if (!this._isOptimized) this._optimize();
+		const children = /** @type {SourceLike[]} */ (this._children);
+		const childCount = children.length;
 		/** @type {Buffer[]} */
 		const buffers = [];
-		for (const child of /** @type {SourceLike[]} */ (this._children)) {
-			if (typeof child.buffer === "function") {
+		// Indexed loop + manual splat avoids the iterator allocation per
+		// child and the inner for-of allocation per child.buffers() call.
+		// Hot path during webpack's emit on deeply-nested ConcatSources.
+		for (let ci = 0; ci < childCount; ci++) {
+			const child = children[ci];
+			if (typeof child.buffers === "function") {
+				const childBuffers = child.buffers();
+				for (let bi = 0, blen = childBuffers.length; bi < blen; bi++) {
+					buffers.push(childBuffers[bi]);
+				}
+			} else if (typeof child.buffer === "function") {
 				buffers.push(child.buffer());
 			} else {
 				const bufferOrString = child.source();
@@ -105,7 +131,7 @@ class ConcatSource extends Source {
 				}
 			}
 		}
-		return Buffer.concat(buffers);
+		return buffers;
 	}
 
 	/**
@@ -113,18 +139,25 @@ class ConcatSource extends Source {
 	 */
 	source() {
 		if (!this._isOptimized) this._optimize();
+		const children = /** @type {Source[]} */ (this._children);
+		const childCount = children.length;
 		let source = "";
-		for (const child of this._children) {
-			source += /** @type {Source} */ (child).source();
+		for (let ci = 0; ci < childCount; ci++) {
+			source += children[ci].source();
 		}
 		return source;
 	}
 
+	/**
+	 * @returns {number} size
+	 */
 	size() {
 		if (!this._isOptimized) this._optimize();
+		const children = /** @type {Source[]} */ (this._children);
+		const childCount = children.length;
 		let size = 0;
-		for (const child of this._children) {
-			size += /** @type {Source} */ (child).size();
+		for (let ci = 0; ci < childCount; ci++) {
+			size += children[ci].size();
 		}
 		return size;
 	}
@@ -169,7 +202,10 @@ class ConcatSource extends Source {
 		const finalSource = Boolean(options && options.finalSource);
 		let code = "";
 		let needToCloseMapping = false;
-		for (const item of /** @type {Source[]} */ (this._children)) {
+		const children = /** @type {Source[]} */ (this._children);
+		const childCount = children.length;
+		for (let ci = 0; ci < childCount; ci++) {
+			const item = children[ci];
 			/** @type {number[]} */
 			const sourceIndexMapping = [];
 			/** @type {number[]} */
@@ -211,11 +247,6 @@ class ConcatSource extends Source {
 						sourceIndex < 0 || sourceIndex >= sourceIndexMapping.length
 							? -1
 							: sourceIndexMapping[sourceIndex];
-					const resultNameIndex =
-						nameIndex < 0 || nameIndex >= nameIndexMapping.length
-							? -1
-							: nameIndexMapping[nameIndex];
-					lastMappingLine = resultSourceIndex < 0 ? 0 : generatedLine;
 					let _chunk;
 					// When using finalSource, we process the entire source code at once at the end, rather than chunk by chunk
 					if (finalSource) {
@@ -224,8 +255,17 @@ class ConcatSource extends Source {
 						_chunk = chunk;
 					}
 					if (resultSourceIndex < 0) {
+						lastMappingLine = 0;
 						onChunk(_chunk, line, column, -1, -1, -1, -1);
 					} else {
+						// Only compute the remapped name index when the chunk
+						// actually carries a source mapping; otherwise it is
+						// unused.
+						const resultNameIndex =
+							nameIndex < 0 || nameIndex >= nameIndexMapping.length
+								? -1
+								: nameIndexMapping[nameIndex];
+						lastMappingLine = generatedLine;
 						onChunk(
 							_chunk,
 							line,
@@ -237,11 +277,11 @@ class ConcatSource extends Source {
 						);
 					}
 				},
-				(i, source, sourceContent) => {
+				(i, source, sourceContent, scopeBindings) => {
 					let globalIndex = sourceMapping.get(source);
 					if (globalIndex === undefined) {
 						sourceMapping.set(source, (globalIndex = sourceMapping.size));
-						onSource(globalIndex, source, sourceContent);
+						onSource(globalIndex, source, sourceContent, scopeBindings);
 					}
 					sourceIndexMapping[i] = globalIndex;
 				},
@@ -287,16 +327,46 @@ class ConcatSource extends Source {
 		};
 	}
 
+	/**
+	 * 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 children = this._children;
+		const { length } = children;
+		let v = visited;
+		if (v === undefined && length > 0) v = new WeakSet();
+		if (v !== undefined) v.add(this);
+		for (let i = 0; i < length; i++) {
+			const child = children[i];
+			if (typeof child !== "string" && typeof child.clearCache === "function") {
+				child.clearCache(options, v);
+			}
+		}
+	}
+
 	/**
 	 * @param {HashLike} hash hash
 	 * @returns {void}
 	 */
 	updateHash(hash) {
 		if (!this._isOptimized) this._optimize();
+		const children = /** @type {Source[]} */ (this._children);
+		const childCount = children.length;
 		hash.update("ConcatSource");
-		for (const item of this._children) {
-			/** @type {Source} */
-			(item).updateHash(hash);
+		for (let ci = 0; ci < childCount; ci++) {
+			children[ci].updateHash(hash);
 		}
 	}
 
@@ -358,7 +428,9 @@ class ConcatSource extends Source {
 				newChildren.push(currentRawSources);
 			}
 		};
-		for (const child of this._children) {
+		const children = this._children;
+		for (let ci = 0, cl = children.length; ci < cl; ci++) {
+			const child = children[ci];
 			if (typeof child === "string") {
 				if (currentString === undefined) {
 					currentString = child;

package/lib/OriginalSource.js

@@ -8,12 +8,12 @@
 const Source = require("./Source");
 const { getMap, getSourceAndMap } = require("./helpers/getFromStreamChunks");
 const getGeneratedSourceInfo = require("./helpers/getGeneratedSourceInfo");
-const splitIntoLines = require("./helpers/splitIntoLines");
-const splitIntoPotentialTokens = require("./helpers/splitIntoPotentialTokens");
+const { eachPotentialToken } = require("./helpers/splitIntoPotentialTokens");
 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 */
@@ -24,32 +24,36 @@ 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 */
 
 class OriginalSource extends Source {
 	/**
 	 * @param {string | Buffer} value value
 	 * @param {string} name name
+	 * @param {ScopeBindings=} scopeBindings what each name this source declares
+	 * evaluates to in the generated code, for the map's `scopes` field
 	 */
-	constructor(value, name) {
+	constructor(value, name, scopeBindings) {
 		super();
 
 		const isBuffer = Buffer.isBuffer(value);
 
 		/**
-		 * @private
 		 * @type {undefined | string}
 		 */
 		this._value = isBuffer ? undefined : value;
 		/**
-		 * @private
 		 * @type {undefined | Buffer}
 		 */
 		this._valueAsBuffer = isBuffer ? value : undefined;
 		/**
-		 * @private
 		 * @type {string}
 		 */
 		this._name = name;
+		/**
+		 * @type {undefined | ScopeBindings}
+		 */
+		this._scopeBindings = scopeBindings;
 	}
 
 	getName() {
@@ -72,6 +76,9 @@ class OriginalSource extends Source {
 		return this._value;
 	}
 
+	/**
+	 * @returns {Buffer} buffer
+	 */
 	buffer() {
 		if (this._valueAsBuffer === undefined) {
 			const value = Buffer.from(/** @type {string} */ (this._value), "utf8");
@@ -83,6 +90,20 @@ class OriginalSource extends Source {
 		return this._valueAsBuffer;
 	}
 
+	/**
+	 * @returns {number} size
+	 */
+	size() {
+		if (this._cachedSize !== undefined) return this._cachedSize;
+		if (this._valueAsBuffer !== undefined) {
+			return (this._cachedSize = this._valueAsBuffer.length);
+		}
+		return (this._cachedSize = Buffer.byteLength(
+			/** @type {string} */ (this._value),
+			"utf8",
+		));
+	}
+
 	/**
 	 * @param {MapOptions=} options map options
 	 * @returns {RawSourceMap | null} map
@@ -112,34 +133,36 @@ class OriginalSource extends Source {
 				/** @type {Buffer} */
 				(this._valueAsBuffer).toString("utf8");
 		}
-		onSource(0, this._name, this._value);
+		onSource(0, this._name, this._value, this._scopeBindings);
 		const finalSource = Boolean(options && options.finalSource);
 		if (!options || options.columns !== false) {
-			// With column info we need to read all lines and split them
-			const matches = splitIntoPotentialTokens(this._value);
+			// With column info we need to walk every potential token. The
+			// scan is streamed by offset (see `eachPotentialToken`) so we
+			// only allocate a chunk substring when one is actually emitted —
+			// and `map()` / `sourceAndMap()` set `finalSource`, in which case
+			// the chunk is dropped and no substring is allocated at all.
+			const value = this._value;
 			let line = 1;
 			let column = 0;
-			if (matches !== null) {
-				for (const match of matches) {
-					const isEndOfLine = match.endsWith("\n");
-					if (isEndOfLine && match.length === 1) {
-						if (!finalSource) onChunk(match, line, column, -1, -1, -1, -1);
-					} else {
-						const chunk = finalSource ? undefined : match;
-						onChunk(chunk, line, column, 0, line, column, -1);
-					}
-					if (isEndOfLine) {
-						line++;
-						column = 0;
-					} else {
-						column += match.length;
-					}
+			eachPotentialToken(value, (start, end, newline) => {
+				const length = end - start;
+				if (newline && length === 1) {
+					if (!finalSource) onChunk("\n", line, column, -1, -1, -1, -1);
+				} else {
+					const chunk = finalSource ? undefined : value.slice(start, end);
+					onChunk(chunk, line, column, 0, line, column, -1);
 				}
-			}
+				if (newline) {
+					line++;
+					column = 0;
+				} else {
+					column += length;
+				}
+			});
 			return {
 				generatedLine: line,
 				generatedColumn: column,
-				source: finalSource ? this._value : undefined,
+				source: finalSource ? value : undefined,
 			};
 		} else if (finalSource) {
 			// Without column info and with final source we only
@@ -165,27 +188,64 @@ class OriginalSource extends Source {
 			}
 			return result;
 		}
-		// Without column info, but also without final source
-		// we need to split source by lines
+		// Without column info, but also without final source.
+		// We only get here when (options.columns === false && !finalSource),
+		// so the source field is always undefined and the chunk arg is always
+		// the line text. Single-pass scan over newlines avoids the
+		// splitIntoLines array allocation.
+		const value = this._value;
+		const len = value.length;
+		if (len === 0) {
+			return { generatedLine: 1, generatedColumn: 0, source: undefined };
+		}
 		let line = 1;
-		const matches = splitIntoLines(this._value);
-		/** @type {string | undefined} */
-		let match;
-		for (match of matches) {
-			onChunk(finalSource ? undefined : match, line, 0, 0, line, 0, -1);
+		let i = 0;
+		while (i < len) {
+			const n = value.indexOf("\n", i);
+			if (n === -1) {
+				const lastLine = i === 0 ? value : value.slice(i);
+				onChunk(lastLine, line, 0, 0, line, 0, -1);
+				return {
+					generatedLine: line,
+					generatedColumn: lastLine.length,
+					source: undefined,
+				};
+			}
+			const chunk = n === i ? "\n" : value.slice(i, n + 1);
+			onChunk(chunk, line, 0, 0, line, 0, -1);
 			line++;
+			i = n + 1;
+		}
+		// Source ended with a newline.
+		return { generatedLine: line, generatedColumn: 0, source: undefined };
+	}
+
+	/**
+	 * 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) {
+			if (visited.has(this)) return;
+			visited.add(this);
+		}
+		if (options !== undefined && options.source === false) return;
+		if (this._value !== undefined && this._valueAsBuffer !== undefined) {
+			// When both forms are cached, drop the string (UTF-16 in V8 is
+			// ~2 bytes/char) and keep the more compact buffer. source() will
+			// rehydrate the string on demand.
+			this._value = undefined;
 		}
-		return matches.length === 0 || /** @type {string} */ (match).endsWith("\n")
-			? {
-					generatedLine: matches.length + 1,
-					generatedColumn: 0,
-					source: finalSource ? this._value : undefined,
-				}
-			: {
-					generatedLine: matches.length,
-					generatedColumn: /** @type {string} */ (match).length,
-					source: finalSource ? this._value : undefined,
-				};
 	}
 
 	/**
@@ -194,7 +254,13 @@ class OriginalSource extends Source {
 	 */
 	updateHash(hash) {
 		hash.update("OriginalSource");
-		hash.update(this.buffer());
+		// Same as RawSource: utf8 is what `buffer()` would have encoded to,
+		// and one of the two forms is always set.
+		if (this._valueAsBuffer === undefined) {
+			hash.update(/** @type {string} */ (this._value));
+		} else {
+			hash.update(this._valueAsBuffer);
+		}
 		hash.update(this._name || "");
 	}
 }

package/lib/PrefixSource.js

@@ -10,6 +10,7 @@ const Source = require("./Source");
 const { getMap, getSourceAndMap } = require("./helpers/getFromStreamChunks");
 const streamChunks = require("./helpers/streamChunks");
 
+/** @typedef {import("./Source").ClearCacheOptions} ClearCacheOptions */
 /** @typedef {import("./Source").HashLike} HashLike */
 /** @typedef {import("./Source").MapOptions} MapOptions */
 /** @typedef {import("./Source").RawSourceMap} RawSourceMap */
@@ -21,7 +22,31 @@ const streamChunks = require("./helpers/streamChunks");
 /** @typedef {import("./helpers/streamChunks").OnSource} OnSource */
 /** @typedef {import("./helpers/streamChunks").Options} Options */
 
-const REPLACE_REGEX = /\n(?=.|\s)/g;
+// `/\n/g` (no lookahead) lets V8's regex compiler take its
+// literal-character fast path; the previous `/\n(?=.|\s)/g` form
+// disabled it. Output stays identical because `buildPrefixed` strips
+// the spurious trailing prefix when the input ended with a newline.
+const NEWLINE_REGEX = /\n/g;
+
+/**
+ * Prepend `prefix` and insert `prefix` after every newline that has
+ * content following — the original `/\n(?=.|\s)/g` semantics, but
+ * implemented as a fast-path regex + tail-strip.
+ * @param {string} prefix prefix
+ * @param {string} node underlying source string
+ * @returns {string} prefixed string
+ */
+const buildPrefixed = (prefix, node) => {
+	if (prefix.length === 0) return node;
+	const replaced = node.replace(NEWLINE_REGEX, `\n${prefix}`);
+	const len = node.length;
+	// `/\n/g` matches the trailing newline too, so the replace appended
+	// a spurious prefix at the end. Trim it.
+	if (len > 0 && node.charCodeAt(len - 1) === 10) {
+		return prefix + replaced.slice(0, replaced.length - prefix.length);
+	}
+	return prefix + replaced;
+};
 
 class PrefixSource extends Source {
 	/**
@@ -31,12 +56,10 @@ class PrefixSource extends Source {
 	constructor(prefix, source) {
 		super();
 		/**
-		 * @private
 		 * @type {string}
 		 */
 		this._prefix = prefix;
 		/**
-		 * @private
 		 * @type {Source}
 		 */
 		this._source =
@@ -57,12 +80,19 @@ class PrefixSource extends Source {
 	 * @returns {SourceValue} source
 	 */
 	source() {
-		const node = /** @type {string} */ (this._source.source());
-		const prefix = this._prefix;
-		return prefix + node.replace(REPLACE_REGEX, `\n${prefix}`);
+		return buildPrefixed(
+			this._prefix,
+			/** @type {string} */ (this._source.source()),
+		);
 	}
 
-	// TODO efficient buffer() implementation
+	// buffer() / buffers() / size() inherit from Source.prototype.
+	// Source.buffer() does Buffer.from(this.source(), "utf8") — cheaper
+	// in CodSpeed instruction count than any safe override we tried
+	// (caching is unsafe with mutable child; a JS-side splice loop
+	// regressed ~5x in instruction count). Speeding up source() via the
+	// simpler regex above lifts buffer(), buffers(), size(), and any
+	// other `this.source()`-using path with no override needed.
 
 	/**
 	 * @param {MapOptions=} options map options
@@ -141,10 +171,7 @@ class PrefixSource extends Source {
 				generatedColumn === 0
 					? 0
 					: prefixOffset + /** @type {number} */ (generatedColumn),
-			source:
-				source !== undefined
-					? prefix + source.replace(REPLACE_REGEX, `\n${prefix}`)
-					: undefined,
+			source: source !== undefined ? buildPrefixed(prefix, source) : undefined,
 		};
 	}
 
@@ -157,6 +184,28 @@ class PrefixSource extends Source {
 		this._source.updateHash(hash);
 		hash.update(this._prefix);
 	}
+
+	/**
+	 * 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;
+		let v = visited;
+		if (v === undefined) v = new WeakSet();
+		v.add(this);
+		this._source.clearCache(options, v);
+	}
 }
 
 module.exports = PrefixSource;