edytor 1.0.0-rc.3 → 2.0.0

package/dist/selection/domSelection.js

@@ -1,130 +1,78 @@
-const hasSelectionApi = (root) => typeof root.getSelection === 'function';
-const isShadowRoot = (root) => typeof ShadowRoot !== 'undefined' && root instanceof ShadowRoot;
-const getOwnerDocument = (node) => node?.ownerDocument ?? (typeof document === 'undefined' ? null : document);
-const getDocumentSelection = (node) => {
-    const ownerDocument = getOwnerDocument(node);
-    return ownerDocument?.defaultView?.getSelection?.() ?? ownerDocument?.getSelection?.() ?? null;
-};
-export const getDomSelection = (node) => {
+const ownerOf = (node) => node?.ownerDocument ?? (typeof document === 'undefined' ? null : document);
+/** The shadow root holding `node`, if any. */
+const shadowOf = (node) => {
     const root = node?.getRootNode();
-    if (isShadowRoot(root) && hasSelectionApi(root)) {
-        const selection = root.getSelection();
-        if (selection) {
-            return selection;
-        }
-    }
-    return getDocumentSelection(node);
-};
-export const getActiveElement = (node) => {
-    const root = node?.getRootNode();
-    if (isShadowRoot(root)) {
-        return root.activeElement ?? getOwnerDocument(node)?.activeElement ?? null;
-    }
-    return getOwnerDocument(node)?.activeElement ?? null;
+    return typeof ShadowRoot !== 'undefined' && root instanceof ShadowRoot ? root : null;
 };
+const documentSelection = (node) => ownerOf(node)?.getSelection() ?? null;
+export const getDomSelection = (node) => shadowOf(node)?.getSelection?.() ?? documentSelection(node);
+export const getActiveElement = (node) => shadowOf(node)?.activeElement ?? ownerOf(node)?.activeElement ?? null;
 export const clearDomSelection = (node) => {
     getDomSelection(node)?.removeAllRanges();
 };
-export const createDomRange = (node) => {
-    const ownerDocument = getOwnerDocument(node);
-    if (!ownerDocument) {
-        throw new Error('Cannot create a DOM range without an owner document');
-    }
-    return ownerDocument.createRange();
+/**
+ * The caret point under (`x`, `y`): `caretPositionFromPoint` (Firefox,
+ * Chromium 128, Safari 26.2), else `caretRangeFromPoint` (the supported
+ * Chromium and Safari before those).
+ */
+export const caretAtPoint = (doc, x, y) => {
+    const at = doc;
+    const position = at.caretPositionFromPoint?.(x, y);
+    if (position?.offsetNode)
+        return { node: position.offsetNode, offset: position.offset };
+    const range = at.caretRangeFromPoint?.(x, y);
+    return range ? { node: range.startContainer, offset: range.startOffset } : null;
 };
-const isSelectionCollapsed = (selection) => selection.anchorNode === selection.focusNode && selection.anchorOffset === selection.focusOffset;
-const createDomSelectionSnapshot = (selection) => ({
-    anchorNode: selection.anchorNode,
-    anchorOffset: selection.anchorOffset,
-    direction: selection.direction,
-    focusNode: selection.focusNode,
-    focusOffset: selection.focusOffset,
-    isCollapsed: isSelectionCollapsed(selection),
-    rangeCount: selection.rangeCount,
-    getRangeAt: (index) => selection.getRangeAt(index),
-    nativeSelection: selection,
-    toString: () => selection.toString(),
-    type: selection.type
-});
-export const createDomSelectionSnapshotFromRange = (range, nativeSelection = null) => ({
+/** A range in `node`'s document (a node always has one). */
+export const createDomRange = (node) => ownerOf(node).createRange();
+/** A snapshot of one range, forward. */
+export const createDomSelectionSnapshotFromRange = (range) => ({
     anchorNode: range.startContainer,
     anchorOffset: range.startOffset,
-    direction: 'forward',
     focusNode: range.endContainer,
     focusOffset: range.endOffset,
     isCollapsed: range.collapsed,
     rangeCount: 1,
-    getRangeAt: (index) => {
-        if (index !== 0) {
-            throw new Error(`Selection range ${index} is unavailable`);
-        }
-        return range;
-    },
-    nativeSelection,
-    toString: () => range.toString(),
-    type: range.collapsed ? 'Caret' : 'Range'
+    getRangeAt: () => range
 });
-const createRangeFromStaticRange = (staticRange) => {
-    const range = createDomRange(staticRange.startContainer);
-    range.setStart(staticRange.startContainer, staticRange.startOffset);
-    range.setEnd(staticRange.endContainer, staticRange.endOffset);
-    return range;
-};
-const isNodeInside = (root, target) => root === target || root.contains(target);
-const getContainedRanges = (selection, container) => {
+/**
+ * A snapshot of `selection`. Several ranges inside `container` are read as
+ * their bounding range, and the DOM is canonicalized to it too, so what the
+ * user sees matches what the model derives (the editor has no multi-range
+ * model); one is read alone.
+ */
+const snapshotOf = (selection, container) => {
     const ranges = [];
-    for (let index = 0; index < selection.rangeCount; index++) {
+    for (let index = 0; selection.rangeCount > 1 && index < selection.rangeCount; index++) {
         const range = selection.getRangeAt(index);
         if (!container ||
-            (isNodeInside(container, range.startContainer) && isNodeInside(container, range.endContainer))) {
+            (container.contains(range.startContainer) && container.contains(range.endContainer)))
             ranges.push(range);
-        }
-    }
-    return ranges;
-};
-const createDomSelectionSnapshotFromMultiRange = (selection, container) => {
-    if (selection.rangeCount <= 1) {
-        return null;
-    }
-    const ranges = getContainedRanges(selection, container);
-    if (ranges.length === 0) {
-        return null;
     }
-    if (ranges.length === 1) {
-        return createDomSelectionSnapshotFromRange(ranges[0], selection);
-    }
-    let firstRange = ranges[0];
-    let lastRange = ranges[0];
-    for (const range of ranges.slice(1)) {
-        if (range.compareBoundaryPoints(Range.START_TO_START, firstRange) < 0) {
-            firstRange = range;
-        }
-        if (range.compareBoundaryPoints(Range.END_TO_END, lastRange) > 0) {
-            lastRange = range;
-        }
-    }
-    const combinedRange = createDomRange(firstRange.startContainer);
-    combinedRange.setStart(firstRange.startContainer, firstRange.startOffset);
-    combinedRange.setEnd(lastRange.endContainer, lastRange.endOffset);
-    // Not just a read: a multi-range selection is canonicalized to its
-    // bounding range in the DOM too, so what the user sees matches the
-    // snapshot the model derives (the editor has no multi-range model).
-    selection.removeAllRanges();
-    selection.addRange(combinedRange);
-    return createDomSelectionSnapshotFromRange(combinedRange, selection);
-};
-const getComposedRangeSnapshot = (root, selection) => {
-    if (typeof selection?.getComposedRanges !== 'function') {
-        return null;
-    }
-    const [staticRange] = selection.getComposedRanges({ shadowRoots: [root] });
-    if (!staticRange ||
-        !root.contains(staticRange.startContainer) ||
-        !root.contains(staticRange.endContainer)) {
-        return null;
-    }
-    const range = createRangeFromStaticRange(staticRange);
-    return createDomSelectionSnapshotFromRange(range, selection);
+    if (ranges.length === 1)
+        return createDomSelectionSnapshotFromRange(ranges[0]);
+    if (ranges.length > 1) {
+        const [first, last] = ranges.reduce(([first, last], range) => [
+            range.compareBoundaryPoints(Range.START_TO_START, first) < 0 ? range : first,
+            range.compareBoundaryPoints(Range.END_TO_END, last) > 0 ? range : last
+        ], [ranges[0], ranges[0]]);
+        const bounds = createDomRange(first.startContainer);
+        bounds.setStart(first.startContainer, first.startOffset);
+        bounds.setEnd(last.endContainer, last.endOffset);
+        selection.removeAllRanges();
+        selection.addRange(bounds);
+        return createDomSelectionSnapshotFromRange(bounds);
+    }
+    const { anchorNode, anchorOffset, focusNode, focusOffset } = selection;
+    return {
+        anchorNode,
+        anchorOffset,
+        focusNode,
+        focusOffset,
+        isCollapsed: anchorNode === focusNode && anchorOffset === focusOffset,
+        rangeCount: selection.rangeCount,
+        getRangeAt: (index) => selection.getRangeAt(index)
+    };
 };
 /**
  * Scroll the caret into view after a programmatic selection write.
@@ -144,87 +92,66 @@ const getComposedRangeSnapshot = (root, selection) => {
  *   `block:'nearest'` otherwise still nudges scroll containers.
  */
 export const scrollCaretIntoView = (root) => {
-    if (!root) {
-        return;
-    }
-    const selection = getDomSelection(root);
+    const selection = root && getDomSelection(root);
     const focusNode = selection?.focusNode;
-    if (!selection || !focusNode || selection.rangeCount === 0 || !root.contains(focusNode)) {
+    if (!selection || !focusNode || selection.rangeCount === 0 || !root.contains(focusNode))
         return;
-    }
-    const activeElement = getActiveElement(root);
-    if (activeElement !== root && !(activeElement && root.contains(activeElement))) {
+    const active = getActiveElement(root);
+    if (!active || !root.contains(active))
         return;
-    }
-    // Collapse a scratch range at the FOCUS endpoint so a backward range
-    // scrolls to the moving edge, and collapsed carets get the exact
-    // caret box rather than the element box. The offset is clamped — a
-    // foreign DOM mutation can leave the selection pointing past a
-    // shrunken node, and `setStart` throws on out-of-bounds offsets.
-    const caretRange = createDomRange(focusNode);
-    const maxOffset = focusNode instanceof Element ? focusNode.childNodes.length : (focusNode.nodeValue?.length ?? 0);
-    caretRange.setStart(focusNode, Math.min(selection.focusOffset, maxOffset));
-    caretRange.collapse(true);
     const element = focusNode instanceof Element ? focusNode : focusNode.parentElement;
-    if (!element) {
+    if (!element)
         return;
-    }
-    // Optional-chained: non-layout environments (jsdom) don't implement
-    // range rects — the element box is the fallback in real browsers too
-    // when the caret rect comes back empty.
-    const caretRect = caretRange.getBoundingClientRect?.() ?? null;
-    const box = caretRect && (caretRect.top !== 0 || caretRect.bottom !== 0)
-        ? caretRect
-        : element.getBoundingClientRect();
-    const view = element.ownerDocument.defaultView;
-    const viewportHeight = view?.innerHeight ?? element.ownerDocument.documentElement.clientHeight;
-    const viewportWidth = view?.innerWidth ?? element.ownerDocument.documentElement.clientWidth;
-    const insideViewport = box.top >= 0 && box.bottom <= viewportHeight && box.left >= 0 && box.right <= viewportWidth;
-    // The viewport check alone is not enough — an `overflow:auto/scroll/
-    // hidden` ancestor clips the caret while it stays inside the window
-    // viewport (the common "editor inside a scrollable pane" case). Walk
-    // the ancestor chain; any scrollable clip counts as out-of-view.
-    let clippedByScroller = false;
-    if (insideViewport && view?.getComputedStyle) {
-        for (let ancestor = element.parentElement; ancestor && ancestor !== element.ownerDocument.documentElement; ancestor = ancestor.parentElement) {
-            const style = view.getComputedStyle(ancestor);
-            const overflow = `${style.overflow} ${style.overflowX} ${style.overflowY}`;
-            if (!/(auto|scroll|hidden)/.test(overflow)) {
-                continue;
-            }
-            const rect = ancestor.getBoundingClientRect();
-            if (box.top < rect.top ||
-                box.bottom > rect.bottom ||
-                box.left < rect.left ||
-                box.right > rect.right) {
-                clippedByScroller = true;
-                break;
-            }
-        }
-    }
-    if (insideViewport && !clippedByScroller) {
-        return;
-    }
-    element.scrollIntoView?.({ block: 'nearest', inline: 'nearest' });
+    // A scratch range collapsed at the FOCUS endpoint: a backward range
+    // scrolls to the moving edge, a caret gets its exact box. The offset is
+    // clamped — a foreign DOM mutation can leave the selection past a
+    // shrunken node, and `setStart` throws out of bounds.
+    const caret = createDomRange(focusNode);
+    const max = focusNode instanceof Element ? focusNode.childNodes.length : (focusNode.nodeValue?.length ?? 0);
+    caret.setStart(focusNode, Math.min(selection.focusOffset, max));
+    caret.collapse(true);
+    // Optional-chained: jsdom has no range rects; an empty caret rect reads
+    // the element's box, in real browsers too.
+    const rect = caret.getBoundingClientRect?.();
+    const box = rect && (rect.top !== 0 || rect.bottom !== 0) ? rect : element.getBoundingClientRect();
+    const clips = (r) => box.top < r.top || box.bottom > r.bottom || box.left < r.left || box.right > r.right;
+    const document = element.ownerDocument;
+    const view = document.defaultView;
+    const { clientWidth, clientHeight } = document.documentElement;
+    // The viewport clips it, or a scrolling ancestor does while it stays in
+    // the window (the "editor inside a scrollable pane" case).
+    let clipped = clips({
+        top: 0,
+        left: 0,
+        bottom: view?.innerHeight ?? clientHeight,
+        right: view?.innerWidth ?? clientWidth
+    });
+    for (let ancestor = element.parentElement; !clipped && view?.getComputedStyle && ancestor && ancestor !== document.documentElement; ancestor = ancestor.parentElement) {
+        const { overflow, overflowX, overflowY } = view.getComputedStyle(ancestor);
+        clipped =
+            /(auto|scroll|hidden)/.test(`${overflow} ${overflowX} ${overflowY}`) &&
+                clips(ancestor.getBoundingClientRect());
+    }
+    if (clipped)
+        element.scrollIntoView?.({ block: 'nearest', inline: 'nearest' });
 };
 export const getDomSelectionSnapshot = (node) => {
-    const root = node?.getRootNode();
-    const documentSelection = getDocumentSelection(node);
-    if (isShadowRoot(root)) {
-        if (hasSelectionApi(root)) {
-            const shadowSelection = root.getSelection();
-            if (shadowSelection?.anchorNode) {
-                return (createDomSelectionSnapshotFromMultiRange(shadowSelection, node) ??
-                    createDomSelectionSnapshot(shadowSelection));
-            }
-        }
-        const composedSnapshot = getComposedRangeSnapshot(root, documentSelection);
-        if (composedSnapshot) {
-            return composedSnapshot;
+    const root = shadowOf(node);
+    const selection = documentSelection(node);
+    if (root) {
+        const own = root.getSelection?.();
+        if (own?.anchorNode)
+            return snapshotOf(own, node);
+        // A selection inside a shadow root the document only reports composed.
+        const [composed] = selection?.getComposedRanges?.({ shadowRoots: [root] }) ?? [];
+        if (composed &&
+            root.contains(composed.startContainer) &&
+            root.contains(composed.endContainer)) {
+            const range = createDomRange(composed.startContainer);
+            range.setStart(composed.startContainer, composed.startOffset);
+            range.setEnd(composed.endContainer, composed.endOffset);
+            return createDomSelectionSnapshotFromRange(range);
         }
     }
-    return documentSelection
-        ? (createDomSelectionSnapshotFromMultiRange(documentSelection, node) ??
-            createDomSelectionSnapshot(documentSelection))
-        : null;
+    return selection && snapshotOf(selection, node);
 };

package/dist/selection/pointer.svelte.d.ts

@@ -1,3 +1,11 @@
+/**
+ * The selection under a pointer (`selection.pointer`): a press and its drag
+ * (`dragStart`, the drag's release, a normalization it held back), a press
+ * on a block's non-editable chrome, a triple click, a drag across columns
+ * (`acrossColumns`), a drag over inline atoms and `selectstart` on chrome.
+ * It writes the selection only through the selection's own writers; the
+ * selection's DOM adoption reads `dragging` and `across` and asks `hold()`.
+ */
 import type { Text } from '../text/text.svelte.js';
 import type { EdytorSelection } from './selection.svelte.js';
 /** A text point under the pointer, with where the pointer was. */
@@ -23,14 +31,4 @@ export declare class SelectionPointer {
     get across(): boolean;
     /** A normalization the drag holds back until its release. */
     hold: () => void;
-    private insideText;
-    private chromeBlock;
-    /** The text point under the pointer, if any. */
-    pointAt: (clientX: number, clientY: number) => {
-        text: Text;
-        offset: number;
-        clientX: number;
-        clientY: number;
-    } | null;
-    offsetAt: (text: Text, clientX: number, clientY: number) => number;
 }

package/dist/selection/pointer.svelte.js

@@ -1,19 +1,10 @@
-/**
- * The selection under a pointer (`selection.pointer`): a press and its drag
- * (`dragStart`, the drag's release, a normalization it held back), a press
- * on a block's non-editable chrome, a triple click, a drag across columns
- * (`acrossColumns`), a drag over inline atoms and `selectstart` on chrome.
- * It writes the selection only through the selection's own setters; the
- * selection's DOM adoption reads `dragging` and `across` and asks `hold()`.
- */
-import { InlineBlock } from '../block/inlineBlock.svelte.js';
 import { blockSelection } from '../session/selection.js';
 import { toTrailingParagraph } from '../session/navigation.js';
-import { isNativeInteractiveEvent } from '../events/nativeInteractiveControl.js';
+import { isNativeInteractiveControl, isNativeInteractiveEvent } from '../events/nativeInteractiveControl.js';
 import { acrossColumns } from './replaceSelection.js';
-import { getDomSelectionSnapshot } from './domSelection.js';
+import { caretAtPoint, getDomSelectionSnapshot } from './domSelection.js';
 import { domPointOf } from '../surface/projector.svelte.js';
-import { getElementFromNode, getYIndex, SUGGESTION } from './selection.utils.js';
+import { getElementFromNode, isTextBoundSelectionPoint, offsetIn, SUGGESTION } from './selection.utils.js';
 export class SelectionPointer {
     selection;
     /** The press's text point while a primary press (a drag) lasts; `null` after its release. */
@@ -33,11 +24,7 @@ export class SelectionPointer {
     hold = () => {
         this.#held = true;
     };
-    insideText = (node) => {
-        const element = getElementFromNode(node);
-        return Boolean(element?.closest('[data-edytor-text]'));
-    };
-    chromeBlock = (node) => {
+    #chromeBlock = (node) => {
         const element = getElementFromNode(node);
         const nonEditableElement = element?.closest('[contenteditable="false"]');
         if (!(nonEditableElement instanceof HTMLElement) ||
@@ -45,7 +32,7 @@ export class SelectionPointer {
             return null;
         }
         // A suggestion's preview is no block's chrome: a press there is its own (cancelled).
-        if (nonEditableElement.closest(`input, textarea, select, button, a[href], ${SUGGESTION}`)) {
+        if (isNativeInteractiveControl(nonEditableElement) || nonEditableElement.closest(SUGGESTION)) {
             return null;
         }
         const block = this.selection.getBlockOfNode(nonEditableElement);
@@ -169,17 +156,17 @@ export class SelectionPointer {
         }
         const box = host.getBoundingClientRect();
         const x = Math.min(Math.max(at.clientX, box.left + 1), box.right - 1);
-        const point = this.pointAt(x, at.clientY);
+        const point = this.#pointAt(x, at.clientY);
         if (!point)
             return;
         edytor.expectInternalFocus();
         host.focus({ preventScroll: true });
-        this.selection.setAtTextOffset(point.text, point.offset);
+        this.selection.selectText(point.text, point.offset);
     };
     /** @internal */
     chromePress = (event) => {
         const targetNode = event.target instanceof Node ? event.target : null;
-        const targetBlock = this.chromeBlock(targetNode);
+        const targetBlock = this.#chromeBlock(targetNode);
         const targetText = targetBlock?.firstText;
         // A native control inside the chrome (a void block's input) owns its press.
         if (!targetText || isNativeInteractiveEvent(event)) {
@@ -190,7 +177,7 @@ export class SelectionPointer {
         event.preventDefault();
         this.selection.edytor.expectInternalFocus();
         this.selection.edytor.node?.focus({ preventScroll: true });
-        this.selection.setAtTextOffset(targetText, 0);
+        this.selection.selectText(targetText, 0);
     };
     /**
      * A triple click selects the block's content in the model; the browser's
@@ -203,18 +190,15 @@ export class SelectionPointer {
             return;
         const targetNode = e.target instanceof Node ? e.target : null;
         const clickedBlock = this.selection.getBlockOfNode(targetNode);
-        if (clickedBlock?.definition.void && !this.insideText(targetNode)) {
+        if (clickedBlock?.definition.void && !isTextBoundSelectionPoint(targetNode)) {
             e.preventDefault();
-            this.selection.selectBlocks(clickedBlock);
+            this.selection.select(blockSelection([clickedBlock.id]));
             return;
         }
-        const targetBlock = targetNode instanceof Node
-            ? (this.selection.getTextOfNode(targetNode)?.parent ??
-                this.selection.getBlockOfNode(targetNode))
-            : this.selection.state.startText?.parent;
-        if (targetBlock) {
-            this.selection.preserveBlockRange(targetBlock);
-        }
+        const { selection } = this;
+        selection.selectLines(targetNode
+            ? (selection.getTextOfNode(targetNode)?.parent ?? selection.getBlockOfNode(targetNode))
+            : selection.textAt(selection.projection.start)?.text.parent);
     };
     /** @internal */
     preventTripleClick = (e) => {
@@ -222,30 +206,17 @@ export class SelectionPointer {
             e.preventDefault();
     };
     /** The text point under the pointer, if any. */
-    pointAt = (clientX, clientY) => {
-        const ownerDocument = (this.selection.edytor.node?.ownerDocument ??
-            document);
-        const caretPosition = ownerDocument.caretPositionFromPoint?.(clientX, clientY);
-        const caretRange = caretPosition ? null : ownerDocument.caretRangeFromPoint?.(clientX, clientY);
-        const node = caretPosition?.offsetNode ?? caretRange?.startContainer ?? null;
-        const domOffset = caretPosition?.offset ?? caretRange?.startOffset ?? null;
-        const text = this.selection.getTextOfNode(node, domOffset ?? undefined);
-        if (!text || typeof domOffset !== 'number') {
-            return null;
-        }
-        return {
-            text,
-            offset: Math.min(Math.max(getYIndex(text, node, domOffset), 0), text.length),
-            clientX,
-            clientY
-        };
+    #pointAt = (clientX, clientY) => {
+        const at = caretAtPoint(this.selection.edytor.node?.ownerDocument ?? document, clientX, clientY);
+        const text = at && this.selection.getTextOfNode(at.node, at.offset);
+        return text ? { text, offset: offsetIn(text, at.node, at.offset), clientX, clientY } : null;
     };
-    offsetAt = (text, clientX, clientY) => {
+    #offsetAt = (text, clientX, clientY) => {
         const ownerDocument = text.node?.ownerDocument;
         if (!text.node || !ownerDocument) {
             return 0;
         }
-        const caretPoint = this.pointAt(clientX, clientY);
+        const caretPoint = this.#pointAt(clientX, clientY);
         if (caretPoint?.text === text) {
             return caretPoint.offset;
         }
@@ -270,7 +241,7 @@ export class SelectionPointer {
     };
     /** @internal */
     placeAt = (text, clientX, clientY) => {
-        this.selection.setAtTextOffset(text, this.offsetAt(text, clientX, clientY));
+        this.selection.selectText(text, this.#offsetAt(text, clientX, clientY));
     };
     /** @internal */
     capture = (event) => {
@@ -278,7 +249,7 @@ export class SelectionPointer {
             this.dragStart = null;
             return;
         }
-        this.dragStart = this.pointAt(event.clientX, event.clientY);
+        this.dragStart = this.#pointAt(event.clientX, event.clientY);
         this.#across = false;
         this.#extending = event.shiftKey;
     };
@@ -350,11 +321,11 @@ export class SelectionPointer {
             return;
         }
         this.selection.placedOver = this.selection.value;
-        const point = this.pointAt(event.clientX, event.clientY);
+        const point = this.#pointAt(event.clientX, event.clientY);
         if (!point) {
             return;
         }
-        this.selection.setAtTextOffset(point.text, point.offset);
+        this.selection.selectText(point.text, point.offset);
     };
     /** @internal */
     restoreAtomRange = (event) => {
@@ -364,7 +335,7 @@ export class SelectionPointer {
         if (!dragStart || event.button !== 0) {
             return;
         }
-        const dragEnd = this.pointAt(event.clientX, event.clientY);
+        const dragEnd = this.#pointAt(event.clientX, event.clientY);
         if (!dragEnd) {
             return;
         }
@@ -372,27 +343,15 @@ export class SelectionPointer {
         if (movement < 4) {
             return;
         }
+        // Two texts of one block hold an inline atom between them (a block's
+        // content alternates texts and atoms): the range is the drag's.
         window.setTimeout(() => {
-            if (dragStart.text.parent !== dragEnd.text.parent) {
-                return;
-            }
             const content = dragStart.text.parent.content;
-            const startIndex = content.indexOf(dragStart.text);
-            const endIndex = content.indexOf(dragEnd.text);
-            const firstTextIndex = Math.min(startIndex, endIndex);
-            const lastTextIndex = Math.max(startIndex, endIndex);
-            const hasInlineAtomBetweenTextPoints = content.some((part, index) => part instanceof InlineBlock && index > firstTextIndex && index < lastTextIndex);
-            if (startIndex === -1 || endIndex === -1 || !hasInlineAtomBetweenTextPoints) {
+            const [from, to] = [content.indexOf(dragStart.text), content.indexOf(dragEnd.text)];
+            if (dragStart.text.parent !== dragEnd.text.parent || from < 0 || to < 0 || from === to)
                 return;
-            }
-            const isReversed = startIndex > endIndex;
-            const rangeStart = isReversed ? dragEnd : dragStart;
-            const rangeEnd = isReversed ? dragStart : dragEnd;
-            this.selection.clearInlineBlockSelection();
-            this.selection.setAtRange(rangeStart.text, rangeStart.offset, rangeEnd.text, rangeEnd.offset, {
-                isReversed
-            });
-            this.selection.clearInlineBlockSelection();
+            const [start, end] = from < to ? [dragStart, dragEnd] : [dragEnd, dragStart];
+            this.selection.selectText(start.text, start.offset, end.text, end.offset, from > to);
         });
     };
     /**

package/dist/selection/replaceSelection.d.ts

@@ -1,15 +1,28 @@
 import type { Block } from '../block/block.svelte.js';
 import type { Edytor } from '../edytor.svelte.js';
 import { Text } from '../text/text.svelte.js';
-import type { RangeEndpoints } from '../edytor.utils.js';
+import type { OpResult } from '../crdt/edytor-doc.js';
 export type SelectionInsertionTarget = {
     text: Text;
     offset: number;
 };
+/** The two endpoints of a range, as the selection holds them. */
+export type RangeEndpoints = {
+    startText: Text | null;
+    endText: Text | null;
+    yStart: number;
+    yEnd: number;
+};
+/**
+ * The caret a write that decides one left (a range deletion, a placed flow:
+ * the view selects it), as a text and an offset; none when the write was
+ * refused.
+ */
+export declare const caretLeft: (edytor: Edytor, result: OpResult) => SelectionInsertionTarget | null;
+/** A range to replace (an attempt's target); none: the live selection. */
 export type SelectionReplacementState = RangeEndpoints & {
     isCollapsed: boolean;
 };
-export declare const getSelectionReplacementState: (edytor: Edytor) => SelectionReplacementState;
 /**
  * The selected blocks as clicked, in document order: a grip-selected list is
  * one block. What a command over them acts on (a list with its items) is
@@ -85,27 +98,13 @@ export declare const movable: (blocks: Iterable<Block>) => Block[];
  */
 export declare const selectMoved: (edytor: Edytor, moved: Block[], before: Iterable<Block>) => void;
 /**
- * Run a block move that never hides a block the user saw (Notion): a closed
- * toggle a moved block lands in opens, and so does a closed toggle that
- * adopts blocks (Shift+Tab takes the blocks after it). `open` is view state.
- * Every relative move (`edytor.moveBlocks`) and every block move
- * command (`revealed`) share it. Answers the moved blocks.
- */
-export declare const revealing: (blocks: Block[], move: () => Block[]) => Block[];
-/**
- * Open every closed toggle `block` sits in, so it shows: a moved block
- * ({@link revealing}), find's current match (`plugins/find`).
+ * Open every closed toggle `block` sits in, so it shows (Notion: a move never
+ * hides a block the user saw): every block a view's operation moved (the
+ * dispatcher's write; a remote peer's move, an undo or a redo opens nothing:
+ * `open` is this view's state), find's current match (`plugins/find`).
  */
 export declare const reveal: (block: Block) => void;
-/**
- * A block's move command (`nestBlock`, `unNestBlock`, `moveBlock`,
- * `moveBlocks`) that reveals what it moved (`revealing`), as the keys and
- * `edytor.moveBlocks` do. A remote peer's move, an undo or a redo
- * opens nothing: `open` is this view's state, and history restores it as
- * it was.
- */
-export declare const revealed: <A extends unknown[], R extends Block | Block[] | null | undefined>(command: (...args: A) => R) => (this: Block, ...args: A) => R;
-export declare const replaceSelectionWithCollapsedTarget: (edytor: Edytor, state?: SelectionReplacementState) => SelectionInsertionTarget | null;
+export declare const replaceSelectionWithCollapsedTarget: (edytor: Edytor, range?: SelectionReplacementState) => SelectionInsertionTarget | null;
 /**
  * The first or last text `block` shows: its own line's (a block selection is
  * exactly its members, never their unselected children), else, for a block
@@ -114,7 +113,7 @@ export declare const replaceSelectionWithCollapsedTarget: (edytor: Edytor, state
  * document order); none for a void that shows nothing (a divider) or a
  * closed toggle's hidden body. A line created in the same change counts (it
  * is displayed once it mounts), as for `caretBeside`. Ranges over blocks
- * (`setAtBlockRange`, leaving a block selection), the block-selection keys
+ * (`selectLines`: Mod+A, a triple click), the block-selection keys
  * and Escape read it.
  */
 export declare const shownText: (block: Block, edge: "first" | "last", whole?: boolean) => Text | undefined;