@pierre/diffs 1.3.0-beta.5 → 1.3.0-beta.7

package/dist/editor/selection.js

@@ -1,5 +1,5 @@
+import { createSegmenter, endsWithLineBreak, getGraphemeSegmenter } from "./utils.js";
 import { applyDocumentChangeToLineAnnotations } from "./lineAnnotations.js";
-
 //#region src/editor/selection.ts
 const DirectionBackward = -1;
 const DirectionNone = 0;
@@ -7,7 +7,7 @@ const DirectionForward = 1;
 /**
 * Converts a selection from a web selection to an editor selection.
 */
-function convertSelection(range, direction = DirectionNone) {
+function convertSelection(range, direction = 0) {
 	const start = boundaryToPosition(range.startContainer, range.startOffset);
 	const end = boundaryToPosition(range.endContainer, range.endOffset);
 	if (start === null || end === null) return;
@@ -81,31 +81,28 @@ function mapCursorMove(textDocument, selections, shortcut) {
 	return selections.map((selection) => {
 		let { line, character } = shortcut === "up" || shortcut === "left" ? selection.start : selection.end;
 		if (shortcut === "textStart" || shortcut === "start" || shortcut === "end") {
+			const caret = getCaretPosition(selection);
+			line = caret.line;
+			character = caret.character;
 			if (shortcut === "textStart") {
 				const indent = getLeadingSpaces(textDocument.getLineText(line));
 				character = character === indent ? 0 : indent;
 			} else character = shortcut === "start" ? 0 : textDocument.getLineLength(line);
-			if (selection.direction === DirectionBackward) line = selection.start.line;
-			else line = selection.end.line;
 		} else if (shortcut === "up") line = Math.max(0, line - 1);
 		else if (shortcut === "down") line = Math.min(Math.max(lineCount - 1, 0), line + 1);
 		else if (isCollapsedSelection(selection)) {
 			const lineLength = textDocument.getLineLength(line);
 			character = Math.min(character, lineLength);
 			if (shortcut === "left") {
-				character--;
-				if (character < 0) if (line === 0) character = 0;
-				else {
-					line = Math.max(0, line - 1);
+				if (character > 0) character = stepCharacterByGrapheme(textDocument, line, character, false);
+				else if (line > 0) {
+					line = line - 1;
 					character = textDocument.getLineLength(line);
 				}
-			} else {
-				character++;
-				if (character > lineLength) if (line === lineCount - 1) character--;
-				else {
-					line = Math.min(Math.max(lineCount - 1, 0), line + 1);
-					character = 0;
-				}
+			} else if (character < lineLength) character = stepCharacterByGrapheme(textDocument, line, character, true);
+			else if (line < lineCount - 1) {
+				line = line + 1;
+				character = 0;
 			}
 		}
 		const pos = {
@@ -115,7 +112,7 @@ function mapCursorMove(textDocument, selections, shortcut) {
 		return {
 			start: pos,
 			end: pos,
-			direction: DirectionNone
+			direction: 0
 		};
 	});
 }
@@ -124,20 +121,19 @@ function mapCursorMove(textDocument, selections, shortcut) {
 */
 function mapSelectionShift(textDocument, selections, shortcut) {
 	return selections.map((selection) => {
-		const [anchorOffset, focusOffset] = getSelectionAnchorAndFocusOffsets(textDocument, selection);
-		const focusPosition = textDocument.positionAt(focusOffset);
+		const focusPosition = selection.direction === -1 ? selection.start : selection.end;
 		const [movedFocusSelection] = mapCursorMove(textDocument, [{
 			start: focusPosition,
 			end: focusPosition,
-			direction: DirectionNone
+			direction: 0
 		}], shortcut);
-		return createSelectionFromAnchorAndFocusOffsets(textDocument, anchorOffset, textDocument.offsetAt(movedFocusSelection.start));
+		return createSelectionFrom(selection, movedFocusSelection);
 	});
 }
 /**
 * Applies a text change to the given text document
 */
-function applyTextChangeToSelections(textDocument, selections, edit, lineAnnotations, tabSize = 2) {
+function applyTextChangeToSelections(textDocument, selections, edit, lineAnnotations, tabSize = 2, undoBoundary = false) {
 	if (selections[selections.length - 1] === void 0) return { nextSelections: [] };
 	const selectionPositions = [];
 	for (const selection of selections) selectionPositions.push(selection.start, selection.end);
@@ -202,7 +198,7 @@ function applyTextChangeToSelections(textDocument, selections, edit, lineAnnotat
 		};
 	}
 	finalizeMergedGroup();
-	const change = textDocument.applyResolvedEdits(edits, true, selections);
+	const change = textDocument.applyResolvedEdits(edits, true, selections, void 0, undoBoundary);
 	const nextSelections = createSelectionsFromOffsetPairs(textDocument, nextSelectionOffsets.map((offsets) => {
 		if (offsets === void 0) throw new Error("Missing next selection offsets");
 		return offsets;
@@ -218,9 +214,27 @@ function applyTextChangeToSelections(textDocument, selections, edit, lineAnnotat
 	};
 }
 /**
+* Returns the next anchor/focus offsets after replacing a selection range.
+* When the inserted text still contains the original selection (auto-surround),
+* the inner range is reselected to match VS Code/CodeMirror behavior.
+*/
+function getNextSelectionOffsetPairAfterReplace(textDocument, entry, offsetDelta, newText) {
+	const insertStart = entry.start + offsetDelta;
+	const insertEnd = insertStart + newText.length;
+	if (entry.end - entry.start > 0) {
+		const originalText = textDocument.getText().slice(entry.start, entry.end);
+		const preservedOffset = newText.indexOf(originalText);
+		if (preservedOffset !== -1 && preservedOffset + originalText.length <= newText.length) {
+			const rangeStart = insertStart + preservedOffset;
+			return [rangeStart, rangeStart + originalText.length];
+		}
+	}
+	return [insertEnd, insertEnd];
+}
+/**
 * Applies a text replace to multiple selections.
 */
-function applyTextReplaceToSelections(textDocument, selections, texts, lineAnnotations) {
+function applyTextReplaceToSelections(textDocument, selections, texts, lineAnnotations, undoBoundary = false) {
 	if (selections.length !== texts.length) throw new Error("Selection text replacements must match the selection count");
 	const selectionPositions = [];
 	for (const selection of selections) selectionPositions.push(selection.start, selection.end);
@@ -247,12 +261,12 @@ function applyTextReplaceToSelections(textDocument, selections, texts, lineAnnot
 	});
 	const allDeletes = texts.every((text) => text === "");
 	let edits;
-	const nextSelectionOffsets = Array.from({ length: selections.length });
+	const nextSelectionOffsetPairs = Array.from({ length: selections.length });
 	if (allDeletes) {
 		edits = [];
 		let hasEffect = false;
 		for (const entry of ordered) {
-			nextSelectionOffsets[entry.index] = entry.end;
+			nextSelectionOffsetPairs[entry.index] = [entry.end, entry.end];
 			if (entry.start >= entry.end) continue;
 			hasEffect = true;
 			const last = edits[edits.length - 1];
@@ -282,7 +296,7 @@ function applyTextReplaceToSelections(textDocument, selections, texts, lineAnnot
 				break;
 			}
 			if (next === caret) next += delta;
-			nextSelectionOffsets[entry.index] = next;
+			nextSelectionOffsetPairs[entry.index] = [next, next];
 		}
 	} else {
 		edits = [];
@@ -297,12 +311,15 @@ function applyTextReplaceToSelections(textDocument, selections, texts, lineAnnot
 				end: entry.end,
 				text: newText
 			});
-			nextSelectionOffsets[entry.index] = entry.start + offsetDelta + newText.length;
+			nextSelectionOffsetPairs[entry.index] = getNextSelectionOffsetPairAfterReplace(textDocument, entry, offsetDelta, newText);
 			offsetDelta += newText.length - (entry.end - entry.start);
 		}
 	}
-	const change = textDocument.applyResolvedEdits(edits, true, selections);
-	const nextSelections = createSelectionsFromOffsetPairs(textDocument, nextSelectionOffsets.map((offset) => [offset, offset]));
+	const change = textDocument.applyResolvedEdits(edits, true, selections, void 0, undoBoundary);
+	const nextSelections = createSelectionsFromOffsetPairs(textDocument, nextSelectionOffsetPairs.map((offsets) => {
+		if (offsets === void 0) throw new Error("Missing next selection offsets");
+		return offsets;
+	}));
 	textDocument.setLastUndoSelectionsAfter(nextSelections);
 	if (change !== void 0 && lineAnnotations !== void 0) {
 		const nextLineAnnotations = applyDocumentChangeToLineAnnotations(change, lineAnnotations);
@@ -313,6 +330,47 @@ function applyTextReplaceToSelections(textDocument, selections, texts, lineAnnot
 		change
 	};
 }
+const AUTO_SURROUND_CLOSE_CHARS = /* @__PURE__ */ new Map([
+	["'", "'"],
+	["\"", "\""],
+	["`", "`"],
+	["{", "}"],
+	["[", "]"],
+	["<", ">"],
+	["(", ")"]
+]);
+const AUTO_SURROUND_QUOTE_CHARS = /* @__PURE__ */ new Set([
+	"'",
+	"\"",
+	"`"
+]);
+const AUTO_SURROUND_BRACKET_CHARS = /* @__PURE__ */ new Set([
+	"{",
+	"[",
+	"(",
+	"<"
+]);
+function shouldAutoSurroundChar(autoSurround, char) {
+	if (autoSurround === "never") return false;
+	if (autoSurround === "brackets") return AUTO_SURROUND_BRACKET_CHARS.has(char);
+	if (autoSurround === "quotes") return AUTO_SURROUND_QUOTE_CHARS.has(char);
+	return true;
+}
+/**
+* Returns per-selection replacement text when typing a surround character over
+* non-collapsed selections, matching VS Code auto-surround behavior.
+*/
+function getAutoSurroundReplacementTexts(textDocument, selections, char, autoSurround) {
+	if (char.length !== 1 || selections.length === 0) return;
+	const closeChar = AUTO_SURROUND_CLOSE_CHARS.get(char);
+	if (closeChar === void 0 || !shouldAutoSurroundChar(autoSurround, char)) return;
+	const replacements = [];
+	for (const selection of selections) {
+		if (isCollapsedSelection(selection)) return;
+		replacements.push(char + textDocument.getText(selection) + closeChar);
+	}
+	return replacements;
+}
 /**
 * Swaps the two characters adjacent to a collapsed selection, matching browser
 * insertTranspose (Ctrl+T) behavior.
@@ -329,36 +387,48 @@ function applyTransposeToSelections(textDocument, selections, lineAnnotations) {
 		}
 		const { line, character } = selection.start;
 		const offset = anchor;
-		const lineLength = textDocument.getLineLength(line);
+		const lineText = textDocument.getLineText(line);
+		const lineLength = lineText.length;
+		const lineStart = offset - character;
+		const graphemeStarts = getLineGraphemeStarts(lineText);
 		let edit;
 		if (character > 0 && character < lineLength) {
+			const before = findClusterBreak(lineText, character, false, graphemeStarts);
+			const after = findClusterBreak(lineText, character, true, graphemeStarts);
 			edit = {
-				start: offset - 1,
-				end: offset + 1,
-				text: text[offset] + text[offset - 1]
+				start: lineStart + before,
+				end: lineStart + after,
+				text: lineText.slice(character, after) + lineText.slice(before, character)
 			};
-			nextOffsetPairs.push([offset + 1, offset + 1]);
-		} else if (character === lineLength && lineLength >= 2) {
+			nextOffsetPairs.push([lineStart + after, lineStart + after]);
+		} else if (character === lineLength && graphemeStarts.length >= 2) {
+			const lastStart = graphemeStarts[graphemeStarts.length - 1];
+			const secondLastStart = graphemeStarts[graphemeStarts.length - 2];
 			edit = {
-				start: offset - 2,
+				start: lineStart + secondLastStart,
 				end: offset,
-				text: text[offset - 1] + text[offset - 2]
+				text: lineText.slice(lastStart, lineLength) + lineText.slice(secondLastStart, lastStart)
 			};
 			nextOffsetPairs.push([offset, offset]);
 		} else if (character === 0 && line > 0 && lineLength > 0) {
 			const prevLine = line - 1;
-			const prevLength = textDocument.getLineLength(prevLine);
+			const prevLineText = textDocument.getLineText(prevLine);
+			const prevLength = prevLineText.length;
 			const prevEnd = textDocument.offsetAt({
 				line: prevLine,
 				character: prevLength
 			});
-			const prevStart = prevLength > 0 ? prevEnd - 1 : prevEnd;
+			const prevGraphemeStart = prevLength > 0 ? findClusterBreak(prevLineText, prevLength, false, getLineGraphemeStarts(prevLineText)) : prevLength;
+			const firstEnd = findClusterBreak(lineText, 0, true, graphemeStarts);
+			const prevStart = prevEnd - (prevLength - prevGraphemeStart);
+			const newText = lineText.slice(0, firstEnd) + text.slice(prevEnd, offset) + prevLineText.slice(prevGraphemeStart, prevLength);
 			edit = {
 				start: prevStart,
-				end: offset + 1,
-				text: text[offset] + text.slice(prevEnd, offset) + text.slice(prevStart, prevEnd)
+				end: offset + firstEnd,
+				text: newText
 			};
-			nextOffsetPairs.push([offset + 1, offset + 1]);
+			const caret = prevStart + newText.length;
+			nextOffsetPairs.push([caret, caret]);
 		} else {
 			nextOffsetPairs.push([anchor, focus]);
 			continue;
@@ -391,7 +461,7 @@ function applyDeleteHardLineForwardToSelections(textDocument, selections, lineAn
 		return {
 			start: range.start,
 			end: range.end,
-			direction: DirectionNone
+			direction: 0
 		};
 	});
 	return applyTextReplaceToSelections(textDocument, deleteSelections, deleteSelections.map(() => ""), lineAnnotations);
@@ -405,7 +475,7 @@ function applyDeleteSoftLineBackwardToSelections(textDocument, selections, getSo
 		if (!isCollapsedSelection(selection)) return {
 			start: selection.start,
 			end: selection.end,
-			direction: DirectionNone
+			direction: 0
 		};
 		const caret = getCaretPosition(selection);
 		const { line, character } = caret;
@@ -419,12 +489,12 @@ function applyDeleteSoftLineBackwardToSelections(textDocument, selections, getSo
 				line,
 				character
 			},
-			direction: DirectionNone
+			direction: 0
 		};
 		if (line === 0) return {
 			start: caret,
 			end: caret,
-			direction: DirectionNone
+			direction: 0
 		};
 		const prevLineLength = textDocument.getLineLength(line - 1);
 		return {
@@ -436,7 +506,7 @@ function applyDeleteSoftLineBackwardToSelections(textDocument, selections, getSo
 				line,
 				character: 0
 			},
-			direction: DirectionNone
+			direction: 0
 		};
 	});
 	return applyTextReplaceToSelections(textDocument, deleteSelections, deleteSelections.map(() => ""), lineAnnotations);
@@ -451,7 +521,77 @@ function applyDeleteWordBackwardToSelections(textDocument, selections, lineAnnot
 		return {
 			start,
 			end,
-			direction: DirectionNone
+			direction: 0
+		};
+	});
+	return applyTextReplaceToSelections(textDocument, deleteSelections, deleteSelections.map(() => ""), lineAnnotations);
+}
+/**
+* Resolves the document range deleted by Backspace or Delete at a collapsed
+* caret. Non-collapsed selections delete their selected text instead.
+*/
+function resolveDeleteCharacterRange(textDocument, selection, forward) {
+	if (!isCollapsedSelection(selection)) return [selection.start, selection.end];
+	const caret = getCaretPosition(selection);
+	let { line, character } = caret;
+	const lineLength = textDocument.getLineLength(line);
+	const lineCount = textDocument.lineCount;
+	character = Math.min(character, lineLength);
+	if (forward) {
+		if (character < lineLength) return [{
+			line,
+			character
+		}, {
+			line,
+			character: stepCharacterByGrapheme(textDocument, line, character, true)
+		}];
+		if (line < lineCount - 1) return [{
+			line,
+			character: lineLength
+		}, {
+			line: line + 1,
+			character: 0
+		}];
+		return [caret, caret];
+	}
+	if (character > 0) return [{
+		line,
+		character: stepCharacterByGrapheme(textDocument, line, character, false)
+	}, {
+		line,
+		character
+	}];
+	if (line > 0) {
+		const prevLineLength = textDocument.getLineLength(line - 1);
+		return [{
+			line: line - 1,
+			character: prevLineLength
+		}, {
+			line,
+			character: 0
+		}];
+	}
+	return [caret, caret];
+}
+/**
+* Deletes one grapheme (or selected text) at each selection.
+*/
+function applyDeleteCharacterToSelections(textDocument, selections, forward, lineAnnotations, tabSize = 2) {
+	const deleteSelections = selections.map((selection) => {
+		let [start, end] = resolveDeleteCharacterRange(textDocument, selection, forward);
+		if (!forward && isCollapsedSelection(selection)) {
+			const normalized = normalizeLeadingIndentForChange(textDocument, {
+				start: textDocument.offsetAt(start),
+				end: textDocument.offsetAt(end),
+				text: ""
+			}, tabSize);
+			start = textDocument.positionAt(normalized.start);
+			end = textDocument.positionAt(normalized.end);
+		}
+		return {
+			start,
+			end,
+			direction: 0
 		};
 	});
 	return applyTextReplaceToSelections(textDocument, deleteSelections, deleteSelections.map(() => ""), lineAnnotations);
@@ -467,7 +607,7 @@ function isCollapsedSelection(selection) {
 */
 function getCaretPosition(selection) {
 	const { start, end, direction } = selection;
-	return direction === DirectionBackward ? start : end;
+	return direction === -1 ? start : end;
 }
 /**
 * Checks if a line is editable.
@@ -497,7 +637,7 @@ function comparePosition(a, b) {
 * Creates a selection from anchor and focus offsets.
 */
 function createSelectionFromAnchorAndFocusOffsets(textDocument, anchorOffset, focusOffset) {
-	const direction = anchorOffset === focusOffset ? DirectionNone : anchorOffset < focusOffset ? DirectionForward : DirectionBackward;
+	const direction = anchorOffset === focusOffset ? 0 : anchorOffset < focusOffset ? 1 : -1;
 	const start = Math.min(anchorOffset, focusOffset);
 	const end = Math.max(anchorOffset, focusOffset);
 	return {
@@ -507,10 +647,44 @@ function createSelectionFromAnchorAndFocusOffsets(textDocument, anchorOffset, fo
 	};
 }
 /**
+* Maps a single offset from the pre-edit document into the post-edit document.
+* `edits` are resolved edits in pre-edit offsets, sorted ascending and
+* non-overlapping. An offset at or after an edit's start shifts to the end of
+* that edit's replacement (right gravity), so text inserted at the caret pushes
+* the caret past it; an offset strictly before an edit is only shifted by the
+* net length change of the edits that precede it.
+*/
+function remapOffsetThroughEdits(offset, edits) {
+	let delta = 0;
+	for (const edit of edits) {
+		if (offset < edit.start) break;
+		if (offset >= edit.end) delta += edit.text.length - (edit.end - edit.start);
+		else return edit.start + delta + edit.text.length;
+	}
+	return offset + delta;
+}
+/**
+* Re-anchors selections after a batch of text edits has been applied, so the
+* caret keeps pointing at the same logical location in the changed buffer.
+*
+* `selectionOffsets` (one `[start, end]` pair per selection) and `edits` are
+* measured in the PRE-edit document; the returned selections are built from
+* `textDocument`, which must already reflect the applied edits. Selection
+* direction is preserved by remapping each edge and re-deriving anchor/focus.
+*/
+function remapSelectionsAfterEdits(textDocument, selections, selectionOffsets, edits) {
+	return selections.map((selection, index) => {
+		const [startOffset, endOffset] = selectionOffsets[index];
+		const nextStart = remapOffsetThroughEdits(startOffset, edits);
+		const nextEnd = remapOffsetThroughEdits(endOffset, edits);
+		return createSelectionFromAnchorAndFocusOffsets(textDocument, selection.direction === -1 ? nextEnd : nextStart, selection.direction === -1 ? nextStart : nextEnd);
+	});
+}
+/**
 * Creates a selection from a anchor and focus selection.
 */
 function createSelectionFrom(anchorSelection, focusSelection) {
-	const anchor = anchorSelection.direction === DirectionBackward ? anchorSelection.end : anchorSelection.start;
+	const anchor = anchorSelection.direction === -1 ? anchorSelection.end : anchorSelection.start;
 	const currentStartOrder = comparePosition(anchor, focusSelection.start);
 	const currentEndOrder = comparePosition(anchor, focusSelection.end);
 	let focus = focusSelection.end;
@@ -521,7 +695,7 @@ function createSelectionFrom(anchorSelection, focusSelection) {
 	return {
 		start: anchorVsFocus <= 0 ? anchor : focus,
 		end: anchorVsFocus <= 0 ? focus : anchor,
-		direction: anchorVsFocus === 0 ? DirectionNone : anchorVsFocus < 0 ? DirectionForward : DirectionBackward
+		direction: anchorVsFocus === 0 ? 0 : anchorVsFocus < 0 ? 1 : -1
 	};
 }
 /**
@@ -534,22 +708,22 @@ function extendSelection(original, target) {
 	if (leftExtended && !rightExtended) return {
 		start: target.start,
 		end: original.end,
-		direction: DirectionBackward
+		direction: -1
 	};
 	if (rightExtended && !leftExtended) return {
 		start: original.start,
 		end: target.end,
-		direction: DirectionForward
+		direction: 1
 	};
-	if (original.direction === DirectionBackward) return {
+	if (original.direction === -1) return {
 		start: target.start,
 		end: original.end,
-		direction: comparePosition(target.start, original.end) === 0 ? DirectionNone : DirectionBackward
+		direction: comparePosition(target.start, original.end) === 0 ? 0 : -1
 	};
 	return {
 		start: original.start,
 		end: target.end,
-		direction: comparePosition(original.start, target.end) === 0 ? DirectionNone : DirectionForward
+		direction: comparePosition(original.start, target.end) === 0 ? 0 : 1
 	};
 }
 /**
@@ -565,30 +739,39 @@ function extendSelections(selections, target) {
 */
 function mergeOverlappingSelections(selections) {
 	if (selections.length <= 1) return selections;
-	const selected = /* @__PURE__ */ new Set();
-	const accepted = [];
-	for (let i = selections.length - 1; i >= 0; i--) {
-		const selection = selections[i];
-		if (selection === void 0) continue;
-		let left = 0;
-		let right = accepted.length;
-		while (left < right) {
-			const mid = Math.floor((left + right) / 2);
-			const candidate = accepted[mid]?.selection;
-			if (candidate === void 0) break;
-			if (comparePosition(candidate.start, selection.start) < 0) left = mid + 1;
-			else right = mid;
+	const ordered = selections.map((selection, index) => ({
+		index,
+		selection
+	})).sort((a, b) => {
+		const startOrder = comparePosition(a.selection.start, b.selection.start);
+		if (startOrder !== 0) return startOrder;
+		const endOrder = comparePosition(a.selection.end, b.selection.end);
+		return endOrder !== 0 ? endOrder : a.index - b.index;
+	});
+	const merged = [];
+	let current = ordered[0];
+	for (const entry of ordered.slice(1)) {
+		if (selectionIntersects(current.selection, entry.selection)) {
+			const latest = entry.index > current.index ? entry : current;
+			const start = comparePosition(entry.selection.start, current.selection.start) < 0 ? entry.selection.start : current.selection.start;
+			const end = comparePosition(entry.selection.end, current.selection.end) > 0 ? entry.selection.end : current.selection.end;
+			let direction = latest.selection.direction;
+			if (direction === 0 && comparePosition(start, end) !== 0) direction = comparePosition(latest.selection.start, start) === 0 ? -1 : 1;
+			current = {
+				index: latest.index,
+				selection: {
+					direction,
+					end,
+					start
+				}
+			};
+			continue;
 		}
-		const previous = accepted[left - 1]?.selection;
-		const next = accepted[left]?.selection;
-		if (previous !== void 0 && selectionIntersects(previous, selection) || next !== void 0 && selectionIntersects(next, selection)) continue;
-		accepted.splice(left, 0, {
-			index: i,
-			selection
-		});
-		selected.add(i);
+		merged.push(current);
+		current = entry;
 	}
-	return selections.filter((_, index) => selected.has(index));
+	merged.push(current);
+	return merged.sort((a, b) => a.index - b.index).map(({ selection }) => selection);
 }
 /**
 * Finds the next matching word and updates the selections.
@@ -622,36 +805,182 @@ function getDocumentFullSelection(textDocument) {
 			line: lastLine,
 			character: textDocument.getLineLength(lastLine)
 		},
-		direction: DirectionForward
+		direction: 1
 	};
 }
 /**
 * Get the boundary selection of the document.
 */
-function getDocumentBoundarySelection(textDocument, atEnd) {
-	const line = atEnd ? textDocument.lineCount - 1 : 0;
+function getDocumentBoundarySelection(textDocument, atEnd, trimmedEndNewLine) {
+	let line = 0;
+	if (atEnd) {
+		const lastLine = textDocument.lineCount - 1;
+		line = trimmedEndNewLine === true && lastLine > 0 && textDocument.getLineLength(lastLine) === 0 ? lastLine - 1 : lastLine;
+	}
+	const character = atEnd ? textDocument.getLineLength(line) : 0;
 	const start = {
 		line,
-		character: atEnd ? textDocument.getLineLength(line) : 0
+		character
 	};
 	return {
 		start,
 		end: start,
-		direction: DirectionForward
+		direction: 1
 	};
 }
 /**
-* Get the text of the selections for the given text document.
+* Resolves the document offset range each selection contributes to the
+* clipboard, ordered by position. A collapsed selection contributes its whole
+* logical line including the trailing line break; the final line has no
+* trailing break to include. A ranged selection contributes the selected text.
+*/
+function resolveClipboardRegions(textDocument, selections) {
+	return selections.map((selection) => {
+		if (isCollapsedSelection(selection)) {
+			const line = selection.start.line;
+			return {
+				start: textDocument.offsetAt({
+					line,
+					character: 0
+				}),
+				end: line < textDocument.lineCount - 1 ? textDocument.offsetAt({
+					line: line + 1,
+					character: 0
+				}) : textDocument.offsetAt({
+					line,
+					character: textDocument.getLineLength(line)
+				})
+			};
+		}
+		const start = textDocument.offsetAt(selection.start);
+		const end = textDocument.offsetAt(selection.end);
+		return start <= end ? {
+			start,
+			end
+		} : {
+			start: end,
+			end: start
+		};
+	}).sort((a, b) => {
+		const startOrder = a.start - b.start;
+		return startOrder !== 0 ? startOrder : a.end - b.end;
+	});
+}
+/**
+* Get the clipboard text of the selections for the given text document. Used by
+* both copy and cut so the two stay in sync. Overlapping regions (e.g. several
+* carets on one line) are merged so the same text is never emitted twice, and a
+* line-ending separator is inserted only between regions that aren't already
+* contiguous in the document.
 */
 function getSelectionText(textDocument, selections) {
-	return [...selections].sort((a, b) => {
-		const startOrder = comparePosition(a.start, b.start);
+	const regions = resolveClipboardRegions(textDocument, selections);
+	const eol = textDocument.eol;
+	let result = "";
+	let prevEnd = -1;
+	for (const region of regions) {
+		if (region.end <= region.start) continue;
+		if (region.start <= prevEnd) {
+			if (region.end > prevEnd) {
+				result += textDocument.getTextSlice(prevEnd, region.end);
+				prevEnd = region.end;
+			}
+			continue;
+		}
+		if (result.length > 0 && !endsWithLineBreak(result)) result += eol;
+		result += textDocument.getTextSlice(region.start, region.end);
+		prevEnd = region.end;
+	}
+	return result;
+}
+function resolveSelectionCutEdit(textDocument, selection) {
+	if (isCollapsedSelection(selection)) return resolveCollapsedSelectionCutEdit(textDocument, selection);
+	const [start, end] = comparePosition(selection.start, selection.end) <= 0 ? [selection.start, selection.end] : [selection.end, selection.start];
+	return {
+		start: textDocument.offsetAt(start),
+		end: textDocument.offsetAt(end),
+		text: ""
+	};
+}
+function resolveCollapsedSelectionCutEdit(textDocument, selection) {
+	const line = selection.start.line;
+	const lineStart = textDocument.offsetAt({
+		line,
+		character: 0
+	});
+	const lineEnd = textDocument.offsetAt({
+		line,
+		character: textDocument.getLineLength(line)
+	});
+	if (line < textDocument.lineCount - 1) return {
+		start: lineStart,
+		end: textDocument.offsetAt({
+			line: line + 1,
+			character: 0
+		}),
+		text: ""
+	};
+	if (line > 0) return {
+		start: textDocument.offsetAt({
+			line: line - 1,
+			character: textDocument.getLineLength(line - 1)
+		}),
+		end: lineEnd,
+		text: ""
+	};
+	return {
+		start: lineStart,
+		end: lineEnd,
+		text: ""
+	};
+}
+function mergeCutEdits(orderedCuts) {
+	const edits = [];
+	for (const { edit } of orderedCuts) {
+		if (edit.start >= edit.end) continue;
+		const last = edits.at(-1);
+		if (last !== void 0 && edit.start <= last.end) edits[edits.length - 1] = {
+			start: last.start,
+			end: Math.max(last.end, edit.end),
+			text: ""
+		};
+		else edits.push(edit);
+	}
+	return edits;
+}
+function mapCutSelectionOffsets(orderedCuts, edits) {
+	const nextOffsets = Array.from({ length: orderedCuts.length });
+	let editIndex = 0;
+	let offsetDelta = 0;
+	for (const cut of orderedCuts) {
+		while (editIndex < edits.length && cut.edit.start > edits[editIndex].end) {
+			const edit = edits[editIndex];
+			offsetDelta -= edit.end - edit.start;
+			editIndex++;
+		}
+		const edit = edits[editIndex];
+		if (edit !== void 0 && cut.edit.start >= edit.start && cut.edit.start <= edit.end) nextOffsets[cut.index] = edit.start + offsetDelta;
+		else nextOffsets[cut.index] = cut.edit.start + offsetDelta;
+	}
+	return nextOffsets;
+}
+function resolveSelectionCut(textDocument, selections) {
+	const orderedCuts = [...selections.map((selection, index) => ({
+		index,
+		edit: resolveSelectionCutEdit(textDocument, selection)
+	}))].sort((a, b) => {
+		const startOrder = a.edit.start - b.edit.start;
 		if (startOrder !== 0) return startOrder;
-		return comparePosition(a.end, b.end);
-	}).map((selection) => {
-		if (isCollapsedSelection(selection)) return textDocument.getLineText(selection.start.line, false);
-		return textDocument.getText(selection);
-	}).join("\n");
+		const endOrder = a.edit.end - b.edit.end;
+		if (endOrder !== 0) return endOrder;
+		return a.index - b.index;
+	});
+	const edits = mergeCutEdits(orderedCuts);
+	return {
+		text: getSelectionText(textDocument, selections),
+		edits,
+		nextSelectionOffsets: mapCutSelectionOffsets(orderedCuts, edits)
+	};
 }
 /**
 * Get the anchor node and offset for a selection.
@@ -703,15 +1032,28 @@ function expandCollapsedSelectionToWord(textDocument, selection) {
 			line,
 			character: span.end
 		},
-		direction: DirectionForward
+		direction: 1
 	};
 }
 function expandCollapsedLineWord(lineText, character) {
-	const segmenter = new Intl.Segmenter(void 0, { granularity: "word" });
-	for (const seg of segmenter.segment(lineText)) {
-		if (seg.isWordLike !== true) continue;
-		const lo = seg.index;
-		const hi = lo + seg.segment.length;
+	const segmenter = createSegmenter({ granularity: "word" });
+	if (segmenter !== void 0) {
+		for (const seg of segmenter.segment(lineText)) {
+			if (seg.isWordLike !== true) continue;
+			const lo = seg.index;
+			const hi = lo + seg.segment.length;
+			if (character >= lo && character <= hi) return {
+				start: lo,
+				end: hi
+			};
+		}
+		return;
+	}
+	const wordRe = /[\p{Alphabetic}\p{Number}_]+/gu;
+	let match;
+	while ((match = wordRe.exec(lineText)) !== null) {
+		const lo = match.index;
+		const hi = lo + match[0].length;
 		if (character >= lo && character <= hi) return {
 			start: lo,
 			end: hi
@@ -734,9 +1076,7 @@ function resolveDeleteWordBackwardRange(textDocument, selection) {
 		}];
 	}
 	const lineText = textDocument.getLineText(line);
-	const graphemeStarts = [0];
-	const segmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
-	for (const segment of segmenter.segment(lineText)) if (segment.index > 0) graphemeStarts.push(segment.index);
+	const graphemeStarts = getLineGraphemeStarts(lineText);
 	let pos = head;
 	let match;
 	while (pos > 0) {
@@ -766,8 +1106,58 @@ function findClusterBreak(text, pos, forward, graphemeStarts) {
 	}
 	return 0;
 }
+function getLineGraphemeStarts(lineText) {
+	const graphemeStarts = [0];
+	const segmenter = getGraphemeSegmenter();
+	if (segmenter !== void 0) {
+		for (const segment of segmenter.segment(lineText)) if (segment.index > 0) graphemeStarts.push(segment.index);
+		return graphemeStarts;
+	}
+	let index = 0;
+	for (const codePoint of lineText) {
+		if (index > 0) graphemeStarts.push(index);
+		index += codePoint.length;
+	}
+	return graphemeStarts;
+}
+function stepCharacterByGrapheme(textDocument, line, character, forward) {
+	const lineLength = textDocument.getLineLength(line);
+	if (forward) {
+		if (character >= lineLength) return lineLength;
+		const lineStart = textDocument.offsetAt({
+			line,
+			character: 0
+		});
+		const suffix = textDocument.getTextSlice(lineStart + character, lineStart + lineLength);
+		const segmenter = getGraphemeSegmenter();
+		if (segmenter !== void 0) {
+			for (const segment of segmenter.segment(suffix)) return character + segment.segment.length;
+			return lineLength;
+		}
+		for (const codePoint of suffix) return character + codePoint.length;
+		return lineLength;
+	}
+	if (character <= 0) return 0;
+	const lineStart = textDocument.offsetAt({
+		line,
+		character: 0
+	});
+	const prefix = textDocument.getTextSlice(lineStart, lineStart + character);
+	let prevStart = 0;
+	const segmenter = getGraphemeSegmenter();
+	if (segmenter !== void 0) {
+		for (const segment of segmenter.segment(prefix)) prevStart = segment.index;
+		return prevStart;
+	}
+	let index = 0;
+	for (const codePoint of prefix) {
+		prevStart = index;
+		index += codePoint.length;
+	}
+	return prevStart;
+}
 function getSelectionAnchorAndFocusOffsets(textDocument, selection) {
-	const isBackward = selection.direction === DirectionBackward;
+	const isBackward = selection.direction === -1;
 	return [textDocument.offsetAt(isBackward ? selection.end : selection.start), textDocument.offsetAt(getCaretPosition(selection))];
 }
 function resolveDeleteHardLineForwardRange(textDocument, selection) {
@@ -809,7 +1199,7 @@ function resolveDeleteHardLineForwardRange(textDocument, selection) {
 	};
 }
 function expandSingleNewlineInsert(textDocument, insertText, insertStartOffset) {
-	if (insertText !== "\n" && insertText !== "\r\n") return insertText;
+	if (insertText !== "\n" && insertText !== "\r" && insertText !== "\r\n") return insertText;
 	const line = textDocument.positionAt(insertStartOffset).line;
 	const lineText = textDocument.getLineText(line);
 	const indentLen = getLeadingSpaces(lineText);
@@ -829,7 +1219,7 @@ function createSelectionsFromOffsetPairs(textDocument, offsetPairs) {
 	for (const [anchorOffset, focusOffset] of offsetPairs) normalizedOffsets.push(Math.min(anchorOffset, focusOffset), Math.max(anchorOffset, focusOffset));
 	const positions = textDocument.positionsAt(normalizedOffsets);
 	return offsetPairs.map(([anchorOffset, focusOffset], index) => {
-		const direction = anchorOffset === focusOffset ? DirectionNone : anchorOffset < focusOffset ? DirectionForward : DirectionBackward;
+		const direction = anchorOffset === focusOffset ? 0 : anchorOffset < focusOffset ? 1 : -1;
 		return {
 			start: positions[index * 2],
 			end: positions[index * 2 + 1],
@@ -985,10 +1375,10 @@ function isInside(token, node) {
 }
 function offsetBefore(line, node) {
 	if (node.parentElement === line) {
-		let offset$1 = 0;
+		let offset = 0;
 		const index = Array.prototype.indexOf.call(line.childNodes, node);
-		for (let i = 0; i < index; i++) offset$1 = getLineChildEnd(line.childNodes[i]);
-		return offset$1;
+		for (let i = 0; i < index; i++) offset = getLineChildEnd(line.childNodes[i]);
+		return offset;
 	}
 	for (const token of collectTokens(line)) if (isInside(token, node)) return getCharacterIndex(token) + (node.nodeType === 3 ? textLengthBefore(token, node) : 0);
 	let offset = 0;
@@ -1018,10 +1408,10 @@ function getLineChildEnd(child, textOffsetInChild) {
 		if (parent === null) return 0;
 		const token = findTokenSpan(parent);
 		if (token === null) return 0;
-		const base$1 = getCharacterIndex(token);
-		if (base$1 === void 0) return 0;
+		const base = getCharacterIndex(token);
+		if (base === void 0) return 0;
 		const length = textOffsetInChild === void 0 ? getTextOffset(child.textContent, child.textContent?.length ?? 0) : getTextOffset(child.textContent, textOffsetInChild);
-		return base$1 + textLengthBefore(token, child) + length;
+		return base + textLengthBefore(token, child) + length;
 	}
 	if (child.nodeType !== 1) return 0;
 	const el = child;
@@ -1033,8 +1423,8 @@ function getLineChildEnd(child, textOffsetInChild) {
 	return end;
 }
 function getLineIndex(el) {
-	const { line } = el.dataset;
-	if (line !== void 0) {
+	const { line, lineType } = el.dataset;
+	if (line !== void 0 && lineType !== "change-deletion") {
 		const lineNumber = parseInt(line, 10);
 		if (!Number.isNaN(lineNumber)) return lineNumber - 1;
 	}
@@ -1051,7 +1441,7 @@ function getTextOffset(text, offset) {
 	const lineBreakIndex = value.search(/[\r\n]/);
 	return Math.min(offset, lineBreakIndex === -1 ? value.length : lineBreakIndex);
 }
-
 //#endregion
-export { DirectionBackward, DirectionForward, DirectionNone, applyDeleteHardLineForwardToSelections, applyDeleteSoftLineBackwardToSelections, applyDeleteWordBackwardToSelections, applyTextChangeToSelections, applyTextReplaceToSelections, applyTransposeToSelections, comparePosition, convertSelection, createSelectionFrom, createSelectionFromAnchorAndFocusOffsets, expandCollapsedSelectionToWord, extendSelection, extendSelections, findNexMatch, getCaretPosition, getDocumentBoundarySelection, getDocumentFullSelection, getSelectionAnchor, getSelectionText, isCollapsedSelection, isLineEditable, mapCursorMove, mapSelectionShift, mergeOverlappingSelections, resolveIndentEdits, selectionIntersects };
+export { DirectionBackward, DirectionForward, DirectionNone, applyDeleteCharacterToSelections, applyDeleteHardLineForwardToSelections, applyDeleteSoftLineBackwardToSelections, applyDeleteWordBackwardToSelections, applyTextChangeToSelections, applyTextReplaceToSelections, applyTransposeToSelections, comparePosition, convertSelection, createSelectionFrom, createSelectionFromAnchorAndFocusOffsets, expandCollapsedSelectionToWord, extendSelection, extendSelections, findNexMatch, getAutoSurroundReplacementTexts, getCaretPosition, getDocumentBoundarySelection, getDocumentFullSelection, getSelectionAnchor, getSelectionText, isCollapsedSelection, isLineEditable, mapCursorMove, mapSelectionShift, mergeOverlappingSelections, remapSelectionsAfterEdits, resolveDeleteCharacterRange, resolveIndentEdits, resolveSelectionCut, selectionIntersects };
+
 //# sourceMappingURL=selection.js.map