@timurproko/a1 0.1.8-dev.139 → 0.1.8-dev.157

package/dist/integrations/pi/components/owned-editor-ux.js

@@ -0,0 +1,778 @@
+import { CURSOR_MARKER, decodeKittyPrintable, visibleWidth, } from "#pi-tui";
+export class OwnedEditorUxInterception {
+    interceptors;
+    fallback;
+    constructor(interceptors, fallback) {
+        this.interceptors = interceptors;
+        this.fallback = fallback;
+    }
+    handleInput(data) {
+        const invoke = (index) => {
+            const interceptor = this.interceptors[index];
+            if (interceptor === undefined) {
+                this.fallback.handleInput(data);
+                return;
+            }
+            interceptor.handleInput(data, () => invoke(index + 1));
+        };
+        invoke(0);
+    }
+    render(width) {
+        const invoke = (index) => {
+            const interceptor = this.interceptors[index];
+            return interceptor === undefined
+                ? this.fallback.render(width)
+                : interceptor.render(width, () => invoke(index + 1));
+        };
+        return invoke(0);
+    }
+    reset() {
+        for (const interceptor of this.interceptors)
+            interceptor.reset();
+    }
+    handlePointer(event) {
+        return this.interceptors.some(interceptor => interceptor.handlePointer?.(event) === true);
+    }
+    hasSelection() {
+        return this.interceptors.some(interceptor => interceptor.hasSelection?.() === true);
+    }
+    ownsPointer() {
+        return this.interceptors.some(interceptor => interceptor.ownsPointer?.() === true);
+    }
+    pasteClipboard() {
+        return this.interceptors.some(interceptor => interceptor.pasteClipboard?.() === true);
+    }
+}
+const ATOMIC_SEGMENTATION = Symbol("a1.editor.atomicSegmentation");
+const ATOMIC_SPACE_SENTINEL = "\uE000";
+const GRAPHEMES = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+const MULTI_CLICK_MS = 500;
+export function createPromptSelectionInterceptor(editor, keybindings, options) {
+    return new PromptSelectionInterceptor(editor, keybindings, options);
+}
+class PromptSelectionInterceptor {
+    editor;
+    keybindings;
+    options;
+    #selection;
+    #pointerSelecting = false;
+    #lastClick;
+    #redoStack = [];
+    #selectionRevision = 0;
+    #geometry;
+    constructor(editor, keybindings, options) {
+        this.editor = editor;
+        this.keybindings = keybindings;
+        this.options = options;
+        installAtomicSegmentation(editor, options.atomicRanges);
+    }
+    handleInput(data, next) {
+        if (this.keybindings.matches(data, "owned.editor.selectAll")) {
+            this.#selectAll();
+            return;
+        }
+        if (this.keybindings.matches(data, "owned.editor.extendLeft")) {
+            this.#extend(-1);
+            return;
+        }
+        if (this.keybindings.matches(data, "owned.editor.extendRight")) {
+            this.#extend(1);
+            return;
+        }
+        if (this.keybindings.matches(data, "tui.input.copy") && this.hasSelection()) {
+            this.options.copyText(this.options.expandCopiedText(this.#selectedText()));
+            this.#collapseCopiedSelection();
+            return;
+        }
+        if (this.keybindings.matches(data, "owned.editor.cut") && this.hasSelection()) {
+            this.options.copyText(this.options.expandCopiedText(this.#selectedText()));
+            if (!this.#deleteSelection())
+                this.#deleteAtomicFocus();
+            return;
+        }
+        if (this.keybindings.matches(data, "owned.editor.paste")) {
+            this.pasteClipboard();
+            return;
+        }
+        if (this.keybindings.matches(data, "owned.editor.redo")) {
+            this.#redo();
+            return;
+        }
+        const terminalPaste = bracketedPasteContent(data);
+        if (terminalPaste !== undefined) {
+            if (terminalPaste.length === 0) {
+                this.pasteClipboard();
+                return;
+            }
+            const transformed = this.options.transformPastedContent({ kind: "text", text: terminalPaste });
+            if (transformed !== terminalPaste) {
+                if (this.#orderedSelection() !== undefined)
+                    this.#replaceSelection(transformed);
+                else
+                    this.editor.insertTextAtCursor(transformed);
+                this.#redoStack = [];
+                this.#requestRender();
+                return;
+            }
+        }
+        if (this.keybindings.matches(data, "tui.editor.undo")) {
+            const before = this.#snapshot();
+            this.#clearSelection(false);
+            next();
+            if (!sameSnapshot(before, this.#snapshot()))
+                this.#redoStack.push(before);
+            this.#requestRender();
+            return;
+        }
+        const selection = this.#orderedSelection();
+        if (selection !== undefined) {
+            if (this.keybindings.matches(data, "tui.editor.deleteCharBackward")
+                || this.keybindings.matches(data, "tui.editor.deleteCharForward")
+                || this.keybindings.matches(data, "tui.editor.deleteWordBackward")
+                || this.keybindings.matches(data, "tui.editor.deleteWordForward")) {
+                this.#deleteSelection();
+                return;
+            }
+            const inserted = insertedText(data);
+            if (inserted !== undefined) {
+                this.#replaceSelection(inserted);
+                return;
+            }
+            if (data.includes("\u001b[200~")) {
+                this.#deleteSelection();
+                next();
+                return;
+            }
+            if (this.keybindings.matches(data, "tui.editor.cursorLeft")
+                || this.keybindings.matches(data, "tui.editor.cursorWordLeft")) {
+                this.#setCursor(selection.start);
+                this.#clearSelection();
+                return;
+            }
+            if (this.keybindings.matches(data, "tui.editor.cursorRight")
+                || this.keybindings.matches(data, "tui.editor.cursorWordRight")) {
+                this.#setCursor(selection.end);
+                this.#clearSelection();
+                return;
+            }
+            this.#clearSelection(false);
+        }
+        else if ((this.keybindings.matches(data, "tui.editor.deleteCharBackward")
+            || this.keybindings.matches(data, "tui.editor.deleteCharForward")
+            || this.keybindings.matches(data, "tui.editor.deleteWordBackward")
+            || this.keybindings.matches(data, "tui.editor.deleteWordForward"))
+            && this.#deleteAtomicFocus()) {
+            return;
+        }
+        if (this.keybindings.matches(data, "tui.editor.cursorWordLeft")) {
+            const before = this.#cursor();
+            const startedWithAtomicFocus = this.#atomicFocus() !== undefined;
+            next();
+            let after = this.#cursor();
+            const landedAtomic = this.#atomicRangeAt(after);
+            if (!startedWithAtomicFocus && landedAtomic?.start === after.col && after.col > 0) {
+                const line = editorState(this.editor).lines[after.line] ?? "";
+                const previous = [...GRAPHEMES.segment(line.slice(0, after.col))].at(-1);
+                if (previous !== undefined && !/^\s+$/u.test(previous.segment)) {
+                    next();
+                    after = this.#cursor();
+                }
+            }
+            if (!samePosition(before, after))
+                this.#moveOntoPreviousSeparator();
+            this.#requestRender();
+            return;
+        }
+        const beforeText = this.editor.getText();
+        next();
+        if (this.editor.getText() !== beforeText)
+            this.#redoStack = [];
+    }
+    render(width, next) {
+        const rows = next().map(row => row.replaceAll(ATOMIC_SPACE_SENTINEL, " "));
+        const maxPadding = Math.max(0, Math.floor((width - 1) / 2));
+        const padding = Math.min(this.editor.getPaddingX(), maxPadding);
+        const contentWidth = Math.max(1, width - padding * 2);
+        const layoutWidth = Math.max(1, contentWidth - (padding ? 0 : 1));
+        const visualLines = editorVisualLineMap(this.editor, layoutWidth)
+            ?? buildVisualLineMap(editorState(this.editor).lines, layoutWidth);
+        const scrollOffset = numericProperty(this.editor, "scrollOffset");
+        const maxVisibleLines = Math.max(5, Math.floor(this.options.getRows() * 0.3));
+        const textRows = Math.max(0, Math.min(visualLines.length - scrollOffset, maxVisibleLines, rows.length - 2));
+        this.#geometry = { width, padding, layoutWidth, visualLines, scrollOffset, textRows };
+        if (this.#atomicFocus() !== undefined) {
+            for (let row = 0; row < rows.length; row += 1) {
+                rows[row] = (rows[row] ?? "").replaceAll(CURSOR_MARKER, "");
+            }
+        }
+        const selection = this.#orderedSelection();
+        if (selection !== undefined) {
+            for (let row = 0; row < textRows; row += 1) {
+                const visual = visualLines[scrollOffset + row];
+                if (visual === undefined || visual.logicalLine < selection.start.line || visual.logicalLine > selection.end.line)
+                    continue;
+                const segmentStart = visual.startCol;
+                const segmentEnd = visual.startCol + visual.length;
+                const from = visual.logicalLine === selection.start.line ? Math.max(selection.start.col, segmentStart) : segmentStart;
+                const to = visual.logicalLine === selection.end.line ? Math.min(selection.end.col, segmentEnd) : segmentEnd;
+                if (to <= from)
+                    continue;
+                const line = editorState(this.editor).lines[visual.logicalLine] ?? "";
+                const fromColumn = padding + visibleWidth(line.slice(segmentStart, from));
+                const toColumn = fromColumn + visibleWidth(line.slice(from, to));
+                const rendered = rows[row + 1];
+                if (rendered !== undefined && toColumn > fromColumn) {
+                    rows[row + 1] = this.options.paintSelection(rendered, fromColumn, toColumn, false);
+                }
+            }
+        }
+        return rows.map(row => this.options.decorateRow(row, width));
+    }
+    reset() {
+        this.#selection = undefined;
+        this.#pointerSelecting = false;
+        this.#lastClick = undefined;
+        this.#redoStack = [];
+        this.#selectionRevision += 1;
+    }
+    hasSelection() {
+        return this.#activeRange() !== undefined;
+    }
+    pasteClipboard() {
+        this.#pasteFromClipboard();
+        return true;
+    }
+    ownsPointer() {
+        return this.#pointerSelecting;
+    }
+    handlePointer(event) {
+        if (event.button !== 0)
+            return false;
+        if (event.kind === "press")
+            return this.#pointerPress(event.column, event.row);
+        if (event.kind === "motion") {
+            if (!this.#pointerSelecting)
+                return false;
+            let position = this.#positionAt(event.column, event.row, true);
+            if (position !== undefined && this.#selection !== undefined) {
+                const atomic = this.#atomicRangeAt(position);
+                if (atomic !== undefined) {
+                    const beforeAnchor = position.line < this.#selection.anchor.line
+                        || (position.line === this.#selection.anchor.line && atomic.start < this.#selection.anchor.col);
+                    position = { line: position.line, col: beforeAnchor ? atomic.start : atomic.end };
+                }
+                this.#selection = { ...this.#selection, head: position };
+                this.#selectionRevision += 1;
+                this.#requestRender();
+            }
+            return true;
+        }
+        if (!this.#pointerSelecting)
+            return false;
+        this.#pointerSelecting = false;
+        const ordered = this.#orderedSelection();
+        if (ordered === undefined && this.#selection !== undefined)
+            this.#setCursor(this.#selection.head);
+        if (ordered === undefined)
+            this.#clearSelection(false);
+        this.#requestRender();
+        return true;
+    }
+    #pointerPress(column, row) {
+        const position = this.#positionAt(column, row, false);
+        if (position === undefined)
+            return false;
+        const atomic = this.#atomicRangeAt(position);
+        if (atomic !== undefined) {
+            this.#selection = {
+                anchor: { line: position.line, col: atomic.start },
+                head: { line: position.line, col: atomic.start },
+            };
+            this.#setCursor({ line: position.line, col: atomic.start });
+            this.#pointerSelecting = true;
+            this.#lastClick = undefined;
+            this.#selectionRevision += 1;
+            this.#requestRender();
+            return true;
+        }
+        const now = Date.now();
+        const previous = this.#lastClick;
+        const count = previous !== undefined
+            && now - previous.time <= MULTI_CLICK_MS
+            && previous.line === position.line
+            && Math.abs(previous.col - position.col) <= 1
+            ? previous.count + 1
+            : 1;
+        this.#lastClick = { time: now, ...position, count };
+        const kind = ((count - 1) % 3) + 1;
+        if (kind === 2)
+            this.#selectWord(position);
+        else if (kind === 3)
+            this.#selectLine(position.line);
+        else
+            this.#selection = { anchor: position, head: position };
+        this.#pointerSelecting = true;
+        this.#selectionRevision += 1;
+        this.#requestRender();
+        return true;
+    }
+    #positionAt(column, row, clampRow) {
+        const geometry = this.#geometry;
+        if (geometry === undefined || geometry.textRows === 0)
+            return undefined;
+        let textRow = row - 2;
+        if (clampRow)
+            textRow = clamp(textRow, 0, geometry.textRows - 1);
+        if (textRow < 0 || textRow >= geometry.textRows)
+            return undefined;
+        const visual = geometry.visualLines[geometry.scrollOffset + textRow];
+        if (visual === undefined)
+            return undefined;
+        const line = editorState(this.editor).lines[visual.logicalLine] ?? "";
+        const segment = line.slice(visual.startCol, visual.startCol + visual.length);
+        const displayColumn = Math.max(0, column - 1 - geometry.padding);
+        return {
+            line: visual.logicalLine,
+            col: visual.startCol + indexAtDisplayWidth(segment, displayColumn),
+        };
+    }
+    #selectWord(position) {
+        const atomic = this.#atomicRangeAt(position);
+        if (atomic !== undefined) {
+            this.#selection = {
+                anchor: { line: position.line, col: atomic.start },
+                head: { line: position.line, col: atomic.end },
+            };
+            return;
+        }
+        const line = editorState(this.editor).lines[position.line] ?? "";
+        const segments = [...GRAPHEMES.segment(line)].map(({ segment, index }) => ({
+            class: charClass(segment), start: index, end: index + segment.length,
+        }));
+        let selected = segments.findIndex(segment => position.col >= segment.start && position.col < segment.end);
+        if (selected < 0 && segments.length > 0 && position.col === line.length)
+            selected = segments.length - 1;
+        if (selected < 0)
+            return;
+        let start = selected;
+        let end = selected;
+        while (start > 0 && segments[start - 1]?.class === segments[selected]?.class)
+            start -= 1;
+        while (end + 1 < segments.length && segments[end + 1]?.class === segments[selected]?.class)
+            end += 1;
+        this.#selection = {
+            anchor: { line: position.line, col: segments[start]?.start ?? position.col },
+            head: { line: position.line, col: segments[end]?.end ?? position.col },
+        };
+    }
+    #selectLine(line) {
+        const text = editorState(this.editor).lines[line] ?? "";
+        this.#selection = { anchor: { line, col: 0 }, head: { line, col: text.length } };
+    }
+    #selectAll() {
+        const lines = editorState(this.editor).lines;
+        const finalLine = Math.max(0, lines.length - 1);
+        this.#selection = {
+            anchor: { line: 0, col: 0 },
+            head: { line: finalLine, col: (lines[finalLine] ?? "").length },
+        };
+        this.#pointerSelecting = false;
+        this.#selectionRevision += 1;
+        this.#requestRender();
+    }
+    #extend(delta) {
+        const cursor = this.#cursor();
+        if (this.#selection === undefined)
+            this.#selection = { anchor: cursor, head: cursor };
+        else if (!samePosition(cursor, this.#selection.head))
+            this.#setCursor(this.#selection.head);
+        this.#moveCursor(delta);
+        this.#selection = { anchor: this.#selection.anchor, head: this.#cursor() };
+        this.#pointerSelecting = false;
+        this.#lastClick = undefined;
+        this.#selectionRevision += 1;
+        this.#requestRender();
+    }
+    #pasteFromClipboard() {
+        const revision = this.#selectionRevision;
+        const selection = this.#orderedSelection();
+        const atomicFocus = this.#atomicFocus();
+        void this.options.readClipboardContent().then(content => {
+            if (content === null)
+                return;
+            const text = this.options.transformPastedContent(content);
+            if (text.length === 0)
+                return;
+            if (selection !== undefined && revision === this.#selectionRevision && this.#orderedSelection() !== undefined) {
+                this.#replaceSelection(text);
+                return;
+            }
+            if (atomicFocus !== undefined && samePosition(this.#cursor(), atomicFocus.start)) {
+                this.editor.insertTextAtCursor(text);
+            }
+            else {
+                this.#clearSelection(false);
+                this.editor.insertTextAtCursor(text);
+            }
+            this.#redoStack = [];
+            this.#requestRender();
+        }).catch(() => { });
+    }
+    #replaceSelection(text) {
+        const selection = this.#orderedSelection();
+        if (selection === undefined) {
+            this.editor.insertTextAtCursor(text);
+            return;
+        }
+        const normalized = normalizeInsertedText(text);
+        const current = this.editor.getText();
+        const lines = editorState(this.editor).lines;
+        const from = positionOffset(lines, selection.start);
+        const to = positionOffset(lines, selection.end);
+        const next = current.slice(0, from) + normalized + current.slice(to);
+        this.editor.setText(next);
+        this.#setCursor(positionAtOffset(next, from + normalized.length));
+        this.#redoStack = [];
+        this.#clearSelection(false);
+        this.#requestRender();
+    }
+    #deleteSelection() {
+        const selection = this.#orderedSelection();
+        if (selection === undefined)
+            return false;
+        const current = this.editor.getText();
+        const lines = editorState(this.editor).lines;
+        const from = positionOffset(lines, selection.start);
+        const to = positionOffset(lines, selection.end);
+        this.editor.setText(current.slice(0, from) + current.slice(to));
+        this.#setCursor(positionAtOffset(this.editor.getText(), from));
+        this.#redoStack = [];
+        this.#clearSelection(false);
+        this.#requestRender();
+        return true;
+    }
+    #deleteAtomicFocus() {
+        const focus = this.#atomicFocus();
+        if (focus === undefined)
+            return false;
+        const current = this.editor.getText();
+        const lines = editorState(this.editor).lines;
+        const from = positionOffset(lines, focus.start);
+        const to = positionOffset(lines, focus.end);
+        this.editor.setText(current.slice(0, from) + current.slice(to));
+        this.#setCursor(positionAtOffset(this.editor.getText(), from));
+        this.#redoStack = [];
+        this.#clearSelection(false);
+        this.#requestRender();
+        return true;
+    }
+    #redo() {
+        const snapshot = this.#redoStack.pop();
+        if (snapshot === undefined)
+            return;
+        this.editor.setText(snapshot.text);
+        this.#setCursor(snapshot.cursor);
+        this.#clearSelection(false);
+        this.#requestRender();
+    }
+    #collapseCopiedSelection() {
+        const selection = this.#activeRange();
+        if (selection === undefined)
+            return;
+        const line = editorState(this.editor).lines[selection.end.line] ?? "";
+        let column = selection.end.col;
+        while (true) {
+            const adjacent = this.options.atomicRanges(line).find(range => range.start === column);
+            if (adjacent === undefined)
+                break;
+            column = adjacent.end;
+        }
+        this.#setCursor({ line: selection.end.line, col: column });
+        this.#clearSelection(false);
+        this.#requestRender();
+    }
+    #selectedText() {
+        const selection = this.#activeRange();
+        if (selection === undefined)
+            return "";
+        const current = this.editor.getText();
+        const lines = editorState(this.editor).lines;
+        return current.slice(positionOffset(lines, selection.start), positionOffset(lines, selection.end));
+    }
+    #activeRange() {
+        return this.#orderedSelection() ?? this.#atomicFocus();
+    }
+    #atomicFocus() {
+        if (this.#orderedSelection() !== undefined)
+            return undefined;
+        const state = editorState(this.editor);
+        const line = state.lines[state.cursorLine] ?? "";
+        const range = this.options.atomicRanges(line).find(candidate => candidate.start === state.cursorCol);
+        return range === undefined ? undefined : {
+            start: { line: state.cursorLine, col: range.start },
+            end: { line: state.cursorLine, col: range.end },
+        };
+    }
+    #orderedSelection() {
+        const selection = this.#selection;
+        if (selection === undefined || samePosition(selection.anchor, selection.head))
+            return undefined;
+        return positionBefore(selection.anchor, selection.head)
+            ? { start: selection.anchor, end: selection.head }
+            : { start: selection.head, end: selection.anchor };
+    }
+    #clearSelection(render = true) {
+        if (this.#selection === undefined && !this.#pointerSelecting)
+            return;
+        this.#selection = undefined;
+        this.#pointerSelecting = false;
+        this.#selectionRevision += 1;
+        if (render)
+            this.#requestRender();
+    }
+    #cursor() {
+        return this.editor.getCursor();
+    }
+    #setCursor(position) {
+        const state = editorState(this.editor);
+        const line = clamp(position.line, 0, Math.max(0, state.lines.length - 1));
+        state.cursorLine = line;
+        state.cursorCol = clamp(position.col, 0, (state.lines[line] ?? "").length);
+    }
+    #moveCursor(delta) {
+        const state = editorState(this.editor);
+        const line = state.lines[state.cursorLine] ?? "";
+        const atomic = this.options.atomicRanges(line).find(range => delta < 0
+            ? state.cursorCol > range.start && state.cursorCol <= range.end
+            : state.cursorCol >= range.start && state.cursorCol < range.end);
+        if (atomic !== undefined) {
+            state.cursorCol = delta < 0 ? atomic.start : atomic.end;
+            return;
+        }
+        if (delta < 0) {
+            if (state.cursorCol > 0) {
+                const segments = [...GRAPHEMES.segment(line.slice(0, state.cursorCol))];
+                state.cursorCol -= segments.at(-1)?.segment.length ?? 1;
+            }
+            else if (state.cursorLine > 0) {
+                state.cursorLine -= 1;
+                state.cursorCol = (state.lines[state.cursorLine] ?? "").length;
+            }
+            return;
+        }
+        if (state.cursorCol < line.length) {
+            state.cursorCol += [...GRAPHEMES.segment(line.slice(state.cursorCol))][0]?.segment.length ?? 1;
+        }
+        else if (state.cursorLine < state.lines.length - 1) {
+            state.cursorLine += 1;
+            state.cursorCol = 0;
+        }
+    }
+    #atomicRangeAt(position) {
+        const line = editorState(this.editor).lines[position.line] ?? "";
+        return this.options.atomicRanges(line).find(range => position.col >= range.start && position.col < range.end);
+    }
+    #moveOntoPreviousSeparator() {
+        const cursor = this.#cursor();
+        if (cursor.col === 0)
+            return;
+        const line = editorState(this.editor).lines[cursor.line] ?? "";
+        const previous = [...GRAPHEMES.segment(line.slice(0, cursor.col))].at(-1);
+        if (previous !== undefined && /^\s+$/u.test(previous.segment))
+            this.#moveCursor(-1);
+    }
+    #snapshot() {
+        return { text: this.editor.getText(), cursor: this.#cursor() };
+    }
+    #requestRender() {
+        this.options.requestRender();
+    }
+}
+function installAtomicSegmentation(editor, rangesForText) {
+    if (Reflect.get(editor, ATOMIC_SEGMENTATION) === true)
+        return;
+    const originalValue = Reflect.get(editor, "segment");
+    if (typeof originalValue !== "function")
+        return;
+    const original = originalValue.bind(editor);
+    Reflect.set(editor, "segment", (text, mode) => {
+        const segments = [...original(text, mode)].filter(isEditorSegment);
+        const ranges = rangesForText(text);
+        if (ranges.length === 0)
+            return segments;
+        const merged = [];
+        let rangeIndex = 0;
+        for (const segment of segments) {
+            while ((ranges[rangeIndex]?.end ?? Number.POSITIVE_INFINITY) <= segment.index)
+                rangeIndex += 1;
+            const range = ranges[rangeIndex];
+            if (range !== undefined && segment.index >= range.start && segment.index < range.end) {
+                if (segment.index === range.start) {
+                    merged.push({
+                        segment: text.slice(range.start, range.end).replaceAll(" ", ATOMIC_SPACE_SENTINEL),
+                        index: range.start,
+                        input: text,
+                    });
+                }
+                continue;
+            }
+            merged.push(segment);
+        }
+        return merged;
+    });
+    Reflect.set(editor, ATOMIC_SEGMENTATION, true);
+}
+function isEditorSegment(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const segment = Reflect.get(value, "segment");
+    const index = Reflect.get(value, "index");
+    const input = Reflect.get(value, "input");
+    return typeof segment === "string" && typeof index === "number" && typeof input === "string";
+}
+function bracketedPasteContent(data) {
+    const start = data.indexOf("\u001b[200~");
+    const end = data.indexOf("\u001b[201~", start + 6);
+    return start < 0 || end < 0 ? undefined : data.slice(start + 6, end);
+}
+function insertedText(data) {
+    if (!data || data.includes("\u001b[200~"))
+        return undefined;
+    const kitty = decodeKittyPrintable(data);
+    if (kitty !== undefined)
+        return kitty;
+    return data.charCodeAt(0) >= 32 ? data : undefined;
+}
+function indexAtDisplayWidth(text, target) {
+    if (target <= 0)
+        return 0;
+    let width = 0;
+    let index = 0;
+    for (const { segment } of GRAPHEMES.segment(text)) {
+        const next = width + visibleWidth(segment);
+        if (next > target)
+            break;
+        width = next;
+        index += segment.length;
+    }
+    return index;
+}
+function charClass(value) {
+    if (/\s/u.test(value))
+        return 0;
+    if (/[\p{L}\p{N}_]/u.test(value))
+        return 1;
+    return 2;
+}
+function positionBefore(left, right) {
+    return left.line < right.line || (left.line === right.line && left.col <= right.col);
+}
+function samePosition(left, right) {
+    return left.line === right.line && left.col === right.col;
+}
+function sameSnapshot(left, right) {
+    return left.text === right.text && samePosition(left.cursor, right.cursor);
+}
+function editorState(editor) {
+    const value = Object.getOwnPropertyDescriptor(editor, "state")?.value;
+    if (!isEditorState(value))
+        throw new Error("Pi editor state is unavailable");
+    return value;
+}
+function isEditorState(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const lines = Object.getOwnPropertyDescriptor(value, "lines")?.value;
+    const cursorLine = Object.getOwnPropertyDescriptor(value, "cursorLine")?.value;
+    const cursorCol = Object.getOwnPropertyDescriptor(value, "cursorCol")?.value;
+    return Array.isArray(lines) && lines.every(line => typeof line === "string")
+        && typeof cursorLine === "number" && typeof cursorCol === "number";
+}
+function numericProperty(target, key) {
+    const value = Object.getOwnPropertyDescriptor(target, key)?.value;
+    return typeof value === "number" ? value : 0;
+}
+function editorVisualLineMap(editor, width) {
+    const builder = Reflect.get(editor, "buildVisualLineMap");
+    if (typeof builder !== "function")
+        return undefined;
+    const value = builder.call(editor, width);
+    if (!Array.isArray(value) || !value.every(isVisualLine))
+        return undefined;
+    return value;
+}
+function isVisualLine(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    return typeof Reflect.get(value, "logicalLine") === "number"
+        && typeof Reflect.get(value, "startCol") === "number"
+        && typeof Reflect.get(value, "length") === "number";
+}
+function buildVisualLineMap(lines, width) {
+    const visualLines = [];
+    for (let logicalLine = 0; logicalLine < lines.length; logicalLine += 1) {
+        const line = lines[logicalLine] ?? "";
+        if (line.length === 0) {
+            visualLines.push({ logicalLine, startCol: 0, length: 0 });
+            continue;
+        }
+        for (const chunk of wrapLine(line, width)) {
+            visualLines.push({ logicalLine, startCol: chunk.start, length: chunk.end - chunk.start });
+        }
+    }
+    return visualLines;
+}
+function wrapLine(line, width) {
+    if (visibleWidth(line) <= width)
+        return [{ start: 0, end: line.length }];
+    const segments = [...GRAPHEMES.segment(line)];
+    const chunks = [];
+    let start = 0;
+    let currentWidth = 0;
+    let wrapAt = -1;
+    let widthAtWrap = 0;
+    for (let index = 0; index < segments.length; index += 1) {
+        const segment = segments[index];
+        if (segment === undefined)
+            continue;
+        const segmentWidth = visibleWidth(segment.segment);
+        if (currentWidth + segmentWidth > width) {
+            if (wrapAt > start && currentWidth - widthAtWrap + segmentWidth <= width) {
+                chunks.push({ start, end: wrapAt });
+                start = wrapAt;
+                currentWidth -= widthAtWrap;
+            }
+            else if (start < segment.index) {
+                chunks.push({ start, end: segment.index });
+                start = segment.index;
+                currentWidth = 0;
+            }
+            wrapAt = -1;
+        }
+        currentWidth += segmentWidth;
+        const next = segments[index + 1];
+        if (/\s/u.test(segment.segment) && next !== undefined && !/\s/u.test(next.segment)) {
+            wrapAt = next.index;
+            widthAtWrap = currentWidth;
+        }
+    }
+    chunks.push({ start, end: line.length });
+    return chunks;
+}
+function positionOffset(lines, position) {
+    let offset = 0;
+    for (let line = 0; line < position.line; line += 1)
+        offset += (lines[line] ?? "").length + 1;
+    return offset + position.col;
+}
+function positionAtOffset(text, requestedOffset) {
+    const offset = clamp(requestedOffset, 0, text.length);
+    const before = text.slice(0, offset).split("\n");
+    return { line: before.length - 1, col: (before.at(-1) ?? "").length };
+}
+function normalizeInsertedText(text) {
+    return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\t/g, "    ");
+}
+function clamp(value, minimum, maximum) {
+    return Math.max(minimum, Math.min(maximum, value));
+}