perf(prefix-source): use V8 fast-path regex (no lookahead) in source()

claude · claude · commit dac0eb8e1df9 · 2026-04-29T09:31:15.000Z
The /\n(?=.|\s)/g lookahead form disables V8's literal-character regex fast-path. Switching to /\n/g + a tail-strip when the input ends with a newline produces identical output and lets V8 take the fast path — faster CPU and lower instruction count. Hoists the prefixed-string builder into a `buildPrefixed(prefix, node)` helper used by both source() and streamChunks(), so the two callsites stay in sync. Drops the buffers() override that landed earlier in this branch: - source() got faster, so the inherited Source.buffer() (which goes through this.source() + Buffer.from) automatically gets faster too; - the inherited Source.buffers() = [this.buffer()] therefore also speeds up — the prior splice-based buffers() override regressed ~3.6x in CodSpeed instruction count and is replaced by the leaner inheritance path. Local A/B/A wall-clock (es6-promise.js fixture, 5 alternating runs): source(): 1592 -> 1766 ops/s (+11%) buffer(): 1149 -> 1520 ops/s (+32%) buffers(): inherited, now ~1506 ops/s size(): inherited, now ~1516 ops/s Mutable-child regression test still passes (no caching introduced). https://claude.ai/code/session_01EHhGq9PRFRGefVtwwasCqZ
diff --git a/lib/PrefixSource.js b/lib/PrefixSource.js
@@ -21,7 +21,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 {
 	/**
@@ -57,55 +81,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()),
+		);
 	}
 
-	// Note: we deliberately don't override buffer() / size() here. The
-	// inherited Source.buffer() (`Buffer.from(this.source(), "utf8")`) is
-	// hard to beat — V8's regex.replace + utf8 encode is two big native
-	// calls, while a JS-side splice loop costs many JS↔C++ boundary
-	// crossings (CodSpeed measures instruction count, where the JS
-	// version regressed ~77%). Caching is also off the table because
-	// `_source` can be mutable (ReplaceSource etc.). buffers() below is
-	// the only override worth keeping; it gives consumers that can
-	// accept multiple buffers (writev, fs.createWriteStream) the chance
-	// to skip the intermediate concatenated buffer.
-
-	/**
-	 * Returns a `Buffer[]` that concatenates to the prefixed source. Each
-	 * content chunk is a `subarray` of the underlying buffer (no copy);
-	 * only the prefix buffer is materialized. This skips the
-	 * `[this.buffer()]` wrap that the default Source.buffers() would do.
-	 * @returns {Buffer[]} buffers
-	 */
-	buffers() {
-		const prefix = this._prefix;
-		if (prefix.length === 0) {
-			return /** @type {Source} */ (this._source).buffers();
-		}
-		const content = this._source.buffer();
-		const prefixBuffer = Buffer.from(prefix, "utf8");
-		if (content.length === 0) return [prefixBuffer];
-		/** @type {Buffer[]} */
-		const result = [prefixBuffer];
-		const len = content.length;
-		let i = 0;
-		while (i < len) {
-			const nl = content.indexOf(0x0a, i);
-			if (nl === -1) {
-				result.push(i === 0 ? content : content.subarray(i));
-				return result;
-			}
-			result.push(content.subarray(i, nl + 1));
-			// Match the regex `/\n(?=.|\s)/g` — only re-emit the prefix when
-			// at least one more byte follows the newline.
-			if (nl + 1 < len) result.push(prefixBuffer);
-			i = nl + 1;
-		}
-		return result;
-	}
+	// 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
@@ -184,10 +172,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,
 		};
 	}
 
