@pierre/diffs 1.3.0-beta.1 → 1.3.0-beta.11

package/dist/editor/pieceTable.js

@@ -1,23 +1,36 @@
 import { computeLineOffsets } from "../utils/computeFileOffsets.js";
-
 //#region src/editor/pieceTable.ts
 const MAX_FIND_MATCHES = 1e5;
+const LINE_FEED = 10;
+const CARRIAGE_RETURN = 13;
 const WORD_SEPARATORS = "`~!@#$%^&*()-=+[{]}\\|;:'\",.<>/?";
 var Piece = class {
+	source;
+	offset;
+	length;
+	lineOffsetStart;
+	lineOffsetEnd;
+	hasVirtualTrailingCRBreak;
+	firstCharCode;
+	lastCharCode;
 	static Original = 0;
 	static Added = 1;
-	constructor(source, offset, length, lineOffsetStart, lineOffsetEnd) {
+	constructor(source, offset, length, lineOffsetStart, lineOffsetEnd, hasVirtualTrailingCRBreak, firstCharCode, lastCharCode) {
 		this.source = source;
 		this.offset = offset;
 		this.length = length;
 		this.lineOffsetStart = lineOffsetStart;
 		this.lineOffsetEnd = lineOffsetEnd;
+		this.hasVirtualTrailingCRBreak = hasVirtualTrailingCRBreak;
+		this.firstCharCode = firstCharCode;
+		this.lastCharCode = lastCharCode;
 	}
 	get lineBreakCount() {
-		return this.lineOffsetEnd - this.lineOffsetStart;
+		return this.lineOffsetEnd - this.lineOffsetStart + (this.hasVirtualTrailingCRBreak ? 1 : 0);
 	}
 };
 var TextBuffer = class {
+	text;
 	lineOffsets;
 	constructor(text) {
 		this.text = text;
@@ -25,43 +38,65 @@ var TextBuffer = class {
 	}
 	append(text) {
 		const offset = this.text.length;
-		const appendedLineOffsets = computeLineOffsets(text);
-		for (let i = 1; i < appendedLineOffsets.length; i++) this.lineOffsets.push(offset + appendedLineOffsets[i]);
+		for (let i = 0; i < text.length; i++) {
+			const charCode = text.charCodeAt(i);
+			if (charCode !== LINE_FEED && charCode !== CARRIAGE_RETURN) continue;
+			if (charCode === CARRIAGE_RETURN && text.charCodeAt(i + 1) === LINE_FEED) i++;
+			this.lineOffsets.push(offset + i + 1);
+		}
 		this.text += text;
 		return offset;
 	}
 };
 var PieceNode = class {
+	piece;
+	subtreeLength;
+	subtreeLineBreakCount;
+	subtreeFirstCharCode;
+	subtreeLastCharCode;
 	left = null;
 	right = null;
 	parent = null;
-	constructor(piece, subtreeLength = piece.length, subtreeLineBreakCount = piece.lineBreakCount) {
+	priority = 0;
+	constructor(piece, subtreeLength = piece.length, subtreeLineBreakCount = piece.lineBreakCount, subtreeFirstCharCode = piece.firstCharCode, subtreeLastCharCode = piece.lastCharCode) {
 		this.piece = piece;
 		this.subtreeLength = subtreeLength;
 		this.subtreeLineBreakCount = subtreeLineBreakCount;
+		this.subtreeFirstCharCode = subtreeFirstCharCode;
+		this.subtreeLastCharCode = subtreeLastCharCode;
 	}
 	updateSubtreeLength() {
 		this.subtreeLength = (this.left?.subtreeLength ?? 0) + this.piece.length + (this.right?.subtreeLength ?? 0);
-		this.subtreeLineBreakCount = (this.left?.subtreeLineBreakCount ?? 0) + this.piece.lineBreakCount + (this.right?.subtreeLineBreakCount ?? 0);
+		this.subtreeLineBreakCount = (this.left?.subtreeLineBreakCount ?? 0) + this.piece.lineBreakCount + (this.right?.subtreeLineBreakCount ?? 0) - (formsCRLF(this.left?.subtreeLastCharCode, this.piece.firstCharCode) ? 1 : 0) - (formsCRLF(this.piece.lastCharCode, this.right?.subtreeFirstCharCode) ? 1 : 0);
+		this.subtreeFirstCharCode = this.left?.subtreeFirstCharCode ?? this.piece.firstCharCode;
+		this.subtreeLastCharCode = this.right?.subtreeLastCharCode ?? this.piece.lastCharCode;
 	}
 };
 /**
 * A piece table is a data structure that allows for efficient insertion and deletion of text.
 * It is a tree of pieces, where each piece is a segment of text that is either original or added.
-* The tree is rebuilt as a balanced tree after edits to keep lookups efficient.
+* The tree is a treap (a binary search tree that also keeps each node's random priority in heap
+* order, which keeps the tree balanced without an explicit rebalancing pass). Each edit reshapes
+* only the nodes along one root-to-leaf path via split and merge in O(log P), instead of
+* rebuilding all P pieces.
 * Inspired by https://code.visualstudio.com/blogs/2018/03/23/text-buffer-reimplementation
 */
 var PieceTable = class {
 	#original;
 	#add = new TextBuffer("");
 	#root = null;
-	#piecesCache = [];
 	#length = 0;
 	#lineCount = 0;
 	#lastVisitedLine = null;
+	#lastVisitedLineLength = null;
+	#lastPosition = null;
+	#priorityState = 2654435769;
 	constructor(originalText) {
 		this.#original = new TextBuffer(originalText);
-		this.#setPieces([this.#createPiece(Piece.Original, 0, originalText.length)]);
+		const piece = this.#createPiece(Piece.Original, 0, originalText.length);
+		this.#root = piece.length > 0 ? this.#createNode(piece) : null;
+		this.#length = this.#root?.subtreeLength ?? 0;
+		this.#lineCount = (this.#root?.subtreeLineBreakCount ?? 0) + 1;
 	}
 	get lineCount() {
 		return this.#lineCount;
@@ -72,14 +107,48 @@ var PieceTable = class {
 		const end = this.offsetAt(range.end);
 		return this.getTextSlice(start, end);
 	}
-	getLineText(line, trimEOF = true) {
-		if (this.#lastVisitedLine !== null && this.#lastVisitedLine[0] === line) return this.#lastVisitedLine[1];
+	getLineText(line, includeLineBreak = false) {
+		if (this.#lastVisitedLine !== null && this.#lastVisitedLine[0] === line && this.#lastVisitedLine[1] === includeLineBreak) return this.#lastVisitedLine[2];
 		const offset = this.#getLineOffset(line);
 		if (offset === void 0) throw new Error(`Line index out of range: ${line}`);
-		const text = this.getTextSlice(offset[0], offset[1], trimEOF);
-		this.#lastVisitedLine = [line, text];
+		const text = this.getTextSlice(offset[0], offset[1], !includeLineBreak);
+		this.#lastVisitedLine = [
+			line,
+			includeLineBreak,
+			text
+		];
+		this.#lastVisitedLineLength = [
+			line,
+			includeLineBreak,
+			text.length
+		];
 		return text;
 	}
+	getLineLength(line, includeLineBreak = false) {
+		const lastVisitedLineLength = this.#lastVisitedLineLength;
+		const lastVisitedLine = this.#lastVisitedLine;
+		if (lastVisitedLineLength !== null && lastVisitedLineLength[0] === line && lastVisitedLineLength[1] === includeLineBreak) return lastVisitedLineLength[2];
+		if (lastVisitedLine !== null && lastVisitedLine[0] === line && lastVisitedLine[1] === includeLineBreak) {
+			const length = lastVisitedLine[2].length;
+			this.#lastVisitedLineLength = [
+				line,
+				includeLineBreak,
+				length
+			];
+			return length;
+		}
+		const offset = this.#getLineOffset(line);
+		if (offset === void 0) throw new Error(`Line index out of range: ${line}`);
+		const [start, end] = offset;
+		let length = end - start;
+		if (!includeLineBreak) while (length > 0 && isEOL(this.charAt(start + length - 1).charCodeAt(0))) length--;
+		this.#lastVisitedLineLength = [
+			line,
+			includeLineBreak,
+			length
+		];
+		return length;
+	}
 	getTextSlice(start, end, trimEOF = false) {
 		if (start >= end) return "";
 		const sliceStart = clamp(start, 0, this.#length);
@@ -93,10 +162,10 @@ var PieceTable = class {
 		while (node !== null && remaining > 0) {
 			const takeLength = Math.min(node.piece.length - offsetInPiece, remaining);
 			const buffer = this.#bufferFor(node.piece.source);
-			const start$1 = node.piece.offset + offsetInPiece;
-			let end$1 = start$1 + takeLength;
-			if (trimEOF) while (end$1 > start$1 && isEOL(buffer.text.charCodeAt(end$1 - 1))) end$1--;
-			chunks.push(buffer.text.slice(start$1, end$1));
+			const start = node.piece.offset + offsetInPiece;
+			let end = start + takeLength;
+			if (trimEOF) while (end > start && isEOL(buffer.text.charCodeAt(end - 1))) end--;
+			chunks.push(buffer.text.slice(start, end));
 			remaining -= takeLength;
 			offsetInPiece = 0;
 			node = this.#nextNode(node);
@@ -159,7 +228,7 @@ var PieceTable = class {
 		});
 		return foundOffset ?? wrappedOffset;
 	}
-	search(kind, searchParams, range) {
+	search(searchParams) {
 		if (searchParams.text.length === 0 || this.#length === 0) return [];
 		if (searchParams.text.includes("\n") || searchParams.text.includes("\r") || searchParams.regex && (searchParams.text.includes("\\n") || searchParams.text.includes("\\r"))) return [];
 		let pattern;
@@ -168,137 +237,60 @@ var PieceTable = class {
 		} catch {
 			return [];
 		}
-		const matches = this.#collectSearchMatchesLineByLine(pattern, searchParams.wholeWord, MAX_FIND_MATCHES);
-		if (kind === "findAll" || kind === "replaceAll") return matches;
-		const caretOffset = range === void 0 ? 0 : kind === "findPrevious" ? this.offsetAt(range?.start) : this.offsetAt(range?.end);
-		if (kind === "findPrevious") {
-			const refOffset = getSearchFindPreviousReferenceOffset(range, (p) => this.offsetAt(p));
-			let best;
-			for (const m of matches) if (m[1] <= refOffset) best = m;
-			else break;
-			if (best !== void 0) return [best];
-			const last = matches[matches.length - 1];
-			return last !== void 0 ? [last] : [];
-		}
-		for (const m of matches) if (m[0] >= caretOffset) return [m];
-		const first = matches[0];
-		return first !== void 0 ? [first] : [];
+		return this.#collectSearchMatchesLineByLine(pattern, searchParams.wholeWord, MAX_FIND_MATCHES);
 	}
 	#collectSearchMatchesLineByLine(pattern, wholeWord, limit) {
 		const out = [];
-		const docLength = this.#length;
-		const charAt = (offset) => this.charAt(offset);
-		for (let line = 0; line < this.#lineCount; line++) {
-			const lineText = this.getLineText(line);
-			const lineStart = this.offsetAt({
-				line,
-				character: 0
-			});
-			const re = new RegExp(pattern.source, pattern.flags);
-			re.lastIndex = 0;
+		const documentText = this.#textFromPieces();
+		const docLength = documentText.length;
+		const lineOffsets = computeLineOffsets(documentText);
+		for (let line = 0; line < lineOffsets.length; line++) {
+			const lineStart = lineOffsets[line];
+			let lineEnd = lineOffsets[line + 1] ?? docLength;
+			while (lineEnd > lineStart && isEOL(documentText.charCodeAt(lineEnd - 1))) lineEnd--;
+			const lineText = documentText.slice(lineStart, lineEnd);
+			pattern.lastIndex = 0;
 			let match;
-			while ((match = re.exec(lineText)) !== null) {
+			while ((match = pattern.exec(lineText)) !== null) {
 				const rel = match.index;
 				const fragment = match[0];
 				if (fragment.length === 0) {
-					re.lastIndex = advancePastEmptyMatch(lineText, rel);
+					pattern.lastIndex = advancePastEmptyMatch(lineText, rel);
 					continue;
 				}
 				const docStart = lineStart + rel;
-				if (!wholeWord || isWholeWordAtDocOffsets(docStart, fragment.length, docLength, charAt)) {
+				if (!wholeWord || isWholeWordAtDocOffsets(documentText, docStart, fragment.length)) {
 					out.push([docStart, docStart + fragment.length]);
 					if (out.length >= limit) return out;
 				}
-				if (rel === re.lastIndex) re.lastIndex = advancePastEmptyMatch(lineText, rel);
+				if (rel === pattern.lastIndex) pattern.lastIndex = advancePastEmptyMatch(lineText, rel);
 			}
 		}
 		return out;
 	}
 	insert(text, offset) {
 		if (text.length === 0) return;
-		const insertOffset = clamp(offset, 0, this.#length);
-		const addOffset = this.#add.append(text);
-		const insertedPiece = this.#createPiece(Piece.Added, addOffset, text.length);
-		const pieces = this.#pieces();
-		const nextPieces = [];
-		let cursor = 0;
-		let inserted = false;
-		for (const piece of pieces) {
-			const pieceEnd = cursor + piece.length;
-			if (!inserted && insertOffset <= pieceEnd) {
-				const splitOffset = insertOffset - cursor;
-				if (splitOffset > 0) nextPieces.push(this.#createPiece(piece.source, piece.offset, splitOffset));
-				nextPieces.push(insertedPiece);
-				if (splitOffset < piece.length) nextPieces.push(this.#createPiece(piece.source, piece.offset + splitOffset, piece.length - splitOffset));
-				inserted = true;
-			} else nextPieces.push(piece);
-			cursor = pieceEnd;
-		}
-		if (!inserted) nextPieces.push(insertedPiece);
-		this.#setPieces(nextPieces);
-		this.#lastVisitedLine = null;
+		const start = clamp(offset, 0, this.#length);
+		this.#replaceRangeIncremental(start, start, text);
+		this.#invalidateCaches();
 	}
 	delete(offset, length) {
 		if (length <= 0 || this.#length === 0) return;
 		const start = clamp(offset, 0, this.#length);
 		const end = clamp(start + length, start, this.#length);
 		if (start === end) return;
-		const nextPieces = [];
-		let cursor = 0;
-		for (const piece of this.#pieces()) {
-			const pieceStart = cursor;
-			const pieceEnd = cursor + piece.length;
-			const keepBefore = clamp(start - pieceStart, 0, piece.length);
-			const keepAfter = clamp(pieceEnd - end, 0, piece.length);
-			if (keepBefore > 0) nextPieces.push(this.#createPiece(piece.source, piece.offset, keepBefore));
-			if (keepAfter > 0) nextPieces.push(this.#createPiece(piece.source, piece.offset + piece.length - keepAfter, keepAfter));
-			cursor = pieceEnd;
-		}
-		this.#setPieces(nextPieces);
-		this.#lastVisitedLine = null;
+		this.#replaceRangeIncremental(start, end, "");
+		this.#invalidateCaches();
 	}
 	applyEdits(edits) {
 		if (edits.length === 0) return;
-		let pieceIndex = 0;
-		let pieceStart = 0;
-		let copyCursor = 0;
-		const pieces = this.#pieces();
-		const insertedPieces = edits.map((edit) => edit.text.length === 0 ? void 0 : this.#createPiece(Piece.Added, this.#add.append(edit.text), edit.text.length));
-		const nextPieces = [];
-		const advancePiece = () => {
-			const piece = pieces[pieceIndex];
-			if (piece !== void 0) {
-				pieceStart += piece.length;
-				pieceIndex++;
-			}
-		};
-		const appendRange = (start, end) => {
-			let rangeStart = clamp(start, 0, this.#length);
-			const rangeEnd = clamp(end, rangeStart, this.#length);
-			while (pieceIndex < pieces.length && pieceStart + pieces[pieceIndex].length <= rangeStart) advancePiece();
-			while (pieceIndex < pieces.length && rangeStart < rangeEnd) {
-				const piece = pieces[pieceIndex];
-				const pieceEnd = pieceStart + piece.length;
-				const offsetInPiece = clamp(rangeStart - pieceStart, 0, piece.length);
-				const takeEnd = Math.min(pieceEnd, rangeEnd);
-				const takeLength = takeEnd - (pieceStart + offsetInPiece);
-				if (takeLength > 0) nextPieces.push(offsetInPiece === 0 && takeLength === piece.length ? piece : this.#createPiece(piece.source, piece.offset + offsetInPiece, takeLength));
-				rangeStart = takeEnd;
-				if (rangeStart >= pieceEnd) advancePiece();
-			}
-		};
-		for (let i = 0; i < edits.length; i++) {
+		for (let i = edits.length - 1; i >= 0; i--) {
 			const edit = edits[i];
-			const start = clamp(edit.start, copyCursor, this.#length);
+			const start = clamp(edit.start, 0, this.#length);
 			const end = clamp(edit.end, start, this.#length);
-			appendRange(copyCursor, start);
-			const insertedPiece = insertedPieces[i];
-			if (insertedPiece !== void 0) nextPieces.push(insertedPiece);
-			copyCursor = end;
+			this.#replaceRangeIncremental(start, end, edit.text);
 		}
-		appendRange(copyCursor, this.#length);
-		this.#setPieces(nextPieces);
-		this.#lastVisitedLine = null;
+		this.#invalidateCaches();
 	}
 	positionAt(offset) {
 		const clampedOffset = clamp(offset, 0, this.#length);
@@ -307,9 +299,15 @@ var PieceTable = class {
 			character: 0
 		};
 		const line = this.#lineAtOffset(clampedOffset);
+		const character = clampedOffset - (line === 0 ? 0 : this.#lineBreakOffset(line - 1));
+		this.#lastPosition = [
+			line,
+			character,
+			clampedOffset
+		];
 		return {
 			line,
-			character: clampedOffset - (line === 0 ? 0 : this.#lineBreakOffset(line - 1))
+			character
 		};
 	}
 	positionsAt(offsets) {
@@ -325,18 +323,13 @@ var PieceTable = class {
 	offsetAt(position) {
 		if (position.line < 0 || this.#length === 0) return 0;
 		if (position.line >= this.#lineCount) throw new Error(`Line index out of range: ${position.line}`);
+		const lastPosition = this.#lastPosition;
+		if (lastPosition !== null && lastPosition[0] === position.line && lastPosition[1] === position.character) return lastPosition[2];
 		const offset = this.#getLineOffset(position.line);
 		if (offset === void 0) throw new Error(`Line index out of range: ${position.line}`);
 		const character = clamp(position.character, 0, offset[1] - offset[0]);
 		return offset[0] + character;
 	}
-	offsetsAt(positions) {
-		const offsets = Array.from({ length: positions.length });
-		if (positions.length === 0) return offsets;
-		if (this.#length === 0) return offsets.fill(0);
-		for (let i = 0; i < positions.length; i++) offsets[i] = this.offsetAt(positions[i]);
-		return offsets;
-	}
 	#findPieceAtOffset(offset) {
 		if (offset < 0 || offset >= this.#length) return;
 		let node = this.#root;
@@ -382,14 +375,17 @@ var PieceTable = class {
 				node = node.left;
 				continue;
 			}
-			line += node.left?.subtreeLineBreakCount ?? 0;
+			line += (node.left?.subtreeLineBreakCount ?? 0) - (formsCRLF(node.left?.subtreeLastCharCode, node.piece.firstCharCode) ? 1 : 0);
 			remaining -= leftLength;
 			if (remaining <= node.piece.length) {
 				const buffer = this.#bufferFor(node.piece.source);
-				line += upperBound(buffer.lineOffsets, node.piece.offset + remaining) - node.piece.lineOffsetStart;
+				const lineOffsetEnd = Math.min(upperBound(buffer.lineOffsets, node.piece.offset + remaining), node.piece.lineOffsetEnd);
+				line += lineOffsetEnd - node.piece.lineOffsetStart;
+				if (remaining === node.piece.length && node.piece.hasVirtualTrailingCRBreak) line++;
+				if (remaining === node.piece.length && formsCRLF(node.piece.lastCharCode, this.#nextNode(node)?.piece.firstCharCode)) line--;
 				return line;
 			}
-			line += node.piece.lineBreakCount;
+			line += node.piece.lineBreakCount - (formsCRLF(node.piece.lastCharCode, node.right?.subtreeFirstCharCode) ? 1 : 0);
 			remaining -= node.piece.length;
 			node = node.right;
 		}
@@ -399,25 +395,30 @@ var PieceTable = class {
 		let node = this.#root;
 		let remaining = lineBreakIndex;
 		let documentOffset = 0;
+		let followingCharCode;
 		while (node !== null) {
-			const leftLineBreakCount = node.left?.subtreeLineBreakCount ?? 0;
+			const leftLineBreakCount = (node.left?.subtreeLineBreakCount ?? 0) - (formsCRLF(node.left?.subtreeLastCharCode, node.piece.firstCharCode) ? 1 : 0);
 			if (remaining < leftLineBreakCount) {
+				followingCharCode = node.piece.firstCharCode;
 				node = node.left;
 				continue;
 			}
 			const leftLength = node.left?.subtreeLength ?? 0;
 			documentOffset += leftLength;
 			remaining -= leftLineBreakCount;
-			if (remaining < node.piece.lineBreakCount) {
-				const bufferLineOffset = this.#bufferFor(node.piece.source).lineOffsets[node.piece.lineOffsetStart + remaining];
-				return documentOffset + (bufferLineOffset - node.piece.offset);
-			}
+			const nextCharCode = node.right?.subtreeFirstCharCode ?? followingCharCode;
+			const pieceLineBreakCount = node.piece.lineBreakCount - (formsCRLF(node.piece.lastCharCode, nextCharCode) ? 1 : 0);
+			if (remaining < pieceLineBreakCount) return documentOffset + this.#pieceLineBreakOffset(node.piece, remaining);
 			documentOffset += node.piece.length;
-			remaining -= node.piece.lineBreakCount;
+			remaining -= pieceLineBreakCount;
 			node = node.right;
 		}
 		return this.#length;
 	}
+	#pieceLineBreakOffset(piece, lineBreakIndex) {
+		if (lineBreakIndex < piece.lineOffsetEnd - piece.lineOffsetStart) return this.#bufferFor(piece.source).lineOffsets[piece.lineOffsetStart + lineBreakIndex] - piece.offset;
+		return piece.length;
+	}
 	#textFromPieces() {
 		const chunks = [];
 		this.#forEachPieceSegment((segment) => {
@@ -443,34 +444,133 @@ var PieceTable = class {
 	}
 	#createPiece(source, offset, length) {
 		const buffer = this.#bufferFor(source);
-		return new Piece(source, offset, length, upperBound(buffer.lineOffsets, offset), upperBound(buffer.lineOffsets, offset + length));
-	}
-	#pieces() {
-		return this.#piecesCache;
-	}
-	#setPieces(pieces) {
-		const coalescedPieces = coalescePieces(pieces);
-		this.#piecesCache = coalescedPieces;
-		let length = 0;
-		let lineBreakCount = 0;
-		for (const piece of coalescedPieces) {
-			length += piece.length;
-			lineBreakCount += piece.lineBreakCount;
+		const end = offset + length;
+		const lineOffsetStart = upperBound(buffer.lineOffsets, offset);
+		const lineOffsetEnd = upperBound(buffer.lineOffsets, end);
+		const lastCharCode = buffer.text.charCodeAt(end - 1);
+		return new Piece(source, offset, length, lineOffsetStart, lineOffsetEnd, lastCharCode === CARRIAGE_RETURN && buffer.lineOffsets[lineOffsetEnd - 1] !== end, buffer.text.charCodeAt(offset), lastCharCode);
+	}
+	#replaceRangeIncremental(start, end, text) {
+		if (start === end && text.length === 0) return;
+		const [left, rest] = this.#split(this.#root, start);
+		const right = this.#dropPrefix(rest, end - start);
+		let root;
+		if (text.length > 0) {
+			const insertedPiece = this.#createPiece(Piece.Added, this.#add.append(text), text.length);
+			root = this.#mergeNodes(this.#appendCoalescing(left, insertedPiece), right);
+		} else {
+			const [seamPiece, restRight] = this.#popLeftmost(right);
+			root = seamPiece === void 0 ? left : this.#mergeNodes(this.#appendCoalescing(left, seamPiece), restRight);
 		}
-		this.#root = this.#buildBalancedTree(coalescedPieces, 0, coalescedPieces.length, null);
-		this.#length = length;
-		this.#lineCount = lineBreakCount + 1;
-	}
-	#buildBalancedTree(pieces, start, end, parent) {
-		if (start >= end) return null;
-		const middle = start + Math.floor((end - start) / 2);
-		const node = new PieceNode(pieces[middle]);
-		node.parent = parent;
-		node.left = this.#buildBalancedTree(pieces, start, middle, node);
-		node.right = this.#buildBalancedTree(pieces, middle + 1, end, node);
-		node.updateSubtreeLength();
+		if (root !== null) root.parent = null;
+		this.#root = root;
+		this.#length = root?.subtreeLength ?? 0;
+		this.#lineCount = (root?.subtreeLineBreakCount ?? 0) + 1;
+	}
+	#invalidateCaches() {
+		this.#lastVisitedLine = null;
+		this.#lastVisitedLineLength = null;
+		this.#lastPosition = null;
+	}
+	#nextPriority() {
+		this.#priorityState = Math.imul(this.#priorityState, 1664525) + 1013904223 >>> 0;
+		return this.#priorityState;
+	}
+	#createNode(piece) {
+		const node = new PieceNode(piece);
+		node.priority = this.#nextPriority();
 		return node;
 	}
+	#setLeft(node, child) {
+		node.left = child;
+		if (child !== null) child.parent = node;
+	}
+	#setRight(node, child) {
+		node.right = child;
+		if (child !== null) child.parent = node;
+	}
+	#split(node, offset) {
+		if (node === null) return [null, null];
+		if (offset <= 0) return [null, node];
+		if (offset >= node.subtreeLength) return [node, null];
+		const leftLength = node.left?.subtreeLength ?? 0;
+		if (offset <= leftLength) {
+			const [left, right] = this.#split(node.left, offset);
+			this.#setLeft(node, right);
+			node.updateSubtreeLength();
+			return [left, node];
+		}
+		const pieceLength = node.piece.length;
+		if (offset >= leftLength + pieceLength) {
+			const [left, right] = this.#split(node.right, offset - leftLength - pieceLength);
+			this.#setRight(node, left);
+			node.updateSubtreeLength();
+			return [node, right];
+		}
+		const inPiece = offset - leftLength;
+		const leftNode = new PieceNode(this.#createPiece(node.piece.source, node.piece.offset, inPiece));
+		const rightNode = new PieceNode(this.#createPiece(node.piece.source, node.piece.offset + inPiece, pieceLength - inPiece));
+		leftNode.priority = node.priority;
+		rightNode.priority = node.priority;
+		this.#setLeft(leftNode, node.left);
+		this.#setRight(rightNode, node.right);
+		leftNode.updateSubtreeLength();
+		rightNode.updateSubtreeLength();
+		return [leftNode, rightNode];
+	}
+	#dropPrefix(node, offset) {
+		if (node === null || offset >= node.subtreeLength) return null;
+		if (offset <= 0) return node;
+		const leftLength = node.left?.subtreeLength ?? 0;
+		if (offset <= leftLength) {
+			this.#setLeft(node, this.#dropPrefix(node.left, offset));
+			node.updateSubtreeLength();
+			return node;
+		}
+		const pieceEnd = leftLength + node.piece.length;
+		if (offset >= pieceEnd) return this.#dropPrefix(node.right, offset - pieceEnd);
+		const inPiece = offset - leftLength;
+		const rightNode = new PieceNode(this.#createPiece(node.piece.source, node.piece.offset + inPiece, node.piece.length - inPiece));
+		rightNode.priority = node.priority;
+		this.#setRight(rightNode, node.right);
+		rightNode.updateSubtreeLength();
+		return rightNode;
+	}
+	#mergeNodes(left, right) {
+		if (left === null) return right;
+		if (right === null) return left;
+		if (left.priority >= right.priority) {
+			this.#setRight(left, this.#mergeNodes(left.right, right));
+			left.updateSubtreeLength();
+			return left;
+		}
+		this.#setLeft(right, this.#mergeNodes(left, right.left));
+		right.updateSubtreeLength();
+		return right;
+	}
+	#appendCoalescing(tree, piece) {
+		if (tree === null) return this.#createNode(piece);
+		let last = tree;
+		while (last.right !== null) last = last.right;
+		if (canCoalescePieces(last.piece, piece)) {
+			last.piece = coalesceTwoPieces(last.piece, piece);
+			for (let node = last; node !== null;) {
+				node.updateSubtreeLength();
+				if (node === tree) break;
+				node = node.parent;
+			}
+			return tree;
+		}
+		return this.#mergeNodes(tree, this.#createNode(piece));
+	}
+	#popLeftmost(tree) {
+		if (tree === null) return [void 0, null];
+		if (tree.left === null) return [tree.piece, tree.right];
+		const [piece, newLeft] = this.#popLeftmost(tree.left);
+		this.#setLeft(tree, newLeft);
+		tree.updateSubtreeLength();
+		return [piece, tree];
+	}
 	#walk(node, visit) {
 		if (node === null) return true;
 		if (!this.#walk(node.left, visit)) return false;
@@ -525,18 +625,14 @@ function rangeOverlaps(ranges, start, end) {
 	const range = ranges[low];
 	return range !== void 0 && range[0] < end;
 }
-function coalescePieces(pieces) {
-	const coalescedPieces = [];
-	for (const piece of pieces) {
-		if (piece.length === 0) continue;
-		const previous = coalescedPieces[coalescedPieces.length - 1];
-		if (previous !== void 0 && previous.source === piece.source && previous.offset + previous.length === piece.offset) {
-			coalescedPieces[coalescedPieces.length - 1] = new Piece(previous.source, previous.offset, previous.length + piece.length, previous.lineOffsetStart, piece.lineOffsetEnd);
-			continue;
-		}
-		coalescedPieces.push(piece);
-	}
-	return coalescedPieces;
+function canCoalescePieces(prev, next) {
+	return prev.source === next.source && prev.offset + prev.length === next.offset && !formsCRLF(prev.lastCharCode, next.firstCharCode);
+}
+function coalesceTwoPieces(prev, next) {
+	return new Piece(prev.source, prev.offset, prev.length + next.length, prev.lineOffsetStart, next.lineOffsetEnd, next.hasVirtualTrailingCRBreak, prev.firstCharCode, next.lastCharCode);
+}
+function formsCRLF(leftCharCode, rightCharCode) {
+	return leftCharCode === CARRIAGE_RETURN && rightCharCode === LINE_FEED;
 }
 function upperBound(values, target) {
 	let lo = 0;
@@ -556,19 +652,45 @@ function isWordSeparatorCharCode(charCode) {
 	const ch = String.fromCharCode(charCode);
 	return WORD_SEPARATORS.includes(ch);
 }
-function isWholeWordAtDocOffsets(docStart, length, docLength, charAt) {
-	const beforeOk = docStart <= 0 || isWordSeparatorCharCode(charCodeUnitAt(charAt, docStart - 1));
-	const afterOk = docStart + length >= docLength || isWordSeparatorCharCode(charCodeUnitAt(charAt, docStart + length));
+function isWholeWordAtDocOffsets(text, docStart, length) {
+	const beforeOk = docStart <= 0 || isWordSeparatorCharCode(text.charCodeAt(docStart - 1));
+	const afterOk = docStart + length >= text.length || isWordSeparatorCharCode(text.charCodeAt(docStart + length));
 	return beforeOk && afterOk;
 }
-function charCodeUnitAt(charAt, offset) {
-	const unit = charAt(offset);
-	return unit.length === 0 ? 0 : unit.charCodeAt(0);
-}
 function compileSearchRegExp(source, isRegex, caseSensitive) {
 	const body = isRegex ? source : escapeRegExp(source);
-	const flags = `g${caseSensitive ? "" : "i"}${isRegex ? "m" : ""}`;
-	return new RegExp(body, flags);
+	return new RegExp(body, `g${caseSensitive ? "" : "i"}${isRegex ? "m" : ""}`);
+}
+/** Expands `$&`, `$1`, `$$`, etc. in a regex replace string using a match. */
+function expandReplaceString(replacement, match) {
+	return replacement.replace(/\$([$&]|\d+)/g, (_token, group) => {
+		if (group === "$") return "$";
+		if (group === "&") return match[0] ?? "";
+		return match[Number(group)] ?? "";
+	});
+}
+/**
+* Builds the text to insert for one search match, including regex capture
+* substitution when regex mode is enabled.
+*/
+function buildSearchReplacementText(positionAt, offsetAt, getLineText, searchParams, matchStart, matchEnd) {
+	if (!searchParams.regex) return searchParams.replaceText;
+	const position = positionAt(matchStart);
+	const lineText = getLineText(position.line);
+	const relStart = matchStart - offsetAt({
+		line: position.line,
+		character: 0
+	});
+	let pattern;
+	try {
+		pattern = compileSearchRegExp(searchParams.text, true, searchParams.caseSensitive);
+	} catch {
+		return searchParams.replaceText;
+	}
+	pattern.lastIndex = relStart;
+	const match = pattern.exec(lineText);
+	if (match === null || match.index !== relStart || match[0].length !== matchEnd - matchStart) return searchParams.replaceText;
+	return expandReplaceString(searchParams.replaceText, match);
 }
 function advancePastEmptyMatch(text, index) {
 	if (index + 1 < text.length) {
@@ -578,13 +700,7 @@ function advancePastEmptyMatch(text, index) {
 	}
 	return index + 1;
 }
-function getSearchFindPreviousReferenceOffset(selection, offsetAt) {
-	if (selection === void 0) return 0;
-	const a = offsetAt(selection.start);
-	const b = offsetAt(selection.end);
-	return Math.min(a, b);
-}
-
 //#endregion
-export { PieceTable };
+export { PieceTable, buildSearchReplacementText };
+
 //# sourceMappingURL=pieceTable.js.map