@pierre/diffs 1.2.8 → 1.3.0-beta.2

package/dist/editor/pieceTable.js

@@ -0,0 +1,590 @@
+import { computeLineOffsets } from "../utils/computeFileOffsets.js";
+
+//#region src/editor/pieceTable.ts
+const MAX_FIND_MATCHES = 1e5;
+const WORD_SEPARATORS = "`~!@#$%^&*()-=+[{]}\\|;:'\",.<>/?";
+var Piece = class {
+	static Original = 0;
+	static Added = 1;
+	constructor(source, offset, length, lineOffsetStart, lineOffsetEnd) {
+		this.source = source;
+		this.offset = offset;
+		this.length = length;
+		this.lineOffsetStart = lineOffsetStart;
+		this.lineOffsetEnd = lineOffsetEnd;
+	}
+	get lineBreakCount() {
+		return this.lineOffsetEnd - this.lineOffsetStart;
+	}
+};
+var TextBuffer = class {
+	lineOffsets;
+	constructor(text) {
+		this.text = text;
+		this.lineOffsets = computeLineOffsets(text);
+	}
+	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]);
+		this.text += text;
+		return offset;
+	}
+};
+var PieceNode = class {
+	left = null;
+	right = null;
+	parent = null;
+	constructor(piece, subtreeLength = piece.length, subtreeLineBreakCount = piece.lineBreakCount) {
+		this.piece = piece;
+		this.subtreeLength = subtreeLength;
+		this.subtreeLineBreakCount = subtreeLineBreakCount;
+	}
+	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);
+	}
+};
+/**
+* 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.
+* 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;
+	constructor(originalText) {
+		this.#original = new TextBuffer(originalText);
+		this.#setPieces([this.#createPiece(Piece.Original, 0, originalText.length)]);
+	}
+	get lineCount() {
+		return this.#lineCount;
+	}
+	getText(range) {
+		if (range === void 0) return this.#textFromPieces();
+		const start = this.offsetAt(range.start);
+		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];
+		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];
+		return text;
+	}
+	getTextSlice(start, end, trimEOF = false) {
+		if (start >= end) return "";
+		const sliceStart = clamp(start, 0, this.#length);
+		const sliceEnd = clamp(end, sliceStart, this.#length);
+		if (sliceStart >= sliceEnd) return "";
+		const location = this.#findPieceAtOffset(sliceStart);
+		if (location === void 0) return "";
+		const chunks = [];
+		let [node, offsetInPiece] = location;
+		let remaining = sliceEnd - sliceStart;
+		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));
+			remaining -= takeLength;
+			offsetInPiece = 0;
+			node = this.#nextNode(node);
+		}
+		return chunks.join("");
+	}
+	charAt(offset) {
+		const location = this.#findPieceAtOffset(offset);
+		if (location === void 0) return "";
+		const [node, offsetInPiece] = location;
+		return this.#bufferFor(node.piece.source).text.charAt(node.piece.offset + offsetInPiece);
+	}
+	includes(needle) {
+		if (needle.length === 0) return true;
+		const prefixTable = createPrefixTable(needle);
+		let matched = 0;
+		let found = false;
+		this.#forEachPieceSegment((segment) => {
+			for (let offset = segment.start; offset < segment.end; offset++) {
+				const charCode = segment.text.charCodeAt(offset);
+				while (matched > 0 && charCode !== needle.charCodeAt(matched)) matched = prefixTable[matched - 1];
+				if (charCode === needle.charCodeAt(matched)) matched++;
+				if (matched === needle.length) {
+					found = true;
+					return false;
+				}
+			}
+			return true;
+		});
+		return found;
+	}
+	findNextNonOverlappingSubstring(needle, occupied) {
+		if (needle.length === 0 || needle.length > this.#length) return;
+		const ranges = normalizeRanges(occupied, this.#length);
+		const pivot = ranges.reduce((max, [, end]) => Math.max(max, end), 0);
+		const prefixTable = createPrefixTable(needle);
+		let matched = 0;
+		let documentOffset = 0;
+		let wrappedOffset;
+		let foundOffset;
+		this.#forEachPieceSegment((segment) => {
+			for (let offset = segment.start; offset < segment.end; offset++) {
+				const charCode = segment.text.charCodeAt(offset);
+				while (matched > 0 && charCode !== needle.charCodeAt(matched)) matched = prefixTable[matched - 1];
+				if (charCode === needle.charCodeAt(matched)) matched++;
+				if (matched === needle.length) {
+					const start = documentOffset - needle.length + 1;
+					if (!rangeOverlaps(ranges, start, start + needle.length)) {
+						if (start >= pivot) {
+							foundOffset = start;
+							return false;
+						}
+						wrappedOffset ??= start;
+					}
+					matched = prefixTable[matched - 1];
+				}
+				documentOffset++;
+			}
+			return true;
+		});
+		return foundOffset ?? wrappedOffset;
+	}
+	search(kind, searchParams, range) {
+		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;
+		try {
+			pattern = compileSearchRegExp(searchParams.text, searchParams.regex, searchParams.caseSensitive);
+		} 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] : [];
+	}
+	#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;
+			let match;
+			while ((match = re.exec(lineText)) !== null) {
+				const rel = match.index;
+				const fragment = match[0];
+				if (fragment.length === 0) {
+					re.lastIndex = advancePastEmptyMatch(lineText, rel);
+					continue;
+				}
+				const docStart = lineStart + rel;
+				if (!wholeWord || isWholeWordAtDocOffsets(docStart, fragment.length, docLength, charAt)) {
+					out.push([docStart, docStart + fragment.length]);
+					if (out.length >= limit) return out;
+				}
+				if (rel === re.lastIndex) re.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;
+	}
+	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;
+	}
+	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++) {
+			const edit = edits[i];
+			const start = clamp(edit.start, copyCursor, 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;
+		}
+		appendRange(copyCursor, this.#length);
+		this.#setPieces(nextPieces);
+		this.#lastVisitedLine = null;
+	}
+	positionAt(offset) {
+		const clampedOffset = clamp(offset, 0, this.#length);
+		if (this.#length === 0) return {
+			line: 0,
+			character: 0
+		};
+		const line = this.#lineAtOffset(clampedOffset);
+		return {
+			line,
+			character: clampedOffset - (line === 0 ? 0 : this.#lineBreakOffset(line - 1))
+		};
+	}
+	positionsAt(offsets) {
+		const positions = Array.from({ length: offsets.length });
+		if (offsets.length === 0) return positions;
+		if (this.#length === 0) return positions.fill({
+			line: 0,
+			character: 0
+		});
+		for (let i = 0; i < offsets.length; i++) positions[i] = this.positionAt(offsets[i]);
+		return positions;
+	}
+	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 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;
+		let remaining = offset;
+		while (node !== null) {
+			const leftLength = node.left?.subtreeLength ?? 0;
+			if (remaining < leftLength) {
+				node = node.left;
+				continue;
+			}
+			remaining -= leftLength;
+			if (remaining < node.piece.length) return [node, remaining];
+			remaining -= node.piece.length;
+			node = node.right;
+		}
+	}
+	#nextNode(node) {
+		if (node.right !== null) {
+			let next = node.right;
+			while (next.left !== null) next = next.left;
+			return next;
+		}
+		let current = node;
+		while (current.parent !== null && current === current.parent.right) current = current.parent;
+		return current.parent;
+	}
+	#getLineOffset(line) {
+		if (line < 0) throw new Error(`Line index out of range: ${line}`);
+		if (this.#length === 0) {
+			if (line === 0) return [0, 0];
+			throw new Error(`Line index out of range: ${line}`);
+		}
+		if (line >= this.#lineCount) throw new Error(`Line index out of range: ${line}`);
+		return [line === 0 ? 0 : this.#lineBreakOffset(line - 1), line < this.#lineCount - 1 ? this.#lineBreakOffset(line) : this.#length];
+	}
+	#lineAtOffset(offset) {
+		let node = this.#root;
+		let remaining = clamp(offset, 0, this.#length);
+		let line = 0;
+		while (node !== null) {
+			const leftLength = node.left?.subtreeLength ?? 0;
+			if (remaining < leftLength) {
+				node = node.left;
+				continue;
+			}
+			line += node.left?.subtreeLineBreakCount ?? 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;
+				return line;
+			}
+			line += node.piece.lineBreakCount;
+			remaining -= node.piece.length;
+			node = node.right;
+		}
+		return this.#lineCount - 1;
+	}
+	#lineBreakOffset(lineBreakIndex) {
+		let node = this.#root;
+		let remaining = lineBreakIndex;
+		let documentOffset = 0;
+		while (node !== null) {
+			const leftLineBreakCount = node.left?.subtreeLineBreakCount ?? 0;
+			if (remaining < leftLineBreakCount) {
+				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);
+			}
+			documentOffset += node.piece.length;
+			remaining -= node.piece.lineBreakCount;
+			node = node.right;
+		}
+		return this.#length;
+	}
+	#textFromPieces() {
+		const chunks = [];
+		this.#forEachPieceSegment((segment) => {
+			chunks.push(segment.text.slice(segment.start, segment.end));
+		});
+		return chunks.join("");
+	}
+	#forEachPieceSegment(callback) {
+		this.#walk(this.#root, (node) => {
+			const buffer = this.#bufferFor(node.piece.source);
+			return callback({
+				text: buffer.text,
+				lineOffsets: buffer.lineOffsets,
+				lineOffsetStart: node.piece.lineOffsetStart,
+				lineOffsetEnd: node.piece.lineOffsetEnd,
+				start: node.piece.offset,
+				end: node.piece.offset + node.piece.length
+			});
+		});
+	}
+	#bufferFor(source) {
+		return source === Piece.Original ? this.#original : this.#add;
+	}
+	#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;
+		}
+		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();
+		return node;
+	}
+	#walk(node, visit) {
+		if (node === null) return true;
+		if (!this.#walk(node.left, visit)) return false;
+		if (visit(node) === false) return false;
+		return this.#walk(node.right, visit);
+	}
+};
+function isEOL(charCode) {
+	return charCode === 10 || charCode === 13;
+}
+function clamp(value, min, max) {
+	return Math.min(Math.max(value, min), max);
+}
+function createPrefixTable(text) {
+	const table = Array.from({ length: text.length }).fill(0);
+	let matched = 0;
+	for (let i = 1; i < text.length; i++) {
+		const charCode = text.charCodeAt(i);
+		while (matched > 0 && charCode !== text.charCodeAt(matched)) matched = table[matched - 1];
+		if (charCode === text.charCodeAt(matched)) matched++;
+		table[i] = matched;
+	}
+	return table;
+}
+function normalizeRanges(ranges, length) {
+	const normalized = [];
+	for (const [rawStart, rawEnd] of ranges) {
+		const start = clamp(rawStart, 0, length);
+		const end = clamp(rawEnd, start, length);
+		if (start < end) normalized.push([start, end]);
+	}
+	normalized.sort((a, b) => a[0] - b[0]);
+	const merged = [];
+	for (const range of normalized) {
+		const previous = merged[merged.length - 1];
+		if (previous !== void 0 && range[0] <= previous[1]) {
+			previous[1] = Math.max(previous[1], range[1]);
+			continue;
+		}
+		merged.push(range);
+	}
+	return merged;
+}
+function rangeOverlaps(ranges, start, end) {
+	let low = 0;
+	let high = ranges.length;
+	while (low < high) {
+		const mid = low + Math.floor((high - low) / 2);
+		if (ranges[mid][1] <= start) low = mid + 1;
+		else high = mid;
+	}
+	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 upperBound(values, target) {
+	let lo = 0;
+	let hi = values.length;
+	while (lo < hi) {
+		const mid = lo + Math.floor((hi - lo) / 2);
+		if (values[mid] <= target) lo = mid + 1;
+		else hi = mid;
+	}
+	return lo;
+}
+function escapeRegExp(text) {
+	return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function isWordSeparatorCharCode(charCode) {
+	if (charCode <= 32 || charCode === 127) return true;
+	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));
+	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);
+}
+function advancePastEmptyMatch(text, index) {
+	if (index + 1 < text.length) {
+		const first = text.charCodeAt(index);
+		const second = text.charCodeAt(index + 1);
+		if (first >= 55296 && first <= 56319 && second >= 56320 && second <= 57343) return index + 2;
+	}
+	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 };
+//# sourceMappingURL=pieceTable.js.map