@rtif-sdk/web 1.0.0

package/dist/input-bridge.js

@@ -0,0 +1,884 @@
+/**
+ * InputBridge — translates DOM `beforeinput` events into RTIF engine operations.
+ *
+ * This module is the core of the "controlled contenteditable" approach.
+ * It intercepts `beforeinput` events, prevents default browser behavior for
+ * most input types, and dispatches the corresponding RTIF operations through
+ * the injected dependencies.
+ *
+ * During IME composition, composition-related input types are passed through
+ * to the browser so that native composition rendering works correctly.
+ * The composition handler (separate module) emits RTIF operations on commit.
+ *
+ * @module
+ */
+import { resolve, blockTextLength } from '@rtif-sdk/core';
+// ---------------------------------------------------------------------------
+// Word boundary helpers
+// ---------------------------------------------------------------------------
+/**
+ * Find the offset of the word boundary before the given local offset in block text.
+ *
+ * A "word character" is any character matching `\w` (alphanumeric + underscore).
+ * The algorithm: first skip any non-word characters (punctuation, whitespace),
+ * then skip word characters. The result is the start of the word.
+ *
+ * @param blockText - The full text of the block
+ * @param localOffset - The current cursor position within the block (0-indexed)
+ * @returns The local offset of the word boundary (always <= localOffset)
+ *
+ * @example
+ * ```ts
+ * findWordBoundaryBackward('hello world', 11); // => 6 (start of "world")
+ * findWordBoundaryBackward('hello world', 5);  // => 0 (start of "hello")
+ * ```
+ */
+export function findWordBoundaryBackward(blockText, localOffset) {
+    let pos = localOffset;
+    // Phase 1: Skip non-word characters (whitespace, punctuation)
+    while (pos > 0 && !/\w/.test(blockText[pos - 1])) {
+        pos--;
+    }
+    // Phase 2: Skip word characters
+    while (pos > 0 && /\w/.test(blockText[pos - 1])) {
+        pos--;
+    }
+    return pos;
+}
+/**
+ * Find the offset of the word boundary after the given local offset in block text.
+ *
+ * The algorithm: first skip word characters, then skip non-word characters
+ * (whitespace, punctuation). The result is the position after the word
+ * and its trailing whitespace.
+ *
+ * @param blockText - The full text of the block
+ * @param localOffset - The current cursor position within the block (0-indexed)
+ * @returns The local offset of the word boundary (always >= localOffset)
+ *
+ * @example
+ * ```ts
+ * findWordBoundaryForward('hello world', 0); // => 6 (after "hello ")
+ * findWordBoundaryForward('hello world', 6); // => 11 (after "world")
+ * ```
+ */
+export function findWordBoundaryForward(blockText, localOffset) {
+    const len = blockText.length;
+    let pos = localOffset;
+    // Phase 1: Skip word characters
+    while (pos < len && /\w/.test(blockText[pos])) {
+        pos++;
+    }
+    // Phase 2: Skip non-word characters (whitespace, punctuation)
+    while (pos < len && !/\w/.test(blockText[pos])) {
+        pos++;
+    }
+    return pos;
+}
+// ---------------------------------------------------------------------------
+// Selection deletion helpers
+// ---------------------------------------------------------------------------
+/**
+ * Compute the absolute offset where a block's text begins in the document.
+ *
+ * @param doc - The document
+ * @param blockIndex - Index of the target block
+ * @returns The absolute offset of the first character in the block
+ */
+function blockStartOffset(doc, blockIndex) {
+    let offset = 0;
+    for (let i = 0; i < blockIndex; i++) {
+        const block = doc.blocks[i];
+        if (!block)
+            break;
+        offset += blockTextLength(block);
+        offset += 1; // virtual \n separator
+    }
+    return offset;
+}
+/**
+ * Compute the operations needed to delete a selection range.
+ *
+ * For single-block selections, returns a single `delete_text`. For cross-block
+ * selections, composes `delete_text` and `merge_block` operations that the
+ * engine can apply sequentially.
+ *
+ * The algorithm works forward through the blocks:
+ * 1. Delete the tail of the start block (from startLocalOffset to end).
+ * 2. For each subsequent block up to and including the end block:
+ *    a. Merge it into the previous block.
+ *    b. Delete the appropriate text (all text for intermediate blocks,
+ *       or endLocalOffset characters for the end block).
+ *
+ * After each merge, the text from the merged block appears at the position
+ * where the start block's tail was deleted, so all delete offsets are the
+ * same absolute offset (the start of the selection).
+ *
+ * @param doc - The current document
+ * @param selection - The selection to delete (may be forward or backward)
+ * @returns Array of operations to dispatch. Empty if selection is collapsed.
+ *
+ * @example
+ * ```ts
+ * // Single-block selection
+ * const ops = deleteSelectionOps(doc, { anchor: { offset: 2 }, focus: { offset: 7 } });
+ * // => [{ type: 'delete_text', offset: 2, count: 5 }]
+ *
+ * // Cross-block selection
+ * const ops = deleteSelectionOps(doc, { anchor: { offset: 3 }, focus: { offset: 8 } });
+ * // => [delete_text, merge_block, delete_text, ...]
+ * ```
+ */
+export function deleteSelectionOps(doc, selection) {
+    const startAbs = Math.min(selection.anchor.offset, selection.focus.offset);
+    const endAbs = Math.max(selection.anchor.offset, selection.focus.offset);
+    if (startAbs === endAbs) {
+        return [];
+    }
+    const startResolved = resolve(doc, startAbs);
+    const endResolved = resolve(doc, endAbs);
+    // Same block: simple delete_text
+    if (startResolved.blockIndex === endResolved.blockIndex) {
+        return [
+            { type: 'delete_text', offset: startAbs, count: endAbs - startAbs },
+        ];
+    }
+    // Cross-block deletion
+    const ops = [];
+    const startBI = startResolved.blockIndex;
+    const endBI = endResolved.blockIndex;
+    const startLocal = startResolved.localOffset;
+    const endLocal = endResolved.localOffset;
+    const startBlock = doc.blocks[startBI];
+    if (!startBlock)
+        return ops;
+    // Step 1: Delete the tail of the start block
+    const startBlockLen = blockTextLength(startBlock);
+    const tailLen = startBlockLen - startLocal;
+    if (tailLen > 0) {
+        ops.push({ type: 'delete_text', offset: startAbs, count: tailLen });
+    }
+    // Step 2: For each block from startBI+1 through endBI
+    for (let i = startBI + 1; i <= endBI; i++) {
+        const block = doc.blocks[i];
+        if (!block)
+            continue;
+        // Merge this block into the previous (which is now the start block)
+        ops.push({ type: 'merge_block', blockId: block.id });
+        // Determine how much text to delete from the merged content
+        const deleteCount = i === endBI ? endLocal : blockTextLength(block);
+        if (deleteCount > 0) {
+            ops.push({ type: 'delete_text', offset: startAbs, count: deleteCount });
+        }
+    }
+    return ops;
+}
+// ---------------------------------------------------------------------------
+// Block text extraction helper
+// ---------------------------------------------------------------------------
+/**
+ * Get the full text of a block by concatenating all span texts.
+ *
+ * @param block - The block to extract text from
+ * @returns The concatenated text of all spans
+ */
+function getBlockText(doc, blockIndex) {
+    const block = doc.blocks[blockIndex];
+    if (!block)
+        return '';
+    let text = '';
+    for (const span of block.spans) {
+        text += span.text;
+    }
+    return text;
+}
+// ---------------------------------------------------------------------------
+// InputBridge
+// ---------------------------------------------------------------------------
+/**
+ * The InputBridge intercepts DOM `beforeinput` events on a contenteditable
+ * element and translates them into RTIF operations.
+ *
+ * This is the "controlled contenteditable" approach: most input types are
+ * prevented and handled through the RTIF engine, while IME composition
+ * events are passed through to the browser for native rendering.
+ *
+ * @example
+ * ```ts
+ * const bridge = new InputBridge(root, {
+ *   getSelection: () => engine.state.selection,
+ *   getDoc: () => engine.state.doc,
+ *   dispatch: (ops) => engine.dispatch(ops),
+ *   undo: () => engine.undo(),
+ *   redo: () => engine.redo(),
+ *   isComposing: () => compositionHandler.isComposing(),
+ *   isReadOnly: () => false,
+ *   generateBlockId: () => crypto.randomUUID(),
+ * });
+ * bridge.attach();
+ * ```
+ */
+export class InputBridge {
+    _root;
+    _deps;
+    _attached = false;
+    /**
+     * Bound reference to the beforeinput handler so we can add/remove
+     * the same function reference.
+     */
+    _boundHandler;
+    constructor(root, deps) {
+        this._root = root;
+        this._deps = deps;
+        this._boundHandler = (e) => {
+            // Only handle InputEvent instances
+            if (e instanceof InputEvent) {
+                this.handleBeforeInput(e);
+            }
+        };
+    }
+    /**
+     * Attach the `beforeinput` event listener to the root element.
+     *
+     * Safe to call multiple times — only one listener is registered.
+     *
+     * @example
+     * ```ts
+     * bridge.attach();
+     * ```
+     */
+    attach() {
+        if (this._attached)
+            return;
+        this._root.addEventListener('beforeinput', this._boundHandler);
+        this._attached = true;
+    }
+    /**
+     * Remove the `beforeinput` event listener from the root element.
+     *
+     * Safe to call without a prior `attach()`.
+     *
+     * @example
+     * ```ts
+     * bridge.detach();
+     * ```
+     */
+    detach() {
+        if (!this._attached)
+            return;
+        this._root.removeEventListener('beforeinput', this._boundHandler);
+        this._attached = false;
+    }
+    /**
+     * Handle a `beforeinput` event by translating its `inputType` into
+     * RTIF operations.
+     *
+     * This method is public for testing. In production it is called by the
+     * bound event listener installed via `attach()`.
+     *
+     * @param e - The InputEvent from the `beforeinput` event
+     *
+     * @example
+     * ```ts
+     * // Typically called via the event listener, but can be called directly:
+     * bridge.handleBeforeInput(inputEvent);
+     * ```
+     */
+    handleBeforeInput(e) {
+        const inputType = e.inputType;
+        // ---------------------------------------------------------------
+        // Composition passthrough: let the browser handle IME mutations
+        // ---------------------------------------------------------------
+        if (this._deps.isComposing() && isCompositionInputType(inputType)) {
+            return;
+        }
+        // ---------------------------------------------------------------
+        // Read-only mode: block all mutations
+        // ---------------------------------------------------------------
+        if (this._deps.isReadOnly()) {
+            e.preventDefault();
+            return;
+        }
+        // ---------------------------------------------------------------
+        // Dispatch based on inputType
+        // ---------------------------------------------------------------
+        switch (inputType) {
+            case 'insertText':
+                e.preventDefault();
+                this._handleInsertText(e);
+                break;
+            case 'insertParagraph':
+                e.preventDefault();
+                this._handleSplitBlock();
+                break;
+            case 'insertLineBreak':
+                e.preventDefault();
+                this._handleInsertLineBreak();
+                break;
+            case 'deleteContentBackward':
+                e.preventDefault();
+                this._handleDeleteBackward();
+                break;
+            case 'deleteContentForward':
+                e.preventDefault();
+                this._handleDeleteForward();
+                break;
+            case 'deleteWordBackward':
+                e.preventDefault();
+                this._handleDeleteWordBackward();
+                break;
+            case 'deleteWordForward':
+                e.preventDefault();
+                this._handleDeleteWordForward();
+                break;
+            case 'deleteSoftLineBackward':
+            case 'deleteHardLineBackward':
+                e.preventDefault();
+                this._handleDeleteLineBackward();
+                break;
+            case 'deleteSoftLineForward':
+            case 'deleteHardLineForward':
+                e.preventDefault();
+                this._handleDeleteLineForward();
+                break;
+            case 'insertCompositionText':
+                // Not composing but got composition text — treat as regular text
+                e.preventDefault();
+                this._handleInsertText(e);
+                break;
+            case 'deleteByComposition':
+            case 'deleteCompositionText':
+                // Not composing — treat as backspace
+                e.preventDefault();
+                this._handleDeleteBackward();
+                break;
+            case 'insertReplacementText':
+                e.preventDefault();
+                this._handleInsertReplacement(e);
+                break;
+            case 'historyUndo':
+                e.preventDefault();
+                this._deps.undo();
+                break;
+            case 'historyRedo':
+                e.preventDefault();
+                this._deps.redo();
+                break;
+            // Clipboard events — handled by clipboard module, just prevent here
+            case 'deleteByCut':
+            case 'insertFromPaste':
+            case 'insertFromDrop':
+                e.preventDefault();
+                break;
+            // Format events — not handled in Phase 1
+            case 'formatBold':
+            case 'formatItalic':
+            case 'formatUnderline':
+            case 'formatStrikeThrough':
+            case 'formatSuperscript':
+            case 'formatSubscript':
+            case 'formatJustifyFull':
+            case 'formatJustifyCenter':
+            case 'formatJustifyRight':
+            case 'formatJustifyLeft':
+            case 'formatIndent':
+            case 'formatOutdent':
+            case 'formatRemove':
+            case 'formatSetBlockTextDirection':
+            case 'formatSetInlineTextDirection':
+            case 'formatBackColor':
+            case 'formatFontColor':
+            case 'formatFontName':
+                e.preventDefault();
+                break;
+            default:
+                // Unknown input type — prevent to avoid uncontrolled DOM mutations
+                e.preventDefault();
+                break;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Private handlers
+    // -----------------------------------------------------------------------
+    /**
+     * Handle `insertText` and `insertCompositionText` (when not composing).
+     *
+     * When pending marks are present (e.g., user toggled bold with collapsed cursor),
+     * appends a `set_span_marks` operation after the `insert_text` to apply those
+     * marks to the newly inserted text, then clears the pending marks.
+     */
+    _handleInsertText(e) {
+        const text = e.data;
+        if (!text)
+            return;
+        const sel = this._deps.getSelection();
+        const startAbs = Math.min(sel.anchor.offset, sel.focus.offset);
+        // Check for pending marks
+        const pendingMarks = this._deps.getPendingMarks?.() ?? {};
+        const hasPendingMarks = Object.keys(pendingMarks).length > 0;
+        const ops = [];
+        if (sel.anchor.offset !== sel.focus.offset) {
+            // Non-collapsed: delete selection, then insert
+            const doc = this._deps.getDoc();
+            const deleteOps = deleteSelectionOps(doc, sel);
+            ops.push(...deleteOps);
+        }
+        const insertOffset = sel.anchor.offset !== sel.focus.offset ? startAbs : sel.focus.offset;
+        ops.push({ type: 'insert_text', offset: insertOffset, text });
+        // Apply pending marks to the newly inserted text
+        if (hasPendingMarks) {
+            ops.push({
+                type: 'set_span_marks',
+                offset: insertOffset,
+                count: text.length,
+                marks: pendingMarks,
+            });
+        }
+        if (ops.length === 1) {
+            this._deps.dispatch(ops[0]);
+        }
+        else {
+            this._deps.dispatch(ops);
+        }
+        // Clear pending marks after use
+        if (hasPendingMarks) {
+            this._deps.clearPendingMarks?.();
+        }
+    }
+    /**
+     * Handle `insertLineBreak` (Shift+Enter).
+     * Inserts a newline character within the current block (soft line break).
+     */
+    _handleInsertLineBreak() {
+        const sel = this._deps.getSelection();
+        const startAbs = Math.min(sel.anchor.offset, sel.focus.offset);
+        const pendingMarks = this._deps.getPendingMarks?.() ?? {};
+        const hasPendingMarks = Object.keys(pendingMarks).length > 0;
+        const ops = [];
+        if (sel.anchor.offset !== sel.focus.offset) {
+            const doc = this._deps.getDoc();
+            const deleteOps = deleteSelectionOps(doc, sel);
+            ops.push(...deleteOps);
+        }
+        const insertOffset = sel.anchor.offset !== sel.focus.offset ? startAbs : sel.focus.offset;
+        ops.push({ type: 'insert_text', offset: insertOffset, text: '\n' });
+        if (hasPendingMarks) {
+            ops.push({
+                type: 'set_span_marks',
+                offset: insertOffset,
+                count: 1,
+                marks: pendingMarks,
+            });
+        }
+        if (ops.length === 1) {
+            this._deps.dispatch(ops[0]);
+        }
+        else {
+            this._deps.dispatch(ops);
+        }
+        if (hasPendingMarks) {
+            this._deps.clearPendingMarks?.();
+        }
+    }
+    /**
+     * Handle `insertParagraph` (Enter key).
+     */
+    _handleSplitBlock() {
+        const sel = this._deps.getSelection();
+        const startAbs = Math.min(sel.anchor.offset, sel.focus.offset);
+        const newBlockId = this._deps.generateBlockId();
+        if (sel.anchor.offset !== sel.focus.offset) {
+            const doc = this._deps.getDoc();
+            const deleteOps = deleteSelectionOps(doc, sel);
+            this._deps.dispatch([
+                ...deleteOps,
+                { type: 'split_block', offset: startAbs, newBlockId },
+            ]);
+        }
+        else {
+            this._deps.dispatch({
+                type: 'split_block',
+                offset: sel.focus.offset,
+                newBlockId,
+            });
+        }
+    }
+    /**
+     * Handle `deleteContentBackward` (Backspace, 1 character).
+     */
+    _handleDeleteBackward() {
+        const sel = this._deps.getSelection();
+        const doc = this._deps.getDoc();
+        // Non-collapsed selection: delete the selection
+        if (sel.anchor.offset !== sel.focus.offset) {
+            const ops = deleteSelectionOps(doc, sel);
+            if (ops.length > 0) {
+                this._deps.dispatch(ops.length === 1 ? ops[0] : ops);
+            }
+            return;
+        }
+        // Collapsed cursor
+        const offset = sel.focus.offset;
+        if (offset === 0) {
+            // At start of first block — revert empty non-text blocks to text
+            const block = doc.blocks[0];
+            if (block && block.type !== 'text' && blockTextLength(block) === 0) {
+                this._deps.dispatch({
+                    type: 'set_block_type',
+                    blockId: block.id,
+                    blockType: 'text',
+                });
+            }
+            return;
+        }
+        const resolved = resolve(doc, offset);
+        if (resolved.localOffset > 0) {
+            // Check if the character before cursor is inside an atomic mark
+            const atomicRange = this._deps.findAtomicMarkRange?.(offset - 1);
+            if (atomicRange) {
+                this._deps.dispatch({
+                    type: 'delete_text',
+                    offset: atomicRange.offset,
+                    count: atomicRange.count,
+                });
+                return;
+            }
+            // Delete one character before cursor
+            this._deps.dispatch({
+                type: 'delete_text',
+                offset: offset - 1,
+                count: 1,
+            });
+        }
+        else if (resolved.blockIndex > 0) {
+            // At start of a non-first block — merge with previous
+            const block = doc.blocks[resolved.blockIndex];
+            const prevBlock = doc.blocks[resolved.blockIndex - 1];
+            if (block && prevBlock) {
+                // If the previous block is atomic with empty text, merge but restore
+                // the current block's type/attrs to prevent corrupt state.
+                if (this._deps.isAtomicBlock?.(prevBlock.type) &&
+                    blockTextLength(prevBlock) === 0) {
+                    const ops = [
+                        { type: 'merge_block', blockId: block.id },
+                        { type: 'set_block_type', blockId: prevBlock.id, blockType: block.type },
+                    ];
+                    if (block.attrs && Object.keys(block.attrs).length > 0) {
+                        ops.push({ type: 'set_block_attrs', blockId: prevBlock.id, attrs: block.attrs });
+                    }
+                    this._deps.dispatch(ops);
+                    return;
+                }
+                this._deps.dispatch({
+                    type: 'merge_block',
+                    blockId: block.id,
+                });
+            }
+        }
+    }
+    /**
+     * Handle `deleteContentForward` (Delete key, 1 character).
+     */
+    _handleDeleteForward() {
+        const sel = this._deps.getSelection();
+        const doc = this._deps.getDoc();
+        // Non-collapsed selection: delete the selection
+        if (sel.anchor.offset !== sel.focus.offset) {
+            const ops = deleteSelectionOps(doc, sel);
+            if (ops.length > 0) {
+                this._deps.dispatch(ops.length === 1 ? ops[0] : ops);
+            }
+            return;
+        }
+        const offset = sel.focus.offset;
+        const resolved = resolve(doc, offset);
+        const block = doc.blocks[resolved.blockIndex];
+        if (!block)
+            return;
+        const bLen = blockTextLength(block);
+        if (resolved.localOffset < bLen) {
+            // Check if the character after cursor is inside an atomic mark
+            const atomicRange = this._deps.findAtomicMarkRange?.(offset);
+            if (atomicRange) {
+                this._deps.dispatch({
+                    type: 'delete_text',
+                    offset: atomicRange.offset,
+                    count: atomicRange.count,
+                });
+                return;
+            }
+            // Delete one character after cursor
+            this._deps.dispatch({
+                type: 'delete_text',
+                offset,
+                count: 1,
+            });
+        }
+        else if (resolved.blockIndex < doc.blocks.length - 1) {
+            // At end of non-last block — merge next block into current
+            const nextBlock = doc.blocks[resolved.blockIndex + 1];
+            if (nextBlock) {
+                // If the next block is atomic with empty text, simply remove it
+                // by merging and restoring the current block's type/attrs.
+                if (this._deps.isAtomicBlock?.(nextBlock.type) &&
+                    blockTextLength(nextBlock) === 0) {
+                    const currentBlock = doc.blocks[resolved.blockIndex];
+                    const ops = [
+                        { type: 'merge_block', blockId: nextBlock.id },
+                        { type: 'set_block_type', blockId: currentBlock.id, blockType: currentBlock.type },
+                    ];
+                    if (currentBlock.attrs && Object.keys(currentBlock.attrs).length > 0) {
+                        ops.push({ type: 'set_block_attrs', blockId: currentBlock.id, attrs: currentBlock.attrs });
+                    }
+                    this._deps.dispatch(ops);
+                    return;
+                }
+                this._deps.dispatch({
+                    type: 'merge_block',
+                    blockId: nextBlock.id,
+                });
+            }
+        }
+        // At end of last block — no-op
+    }
+    /**
+     * Handle `deleteWordBackward` (Ctrl/Option + Backspace).
+     */
+    _handleDeleteWordBackward() {
+        const sel = this._deps.getSelection();
+        const doc = this._deps.getDoc();
+        // Non-collapsed selection: delete the selection
+        if (sel.anchor.offset !== sel.focus.offset) {
+            const ops = deleteSelectionOps(doc, sel);
+            if (ops.length > 0) {
+                this._deps.dispatch(ops.length === 1 ? ops[0] : ops);
+            }
+            return;
+        }
+        const offset = sel.focus.offset;
+        const resolved = resolve(doc, offset);
+        if (resolved.localOffset === 0) {
+            // At start of block — merge with previous (same as single backspace)
+            if (resolved.blockIndex > 0) {
+                const block = doc.blocks[resolved.blockIndex];
+                if (block) {
+                    this._deps.dispatch({
+                        type: 'merge_block',
+                        blockId: block.id,
+                    });
+                }
+            }
+            return;
+        }
+        // Check if the character before cursor is inside an atomic mark
+        const atomicRange = this._deps.findAtomicMarkRange?.(offset - 1);
+        if (atomicRange) {
+            this._deps.dispatch({
+                type: 'delete_text',
+                offset: atomicRange.offset,
+                count: atomicRange.count,
+            });
+            return;
+        }
+        // Find word boundary backward
+        const blockText = getBlockText(doc, resolved.blockIndex);
+        const wordBoundary = findWordBoundaryBackward(blockText, resolved.localOffset);
+        const bStart = blockStartOffset(doc, resolved.blockIndex);
+        const deleteFrom = bStart + wordBoundary;
+        const deleteCount = offset - deleteFrom;
+        if (deleteCount > 0) {
+            this._deps.dispatch({
+                type: 'delete_text',
+                offset: deleteFrom,
+                count: deleteCount,
+            });
+        }
+    }
+    /**
+     * Handle `deleteWordForward` (Ctrl/Option + Delete).
+     */
+    _handleDeleteWordForward() {
+        const sel = this._deps.getSelection();
+        const doc = this._deps.getDoc();
+        // Non-collapsed selection: delete the selection
+        if (sel.anchor.offset !== sel.focus.offset) {
+            const ops = deleteSelectionOps(doc, sel);
+            if (ops.length > 0) {
+                this._deps.dispatch(ops.length === 1 ? ops[0] : ops);
+            }
+            return;
+        }
+        const offset = sel.focus.offset;
+        const resolved = resolve(doc, offset);
+        const block = doc.blocks[resolved.blockIndex];
+        if (!block)
+            return;
+        const bLen = blockTextLength(block);
+        if (resolved.localOffset >= bLen) {
+            // At end of block — merge next block (if exists)
+            if (resolved.blockIndex < doc.blocks.length - 1) {
+                const nextBlock = doc.blocks[resolved.blockIndex + 1];
+                if (nextBlock) {
+                    this._deps.dispatch({
+                        type: 'merge_block',
+                        blockId: nextBlock.id,
+                    });
+                }
+            }
+            return;
+        }
+        // Check if the character after cursor is inside an atomic mark
+        const atomicRange = this._deps.findAtomicMarkRange?.(offset);
+        if (atomicRange) {
+            this._deps.dispatch({
+                type: 'delete_text',
+                offset: atomicRange.offset,
+                count: atomicRange.count,
+            });
+            return;
+        }
+        // Find word boundary forward
+        const blockText = getBlockText(doc, resolved.blockIndex);
+        const wordBoundary = findWordBoundaryForward(blockText, resolved.localOffset);
+        const deleteCount = wordBoundary - resolved.localOffset;
+        if (deleteCount > 0) {
+            this._deps.dispatch({
+                type: 'delete_text',
+                offset,
+                count: deleteCount,
+            });
+        }
+    }
+    /**
+     * Handle `deleteSoftLineBackward` and `deleteHardLineBackward`
+     * (Cmd+Backspace on Mac).
+     */
+    _handleDeleteLineBackward() {
+        const sel = this._deps.getSelection();
+        const doc = this._deps.getDoc();
+        // Non-collapsed selection: delete the selection
+        if (sel.anchor.offset !== sel.focus.offset) {
+            const ops = deleteSelectionOps(doc, sel);
+            if (ops.length > 0) {
+                this._deps.dispatch(ops.length === 1 ? ops[0] : ops);
+            }
+            return;
+        }
+        const offset = sel.focus.offset;
+        const resolved = resolve(doc, offset);
+        if (resolved.localOffset === 0) {
+            // At start of block — merge with previous
+            if (resolved.blockIndex > 0) {
+                const block = doc.blocks[resolved.blockIndex];
+                if (block) {
+                    this._deps.dispatch({
+                        type: 'merge_block',
+                        blockId: block.id,
+                    });
+                }
+            }
+            return;
+        }
+        // Delete from start of block to cursor
+        const bStart = blockStartOffset(doc, resolved.blockIndex);
+        this._deps.dispatch({
+            type: 'delete_text',
+            offset: bStart,
+            count: resolved.localOffset,
+        });
+    }
+    /**
+     * Handle `deleteSoftLineForward` and `deleteHardLineForward`
+     * (Cmd+Delete on Mac).
+     */
+    _handleDeleteLineForward() {
+        const sel = this._deps.getSelection();
+        const doc = this._deps.getDoc();
+        // Non-collapsed selection: delete the selection
+        if (sel.anchor.offset !== sel.focus.offset) {
+            const ops = deleteSelectionOps(doc, sel);
+            if (ops.length > 0) {
+                this._deps.dispatch(ops.length === 1 ? ops[0] : ops);
+            }
+            return;
+        }
+        const offset = sel.focus.offset;
+        const resolved = resolve(doc, offset);
+        const block = doc.blocks[resolved.blockIndex];
+        if (!block)
+            return;
+        const bLen = blockTextLength(block);
+        if (resolved.localOffset >= bLen) {
+            // At end of block — merge next block if exists
+            if (resolved.blockIndex < doc.blocks.length - 1) {
+                const nextBlock = doc.blocks[resolved.blockIndex + 1];
+                if (nextBlock) {
+                    this._deps.dispatch({
+                        type: 'merge_block',
+                        blockId: nextBlock.id,
+                    });
+                }
+            }
+            return;
+        }
+        // Delete from cursor to end of block
+        const deleteCount = bLen - resolved.localOffset;
+        if (deleteCount > 0) {
+            this._deps.dispatch({
+                type: 'delete_text',
+                offset,
+                count: deleteCount,
+            });
+        }
+    }
+    /**
+     * Handle `insertReplacementText` (spellcheck/autocorrect acceptance).
+     *
+     * Reads the replacement text from `e.dataTransfer` or `e.data`, and
+     * the target range from `e.getTargetRanges()`. Falls back to treating
+     * the current selection as the target range if target ranges are
+     * unavailable.
+     */
+    _handleInsertReplacement(e) {
+        const replacementText = e.dataTransfer?.getData('text/plain') ?? e.data ?? null;
+        if (!replacementText)
+            return;
+        const sel = this._deps.getSelection();
+        const startAbs = Math.min(sel.anchor.offset, sel.focus.offset);
+        const endAbs = Math.max(sel.anchor.offset, sel.focus.offset);
+        const count = endAbs - startAbs;
+        if (count > 0) {
+            this._deps.dispatch([
+                { type: 'delete_text', offset: startAbs, count },
+                { type: 'insert_text', offset: startAbs, text: replacementText },
+            ]);
+        }
+        else {
+            // Collapsed cursor — just insert
+            this._deps.dispatch({
+                type: 'insert_text',
+                offset: startAbs,
+                text: replacementText,
+            });
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Input types that should be passed through during IME composition.
+ */
+const COMPOSITION_INPUT_TYPES = new Set([
+    'insertCompositionText',
+    'deleteCompositionText',
+    'deleteByComposition',
+]);
+/**
+ * Check whether an inputType is a composition-related type that should
+ * be passed through to the browser during an active composition session.
+ */
+function isCompositionInputType(inputType) {
+    return COMPOSITION_INPUT_TYPES.has(inputType);
+}
+//# sourceMappingURL=input-bridge.js.map