@pierre/diffs 1.2.5 → 1.3.0-beta.1

package/dist/editor/selection.js

@@ -0,0 +1,900 @@
+import { applyDocumentChangeToLineAnnotations } from "./lineAnnotations.js";
+
+//#region src/editor/selection.ts
+const DirectionBackward = -1;
+const DirectionNone = 0;
+const DirectionForward = 1;
+/**
+* Converts a selection from a web selection to an editor selection.
+*/
+function convertSelection(range, direction = DirectionNone) {
+	const start = boundaryToPosition(range.startContainer, range.startOffset);
+	const end = boundaryToPosition(range.endContainer, range.endOffset);
+	if (start === null || end === null) return;
+	return {
+		start,
+		end,
+		direction
+	};
+}
+/**
+* Resolves the indent edits for a selection.
+*/
+function resolveIndentEdits(textDocument, selection, tabSize, outdent) {
+	if (textDocument === void 0) return [[], selection];
+	const { start, end } = selection;
+	const edits = [];
+	let newSelection = { ...selection };
+	let endLine = end.line;
+	if (start.line < end.line && end.character === 0) endLine--;
+	for (let line = start.line; line <= endLine; line++) {
+		const lineText = textDocument.getLineText(line);
+		if (lineText === void 0) continue;
+		const indentUnit = lineText.startsWith("	") ? "	" : " ".repeat(tabSize);
+		let deleteLength = 0;
+		let newText = indentUnit;
+		if (outdent) {
+			if (lineText.startsWith("	")) deleteLength = 1;
+			else if (lineText.startsWith(" ")) {
+				const leadingSpacesLength = lineText.length - lineText.trimStart().length;
+				deleteLength = Math.min(indentUnit.length, leadingSpacesLength);
+			}
+			if (deleteLength === 0) continue;
+			newText = "";
+		}
+		edits.push({
+			range: {
+				start: {
+					line,
+					character: 0
+				},
+				end: {
+					line,
+					character: deleteLength
+				}
+			},
+			newText
+		});
+		const delta = newText.length - deleteLength;
+		if (line === start.line) newSelection = {
+			...newSelection,
+			start: {
+				...start,
+				character: Math.max(0, start.character + delta)
+			}
+		};
+		if (line === end.line) newSelection = {
+			...newSelection,
+			end: {
+				...end,
+				character: Math.max(0, end.character + delta)
+			}
+		};
+	}
+	return [edits, newSelection];
+}
+/**
+* Maps the cursor move to all selections.
+*/
+function mapCursorMove(textDocument, selections, shortcut) {
+	const lineCount = textDocument.lineCount;
+	return selections.map((selection) => {
+		let { line, character } = shortcut === "up" || shortcut === "left" ? selection.start : selection.end;
+		if (shortcut === "textStart" || shortcut === "start" || shortcut === "end") {
+			if (shortcut === "textStart") {
+				const indent = getLeadingSpaces(textDocument.getLineText(line));
+				character = character === indent ? 0 : indent;
+			} else character = shortcut === "start" ? 0 : textDocument.getLineText(line).length;
+			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)) if (shortcut === "left") {
+			character--;
+			if (character < 0) if (line === 0) character = 0;
+			else {
+				line = Math.max(0, line - 1);
+				character = textDocument.getLineText(line).length;
+			}
+		} else {
+			character++;
+			if (character > textDocument.getLineText(line).length) if (line === lineCount - 1) character--;
+			else {
+				line = Math.min(Math.max(lineCount - 1, 0), line + 1);
+				character = 0;
+			}
+		}
+		const pos = {
+			line,
+			character
+		};
+		return {
+			start: pos,
+			end: pos,
+			direction: DirectionNone
+		};
+	});
+}
+/**
+* Same as mapCursorMove, but with shift key pressed.
+*/
+function mapSelectionShift(textDocument, selections, shortcut) {
+	return selections.map((selection) => {
+		const [anchorOffset, focusOffset] = getSelectionAnchorAndFocusOffsets(textDocument, selection);
+		const focusPosition = textDocument.positionAt(focusOffset);
+		const [movedFocusSelection] = mapCursorMove(textDocument, [{
+			start: focusPosition,
+			end: focusPosition,
+			direction: DirectionNone
+		}], shortcut);
+		return createSelectionFromAnchorAndFocusOffsets(textDocument, anchorOffset, textDocument.offsetAt(movedFocusSelection.start));
+	});
+}
+/**
+* Applies a text change to the given text document
+*/
+function applyTextChangeToSelections(textDocument, selections, edit, lineAnnotations, tabSize = 2) {
+	if (selections[selections.length - 1] === void 0) return { nextSelections: [] };
+	const selectionPositions = [];
+	for (const selection of selections) selectionPositions.push(selection.start, selection.end);
+	const selectionOffsets = textDocument.offsetsAt(selectionPositions);
+	const primaryStartOffset = selectionOffsets[(selections.length - 1) * 2];
+	const primaryEndOffset = selectionOffsets[(selections.length - 1) * 2 + 1];
+	const ordered = [];
+	let isAlreadyOrdered = true;
+	for (let index = 0; index < selections.length; index++) {
+		const entry = {
+			index,
+			start: selectionOffsets[index * 2],
+			end: selectionOffsets[index * 2 + 1]
+		};
+		const previous = ordered[ordered.length - 1];
+		if (previous !== void 0 && (entry.start < previous.start || entry.start === previous.start && entry.end < previous.end)) isAlreadyOrdered = false;
+		ordered.push(entry);
+	}
+	if (!isAlreadyOrdered) ordered.sort((a, b) => {
+		const startOrder = a.start - b.start;
+		if (startOrder !== 0) return startOrder;
+		const endOrder = a.end - b.end;
+		if (endOrder !== 0) return endOrder;
+		return a.index - b.index;
+	});
+	const adjustedChange = normalizeLeadingIndentForChange(textDocument, edit, tabSize);
+	const edits = [];
+	const nextSelectionOffsets = Array.from({ length: selections.length });
+	let offsetDelta = 0;
+	let mergedGroup;
+	const finalizeMergedGroup = () => {
+		if (mergedGroup === void 0) return;
+		const perGroupChange = normalizeLeadingIndentForChange(textDocument, {
+			start: mergedGroup.start,
+			end: mergedGroup.end,
+			text: adjustedChange.text
+		}, tabSize);
+		const newText = expandSingleNewlineInsert(textDocument, perGroupChange.text, perGroupChange.start);
+		edits.push({
+			start: perGroupChange.start,
+			end: perGroupChange.end,
+			text: newText
+		});
+		const nextOffsets = [mergedGroup.start + offsetDelta + newText.length, mergedGroup.start + offsetDelta + newText.length];
+		for (const index of mergedGroup.indices) nextSelectionOffsets[index] = nextOffsets;
+		offsetDelta += newText.length - (perGroupChange.end - perGroupChange.start);
+		mergedGroup = void 0;
+	};
+	for (const entry of ordered) {
+		const startOffset = Math.max(0, entry.start + (adjustedChange.start - primaryStartOffset));
+		const endOffset = Math.max(startOffset, entry.end + (adjustedChange.end - primaryEndOffset));
+		if (mergedGroup !== void 0 && startOffset < mergedGroup.end) {
+			mergedGroup.end = Math.max(mergedGroup.end, endOffset);
+			mergedGroup.indices.push(entry.index);
+			continue;
+		}
+		finalizeMergedGroup();
+		mergedGroup = {
+			start: startOffset,
+			end: endOffset,
+			indices: [entry.index]
+		};
+	}
+	finalizeMergedGroup();
+	const change = textDocument.applyResolvedEdits(edits, true, selections);
+	const nextSelections = createSelectionsFromOffsetPairs(textDocument, nextSelectionOffsets.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);
+		if (nextLineAnnotations !== void 0) textDocument.setLastUndoLineAnnotations(lineAnnotations, nextLineAnnotations);
+	}
+	return {
+		nextSelections,
+		change
+	};
+}
+/**
+* Applies a text replace to multiple selections.
+*/
+function applyTextReplaceToSelections(textDocument, selections, texts, lineAnnotations) {
+	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);
+	const selectionOffsets = textDocument.offsetsAt(selectionPositions);
+	const ordered = [];
+	let isAlreadyOrdered = true;
+	for (let index = 0; index < selections.length; index++) {
+		const entry = {
+			index,
+			start: selectionOffsets[index * 2],
+			end: selectionOffsets[index * 2 + 1],
+			text: texts[index]
+		};
+		const previous = ordered[ordered.length - 1];
+		if (previous !== void 0 && (entry.start < previous.start || entry.start === previous.start && entry.end < previous.end)) isAlreadyOrdered = false;
+		ordered.push(entry);
+	}
+	if (!isAlreadyOrdered) ordered.sort((a, b) => {
+		const startOrder = a.start - b.start;
+		if (startOrder !== 0) return startOrder;
+		const endOrder = a.end - b.end;
+		if (endOrder !== 0) return endOrder;
+		return a.index - b.index;
+	});
+	const edits = [];
+	const nextSelectionOffsets = Array.from({ length: selections.length });
+	let offsetDelta = 0;
+	let previousEditEnd = -1;
+	for (const entry of ordered) {
+		if (entry.start < previousEditEnd) throw new Error("Overlapping multi-selection edits are not supported");
+		previousEditEnd = entry.end;
+		const newText = expandSingleNewlineInsert(textDocument, entry.text, entry.start);
+		edits.push({
+			start: entry.start,
+			end: entry.end,
+			text: newText
+		});
+		nextSelectionOffsets[entry.index] = entry.start + offsetDelta + newText.length;
+		offsetDelta += newText.length - (entry.end - entry.start);
+	}
+	const change = textDocument.applyResolvedEdits(edits, true, selections);
+	const nextSelections = createSelectionsFromOffsetPairs(textDocument, nextSelectionOffsets.map((offset) => [offset, offset]));
+	textDocument.setLastUndoSelectionsAfter(nextSelections);
+	if (change !== void 0 && lineAnnotations !== void 0) {
+		const nextLineAnnotations = applyDocumentChangeToLineAnnotations(change, lineAnnotations);
+		if (nextLineAnnotations !== void 0) textDocument.setLastUndoLineAnnotations(lineAnnotations, nextLineAnnotations);
+	}
+	return {
+		nextSelections,
+		change
+	};
+}
+/**
+* Swaps the two characters adjacent to a collapsed selection, matching browser
+* insertTranspose (Ctrl+T) behavior.
+*/
+function applyTransposeToSelections(textDocument, selections, lineAnnotations) {
+	const text = textDocument.getText();
+	const edits = [];
+	const nextOffsetPairs = [];
+	for (const selection of selections) {
+		const [anchor, focus] = getSelectionAnchorAndFocusOffsets(textDocument, selection);
+		if (!isCollapsedSelection(selection)) {
+			nextOffsetPairs.push([anchor, focus]);
+			continue;
+		}
+		const { line, character } = selection.start;
+		const offset = anchor;
+		const lineLength = textDocument.getLineText(line).length;
+		let edit;
+		if (character > 0 && character < lineLength) {
+			edit = {
+				start: offset - 1,
+				end: offset + 1,
+				text: text[offset] + text[offset - 1]
+			};
+			nextOffsetPairs.push([offset + 1, offset + 1]);
+		} else if (character === lineLength && lineLength >= 2) {
+			edit = {
+				start: offset - 2,
+				end: offset,
+				text: text[offset - 1] + text[offset - 2]
+			};
+			nextOffsetPairs.push([offset, offset]);
+		} else if (character === 0 && line > 0 && lineLength > 0) {
+			const prevLine = line - 1;
+			const prevLength = textDocument.getLineText(prevLine).length;
+			const prevEnd = textDocument.offsetAt({
+				line: prevLine,
+				character: prevLength
+			});
+			const prevStart = prevLength > 0 ? prevEnd - 1 : prevEnd;
+			edit = {
+				start: prevStart,
+				end: offset + 1,
+				text: text[offset] + text.slice(prevEnd, offset) + text.slice(prevStart, prevEnd)
+			};
+			nextOffsetPairs.push([offset + 1, offset + 1]);
+		} else {
+			nextOffsetPairs.push([anchor, focus]);
+			continue;
+		}
+		edits.push(edit);
+	}
+	if (edits.length === 0) return { nextSelections: selections };
+	edits.sort((a, b) => a.start - b.start);
+	for (let index = 1; index < edits.length; index++) if (edits[index].start < edits[index - 1].end) throw new Error("Overlapping multi-selection edits are not supported");
+	const change = textDocument.applyResolvedEdits(edits, true, selections);
+	const nextSelections = createSelectionsFromOffsetPairs(textDocument, nextOffsetPairs);
+	textDocument.setLastUndoSelectionsAfter(nextSelections);
+	if (change !== void 0 && lineAnnotations !== void 0) {
+		const nextLineAnnotations = applyDocumentChangeToLineAnnotations(change, lineAnnotations);
+		if (nextLineAnnotations !== void 0) textDocument.setLastUndoLineAnnotations(lineAnnotations, nextLineAnnotations);
+	}
+	return {
+		nextSelections,
+		change
+	};
+}
+/**
+* Deletes from each selection to the end of its line, including the line break
+* when the caret is already at the end of a non-final line. Non-collapsed
+* selections delete their selected text instead.
+*/
+function applyDeleteHardLineForwardToSelections(textDocument, selections, lineAnnotations) {
+	const deleteSelections = selections.map((selection) => {
+		const range = resolveDeleteHardLineForwardRange(textDocument, selection);
+		return {
+			start: range.start,
+			end: range.end,
+			direction: DirectionNone
+		};
+	});
+	if (!deleteSelections.some((selection) => comparePosition(selection.start, selection.end) !== 0)) return { nextSelections: selections };
+	return applyTextReplaceToSelections(textDocument, deleteSelections, deleteSelections.map(() => ""), lineAnnotations);
+}
+/**
+* Checks if a selection is collapsed.
+*/
+function isCollapsedSelection(selection) {
+	return selection.start.line === selection.end.line && selection.start.character === selection.end.character;
+}
+/**
+* Returns the caret (focus) position for a selection.
+*/
+function getCaretPosition(selection) {
+	const { start, end, direction } = selection;
+	return direction === DirectionBackward ? start : end;
+}
+/**
+* Checks if a line is editable.
+*/
+function isLineEditable(lineType) {
+	return lineType === "context" || lineType === "change-addition" || lineType === "context-expanded";
+}
+/**
+* Checks whether selections `a` and `b` intersect.
+*/
+function selectionIntersects(a, b) {
+	const aCollapsed = isCollapsedSelection(a);
+	const bCollapsed = isCollapsedSelection(b);
+	if (aCollapsed && bCollapsed) return comparePosition(a.start, b.start) === 0;
+	if (aCollapsed) return comparePosition(b.start, a.start) <= 0 && comparePosition(a.start, b.end) <= 0;
+	if (bCollapsed) return comparePosition(a.start, b.start) <= 0 && comparePosition(b.start, a.end) <= 0;
+	return comparePosition(a.start, b.end) < 0 && comparePosition(b.start, a.end) < 0;
+}
+/**
+* Compares two positions.
+*/
+function comparePosition(a, b) {
+	if (a.line !== b.line) return a.line - b.line;
+	return a.character - b.character;
+}
+/**
+* Creates a selection from anchor and focus offsets.
+*/
+function createSelectionFromAnchorAndFocusOffsets(textDocument, anchorOffset, focusOffset) {
+	const direction = anchorOffset === focusOffset ? DirectionNone : anchorOffset < focusOffset ? DirectionForward : DirectionBackward;
+	const start = Math.min(anchorOffset, focusOffset);
+	const end = Math.max(anchorOffset, focusOffset);
+	return {
+		start: textDocument.positionAt(start),
+		end: textDocument.positionAt(end),
+		direction
+	};
+}
+/**
+* Creates a selection from a anchor and focus selection.
+*/
+function createSelectionFrom(anchorSelection, focusSelection) {
+	const anchor = anchorSelection.direction === DirectionBackward ? anchorSelection.end : anchorSelection.start;
+	const currentStartOrder = comparePosition(anchor, focusSelection.start);
+	const currentEndOrder = comparePosition(anchor, focusSelection.end);
+	let focus = focusSelection.end;
+	if (currentStartOrder <= 0) focus = focusSelection.end;
+	else if (currentEndOrder >= 0) focus = focusSelection.start;
+	else focus = currentStartOrder === 0 ? focusSelection.end : focusSelection.start;
+	const anchorVsFocus = comparePosition(anchor, focus);
+	return {
+		start: anchorVsFocus <= 0 ? anchor : focus,
+		end: anchorVsFocus <= 0 ? focus : anchor,
+		direction: anchorVsFocus === 0 ? DirectionNone : anchorVsFocus < 0 ? DirectionForward : DirectionBackward
+	};
+}
+/**
+* Extends or shrinks the selection `original` using the endpoints of `target`, \
+* matching contenteditable shift + click extend behavior.
+*/
+function extendSelection(original, target) {
+	const leftExtended = comparePosition(target.start, original.start) < 0;
+	const rightExtended = comparePosition(target.end, original.end) > 0;
+	if (leftExtended && !rightExtended) return {
+		start: target.start,
+		end: original.end,
+		direction: DirectionBackward
+	};
+	if (rightExtended && !leftExtended) return {
+		start: original.start,
+		end: target.end,
+		direction: DirectionForward
+	};
+	if (original.direction === DirectionBackward) return {
+		start: target.start,
+		end: original.end,
+		direction: comparePosition(target.start, original.end) === 0 ? DirectionNone : DirectionBackward
+	};
+	return {
+		start: original.start,
+		end: target.end,
+		direction: comparePosition(original.start, target.end) === 0 ? DirectionNone : DirectionForward
+	};
+}
+/**
+* Extends multiple selections.
+*/
+function extendSelections(selections, target) {
+	return mergeOverlappingSelections(selections.map((selection) => {
+		return extendSelection(selection, target);
+	}));
+}
+/**
+* Merges overlapping selections.
+*/
+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 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);
+	}
+	return selections.filter((_, index) => selected.has(index));
+}
+/**
+* Finds the next matching word and updates the selections.
+*/
+function findNexMatch(textDocument, selections) {
+	if (selections.length === 0) return;
+	const normalizedSelections = selections.map((selection) => isCollapsedSelection(selection) ? expandCollapsedSelectionToWord(textDocument, selection) : selection);
+	const texts = normalizedSelections.map((s) => textDocument.getText(s));
+	const needle = texts[0];
+	if (needle.length === 0 || texts.some((t) => t !== needle)) return;
+	const occupied = normalizedSelections.map((s) => [textDocument.offsetAt(s.start), textDocument.offsetAt(s.end)]);
+	const nextOffset = textDocument.findNextNonOverlappingSubstring(needle, occupied);
+	if (nextOffset === void 0) return normalizedSelections.some((selection, index) => {
+		const original = selections[index];
+		return comparePosition(selection.start, original.start) !== 0 || comparePosition(selection.end, original.end) !== 0 || selection.direction !== original.direction;
+	}) ? normalizedSelections : void 0;
+	const added = createSelectionFromAnchorAndFocusOffsets(textDocument, nextOffset, nextOffset + needle.length);
+	return [...normalizedSelections, added];
+}
+/**
+* Get the full selection of the document.
+*/
+function getDocumentFullSelection(textDocument) {
+	const lastLine = textDocument.lineCount - 1;
+	return {
+		start: {
+			line: 0,
+			character: 0
+		},
+		end: {
+			line: lastLine,
+			character: textDocument.getLineText(lastLine)?.length ?? 0
+		},
+		direction: DirectionForward
+	};
+}
+/**
+* Get the boundary selection of the document.
+*/
+function getDocumentBoundarySelection(textDocument, atEnd) {
+	const line = atEnd ? textDocument.lineCount - 1 : 0;
+	const start = {
+		line,
+		character: atEnd ? textDocument.getLineText(line)?.length ?? 0 : 0
+	};
+	return {
+		start,
+		end: start,
+		direction: DirectionForward
+	};
+}
+/**
+* Get the text of the selections for the given text document.
+*/
+function getSelectionText(textDocument, selections) {
+	return [...selections].sort((a, b) => {
+		const startOrder = comparePosition(a.start, b.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");
+}
+/**
+* Get the anchor node and offset for a selection.
+*/
+function getSelectionAnchor(lineElement, character) {
+	const ch = Math.max(0, character);
+	const tokens = collectTokens(lineElement);
+	let last = null;
+	for (const token of tokens) {
+		last = token;
+		const base = getCharacterIndex(token);
+		if (ch <= base + (token.textContent?.length ?? 0)) {
+			const anchor = textAt(token, ch < base ? 0 : ch - base);
+			if (anchor !== null) return anchor;
+		}
+	}
+	if (last !== null) {
+		const anchor = textAt(last, last.textContent?.length ?? 0);
+		if (anchor !== null) return anchor;
+		return [last, 0];
+	}
+	let textOffset = 0;
+	let lastTextNode = null;
+	for (const child of lineElement.childNodes) {
+		if (child.nodeType === 1 && child.tagName === "BR") return [child, 0];
+		if (child.nodeType !== 3) continue;
+		lastTextNode = child;
+		const len = getTextOffset(lastTextNode.textContent, lastTextNode.textContent?.length ?? 0);
+		if (ch <= textOffset + len) return [lastTextNode, getTextOffset(lastTextNode.textContent, ch - textOffset)];
+		textOffset += len;
+	}
+	if (lastTextNode !== null) return [lastTextNode, getTextOffset(lastTextNode.textContent, lastTextNode.textContent?.length ?? 0)];
+	return [lineElement, 0];
+}
+/**
+* Expands a zero-width selection to the word-like segment that contains the caret.
+*/
+function expandCollapsedSelectionToWord(textDocument, selection) {
+	const { line, character } = selection.start;
+	const lineText = textDocument.getLineText(line);
+	const span = expandCollapsedLineWord(lineText, Math.max(0, Math.min(character, lineText.length)));
+	if (span === void 0) return selection;
+	return {
+		start: {
+			line,
+			character: span.start
+		},
+		end: {
+			line,
+			character: span.end
+		},
+		direction: DirectionForward
+	};
+}
+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;
+		if (character >= lo && character <= hi) return {
+			start: lo,
+			end: hi
+		};
+	}
+}
+function getSelectionAnchorAndFocusOffsets(textDocument, selection) {
+	const isBackward = selection.direction === DirectionBackward;
+	return [textDocument.offsetAt(isBackward ? selection.end : selection.start), textDocument.offsetAt(getCaretPosition(selection))];
+}
+function resolveDeleteHardLineForwardRange(textDocument, selection) {
+	if (!isCollapsedSelection(selection)) return {
+		start: selection.start,
+		end: selection.end
+	};
+	const { line, character } = selection.start;
+	const lineLength = textDocument.getLineText(line).length;
+	if (character < lineLength) return {
+		start: {
+			line,
+			character
+		},
+		end: {
+			line,
+			character: lineLength
+		}
+	};
+	if (line < textDocument.lineCount - 1) return {
+		start: {
+			line,
+			character
+		},
+		end: {
+			line: line + 1,
+			character: 0
+		}
+	};
+	return {
+		start: {
+			line,
+			character
+		},
+		end: {
+			line,
+			character
+		}
+	};
+}
+function expandSingleNewlineInsert(textDocument, insertText, insertStartOffset) {
+	if (insertText !== "\n" && insertText !== "\r\n") return insertText;
+	const line = textDocument.positionAt(insertStartOffset).line;
+	const lineText = textDocument.getLineText(line);
+	const indentLen = getLeadingSpaces(lineText);
+	if (indentLen === 0) return insertText;
+	return insertText + lineText.slice(0, indentLen);
+}
+function getLeadingSpaces(text) {
+	let indent = 0;
+	for (; indent < text.length; indent++) {
+		const c = text.charCodeAt(indent);
+		if (c !== 32 && c !== 9) break;
+	}
+	return indent;
+}
+function createSelectionsFromOffsetPairs(textDocument, offsetPairs) {
+	const normalizedOffsets = [];
+	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;
+		return {
+			start: positions[index * 2],
+			end: positions[index * 2 + 1],
+			direction
+		};
+	});
+}
+function normalizeLeadingIndentForChange(textDocument, change, tabSize) {
+	if (change.text !== "" || change.start !== change.end - 1) return change;
+	const caretPosition = textDocument.positionAt(change.end);
+	if (caretPosition.character === 0) return change;
+	const lineText = textDocument.getLineText(caretPosition.line);
+	const leadingText = lineText.slice(0, caretPosition.character);
+	if (/[^ \t]/.test(leadingText)) return change;
+	if (lineText[caretPosition.character - 1] === "	") return change;
+	const softTabStart = Math.max(0, caretPosition.character - tabSize);
+	const softTabText = lineText.slice(softTabStart, caretPosition.character);
+	if (softTabText.length === tabSize && /^ +$/.test(softTabText)) return {
+		...change,
+		start: change.end - softTabText.length
+	};
+	return change;
+}
+function boundaryToPosition(node, offset) {
+	let lineEl = node.nodeType === 1 ? node : node.parentElement;
+	while (lineEl !== null && getLineIndex(lineEl) === void 0) lineEl = lineEl.parentElement;
+	if (lineEl === null) return null;
+	const line = getLineIndex(lineEl);
+	if (line === void 0) return null;
+	if (node.nodeType === 3) {
+		if (node.parentElement === null) return null;
+		if (findTokenSpan(node.parentElement) !== null) return {
+			line,
+			character: getLineChildEnd(node, offset)
+		};
+		return {
+			line,
+			character: offsetBefore(lineEl, node) + getTextOffset(node.textContent, offset)
+		};
+	}
+	if (node.nodeType === 1) {
+		const el = node;
+		if (el.tagName === "DIV") {
+			let character = 0;
+			for (let i = 0; i < offset; i++) character = getLineChildEnd(el.childNodes[i]);
+			return {
+				line,
+				character
+			};
+		}
+		if (el.tagName === "BR") return {
+			line,
+			character: 0
+		};
+		if (el.tagName === "SPAN") {
+			if (offset < el.childNodes.length) {
+				const next = el.childNodes[offset];
+				if (next?.nodeType === 1) {
+					const nextBase = getCharacterIndex(next);
+					if (nextBase !== void 0) return {
+						line,
+						character: nextBase
+					};
+					const token = findTokenSpan(next);
+					const tokenBase = token === null ? void 0 : getCharacterIndex(token);
+					if (tokenBase !== void 0) return {
+						line,
+						character: tokenBase
+					};
+				}
+			}
+			return {
+				line,
+				character: offset > 0 ? getLineChildEnd(el.childNodes[offset - 1]) : offsetBefore(lineEl, el)
+			};
+		}
+		return {
+			line,
+			character: offsetBefore(lineEl, el)
+		};
+	}
+	return null;
+}
+function collectTokens(line) {
+	const tokens = [];
+	for (const child of line.childNodes) {
+		if (child.nodeType !== 1) continue;
+		const el = child;
+		if (el.tagName !== "SPAN") continue;
+		if (getCharacterIndex(el) !== void 0) {
+			tokens.push(el);
+			continue;
+		}
+		for (const nested of el.childNodes) if (nested.nodeType === 1 && getCharacterIndex(nested) !== void 0) tokens.push(nested);
+	}
+	return tokens;
+}
+function textAt(token, offset) {
+	let remaining = Math.max(0, offset);
+	const stack = [{
+		container: token,
+		index: 0
+	}];
+	while (stack.length > 0) {
+		const frame = stack[stack.length - 1];
+		if (frame.index >= frame.container.childNodes.length) {
+			stack.pop();
+			continue;
+		}
+		const walkNode = frame.container.childNodes[frame.index];
+		frame.index++;
+		if (walkNode.nodeType === 3) {
+			const len = getTextOffset(walkNode.textContent, walkNode.textContent?.length ?? 0);
+			if (remaining <= len) return [walkNode, remaining];
+			remaining -= len;
+		} else if (walkNode.nodeType === 1) stack.push({
+			container: walkNode,
+			index: 0
+		});
+	}
+	return null;
+}
+function textLengthBefore(root, target) {
+	let before = 0;
+	const stack = [{
+		container: root,
+		index: 0
+	}];
+	while (stack.length > 0) {
+		const frame = stack[stack.length - 1];
+		if (frame.index >= frame.container.childNodes.length) {
+			stack.pop();
+			continue;
+		}
+		const walkNode = frame.container.childNodes[frame.index];
+		if (walkNode === target) return before;
+		frame.index++;
+		if (walkNode.nodeType === 3) before += getTextOffset(walkNode.textContent, walkNode.textContent?.length ?? 0);
+		else if (walkNode.nodeType === 1) stack.push({
+			container: walkNode,
+			index: 0
+		});
+	}
+	return before;
+}
+function isInside(token, node) {
+	let current = node;
+	while (current !== null) {
+		if (current === token) return true;
+		current = current.parentElement;
+	}
+	return false;
+}
+function offsetBefore(line, node) {
+	if (node.parentElement === line) {
+		let offset$1 = 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 (const token of collectTokens(line)) if (isInside(token, node)) return getCharacterIndex(token) + (node.nodeType === 3 ? textLengthBefore(token, node) : 0);
+	let offset = 0;
+	let target = node.nodeType === 1 ? node : node.parentElement;
+	while (target !== null && target.parentElement !== null) {
+		if (getLineIndex(target.parentElement) !== void 0) break;
+		const parent = target.parentElement;
+		const index = Array.prototype.indexOf.call(parent.childNodes, target);
+		for (let i = 0; i < index; i++) offset = getLineChildEnd(parent.childNodes[i]);
+		target = parent;
+	}
+	return offset;
+}
+function findTokenSpan(el) {
+	let current = el;
+	while (current !== null) {
+		if (getLineIndex(current) !== void 0) return null;
+		if (getCharacterIndex(current) !== void 0) return current;
+		current = current.parentElement;
+	}
+	return null;
+}
+function getLineChildEnd(child, textOffsetInChild) {
+	if (child === void 0) return 0;
+	if (child.nodeType === 3) {
+		const parent = child.parentElement;
+		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 length = textOffsetInChild === void 0 ? getTextOffset(child.textContent, child.textContent?.length ?? 0) : getTextOffset(child.textContent, textOffsetInChild);
+		return base$1 + textLengthBefore(token, child) + length;
+	}
+	if (child.nodeType !== 1) return 0;
+	const el = child;
+	if (el.tagName !== "SPAN" && el.tagName !== "BR") return 0;
+	const base = getCharacterIndex(el);
+	if (base !== void 0) return base + (el.textContent?.length ?? 0);
+	let end = 0;
+	for (const token of el.childNodes) end = Math.max(end, getLineChildEnd(token));
+	return end;
+}
+function getLineIndex(el) {
+	const { line } = el.dataset;
+	if (line !== void 0) return parseInt(line) - 1;
+}
+function getCharacterIndex(el) {
+	const { char } = el.dataset;
+	return char !== void 0 ? parseInt(char) : void 0;
+}
+function getTextOffset(text, offset) {
+	const value = text ?? "";
+	const lineBreakIndex = value.search(/[\r\n]/);
+	return Math.min(offset, lineBreakIndex === -1 ? value.length : lineBreakIndex);
+}
+
+//#endregion
+export { DirectionBackward, DirectionForward, DirectionNone, applyDeleteHardLineForwardToSelections, applyTextChangeToSelections, applyTextReplaceToSelections, applyTransposeToSelections, comparePosition, convertSelection, createSelectionFrom, createSelectionFromAnchorAndFocusOffsets, expandCollapsedSelectionToWord, extendSelection, extendSelections, findNexMatch, getCaretPosition, getDocumentBoundarySelection, getDocumentFullSelection, getSelectionAnchor, getSelectionText, isCollapsedSelection, isLineEditable, mapCursorMove, mapSelectionShift, mergeOverlappingSelections, resolveIndentEdits, selectionIntersects };
+//# sourceMappingURL=selection.js.map