edytor 1.0.0-rc.2 → 1.0.0

package/dist/selection/pointer.svelte.js

@@ -1,18 +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 { isNativeInteractiveEvent } from '../events/nativeInteractiveControl.js';
+import { toTrailingParagraph } from '../session/navigation.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. */
@@ -32,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) ||
@@ -44,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);
@@ -53,10 +41,132 @@ export class SelectionPointer {
         }
         return block;
     };
+    /**
+     * A press in the host's own area below its last block (its bottom
+     * padding, its height past the content; `nav.trailing.press`, Notion):
+     * the caret goes to the trailing paragraph (`toTrailingParagraph`, a new
+     * one when the last block is not an empty one). A primary press without
+     * a modifier, from a mouse or a pen (a touch there may start a scroll:
+     * the browser's); a view that writes nothing keeps the browser's caret.
+     * Answers whether it took the press.
+     * @internal
+     */
+    belowPress = (event) => {
+        const { edytor } = this.selection;
+        const host = edytor.node;
+        if (!host || event.target !== host || event.button !== 0)
+            return false;
+        if (event.shiftKey || event.altKey || event.metaKey || event.ctrlKey)
+            return false;
+        if (event.pointerType === 'touch' || !edytor.dispatcher.permits())
+            return false;
+        if (!this.#below(event.clientY))
+            return false;
+        // The model answers this press, as a chrome press: no native caret placement.
+        event.preventDefault();
+        this.#trailing();
+        return true;
+    };
+    /** Whether `y` lies below the host's last top-level block (`nav.trailing.press`'s place). */
+    #below = (y) => {
+        const last = this.selection.edytor.root?.children.at(-1)?.node;
+        const bottom = last?.getBoundingClientRect().bottom;
+        return bottom !== undefined && y > bottom;
+    };
+    #trailing = () => {
+        const { edytor } = this.selection;
+        edytor.expectInternalFocus();
+        edytor.node?.focus({ preventScroll: true });
+        toTrailingParagraph(edytor);
+    };
+    /** The gesture a press in the host's own area starts (`claimMargins`): the marquee's. */
+    #margin = null;
+    /**
+     * The host's last press went to the margin gesture (`marginPress`), until
+     * its release: its compatibility `mousedown` is cancelled (no native
+     * caret, focus or selection), and it places no caret (`pressed`) and
+     * starts no text drag (`capture`).
+     * @internal
+     */
+    claimed = false;
+    /**
+     * Register the gesture a press in the host's own area starts (one per
+     * view: the marquee plugin's, `sel.marquee`). Answers the release.
+     * @internal
+     */
+    claimMargins = (claim) => {
+        this.#margin = claim;
+        return () => {
+            if (this.#margin === claim)
+                this.#margin = null;
+        };
+    };
+    /**
+     * A primary press from a mouse or a pen on the host's own area (its
+     * padding beside and below the blocks: never a block, its text or its
+     * chrome) while a margin gesture is registered (`sel.marquee`): offered
+     * to it before the trailing paragraph's press (`belowPress`), whose click
+     * the gesture gives back (`marginClick`). Classified with the chrome
+     * press in `events/onFocus.ts`. Answers whether the gesture took it.
+     * @internal
+     */
+    marginPress = (event) => {
+        this.claimed = false;
+        const claim = this.#margin;
+        const host = this.selection.edytor.node;
+        if (!claim || !host || event.target !== host || event.button !== 0)
+            return false;
+        if (event.pointerType === 'touch' || !claim(event))
+            return false;
+        this.claimed = true;
+        // WebKit's lone `mousedown` is the press itself (`isLonePress`).
+        if (event.type === 'mousedown')
+            event.preventDefault();
+        return true;
+    };
+    /**
+     * The compatibility `mousedown` of the press the margin gesture took:
+     * cancelled, so the browser places no caret, moves no focus and starts no
+     * native selection (the `mousedown`'s default actions; the `pointerdown` is
+     * left alone).
+     * @internal
+     */
+    marginMouse = (event) => {
+        if (this.claimed && event.button === 0)
+            event.preventDefault();
+    };
+    /**
+     * A margin press released where it began (a click, no drag): what the
+     * press does when no gesture takes it. Below the last block, the trailing
+     * paragraph (`nav.trailing.press`: no modifier, a view that writes);
+     * beside the blocks, the caret at the text point of that height nearest
+     * the host's edge, where the browser puts it. A click with a modifier
+     * keeps the selection.
+     * @internal
+     */
+    marginClick = (at) => {
+        const { edytor } = this.selection;
+        const host = edytor.node;
+        if (!host || at.shiftKey || at.altKey || at.metaKey || at.ctrlKey)
+            return;
+        if (this.#below(at.clientY)) {
+            if (edytor.dispatcher.permits())
+                this.#trailing();
+            return;
+        }
+        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);
+        if (!point)
+            return;
+        edytor.expectInternalFocus();
+        host.focus({ preventScroll: true });
+        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)) {
@@ -67,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
@@ -80,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) => {
@@ -99,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;
         }
@@ -147,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) => {
@@ -155,12 +249,13 @@ 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;
     };
     /** @internal */
     release = () => {
+        this.claimed = false;
         this.dragStart = null;
         this.#dropped();
     };
@@ -226,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) => {
@@ -240,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;
         }
@@ -248,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;

package/dist/selection/replaceSelection.js

@@ -1,9 +1,15 @@
 import { Text } from '../text/text.svelte.js';
 import { id, vetoable } from '../utils.js';
+import { blockSelection, noSelection } from '../session/selection.js';
 import { hidden, selectedMembers, shown } from './visibility.js';
-export const getSelectionReplacementState = (edytor) => {
-    const { startText, endText, yStart, yEnd, isCollapsed } = edytor.selection.state;
-    return { startText, endText, yStart, yEnd, isCollapsed };
+/**
+ * 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 const caretLeft = (edytor, result) => {
+    const { startText, yStart } = edytor.selection.textRange();
+    return result.status !== 'refused' && startText ? { text: startText, offset: yStart } : null;
 };
 /**
  * The selected blocks as clicked, in document order: a grip-selected list is
@@ -23,14 +29,18 @@ export const getSelectedBlocksInDocumentOrder = (edytor) => [...edytor.selection
  * the caret's block. Menus, the toolbar, kind commands and Tab read it.
  */
 export const getSelectionBlocks = (edytor) => {
-    const { selectedBlocks, state } = edytor.selection;
+    const { selectedBlocks, projection } = edytor.selection;
     if (selectedBlocks.size)
         return selectedMembers(edytor);
-    if (state.isCollapsed)
-        return state.startBlock ? [state.startBlock] : [];
-    const edges = [state.startBlock, state.endBlock];
-    const enters = (block) => block.isContainer && edges.some((edge) => edge && isInside(edge, block));
-    return state.blocks.filter((block) => !hidden(block) && !enters(block));
+    const { startText, endText } = edytor.selection.textRange(projection);
+    const [start, end] = [startText?.parent, endText?.parent];
+    if (projection.isCollapsed)
+        return start ? [start] : [];
+    const enters = (block) => block.isContainer && [start, end].some((edge) => edge?.isChildOf(block));
+    return projection.blocks.flatMap((id) => {
+        const block = edytor.idToBlock.get(id);
+        return block && !hidden(block) && !enters(block) ? [block] : [];
+    });
 };
 /**
  * The blocks <kbd>Mod</kbd>+<kbd>Enter</kbd> modifies (Notion): the
@@ -45,13 +55,6 @@ export const flipToggles = (blocks) => {
         if (node?.tagName === 'DETAILS')
             node.open = !node.open;
 };
-/** Whether `block` is a descendant of `ancestor`. */
-const isInside = (block, ancestor) => {
-    for (let parent = block.parent; parent; parent = parent.parent)
-        if (parent === ancestor)
-            return true;
-    return false;
-};
 /**
  * `blocks` with every layout they cover whole standing for it (as
  * Notion): a set holding every shown block of every column of a layout (each
@@ -170,28 +173,11 @@ export const movable = (blocks) => {
  */
 export const selectMoved = (edytor, moved, before) => {
     const held = [...before];
-    const kept = held.filter((block) => moved.some((root) => isInside(block, root)));
+    const kept = held.filter((block) => moved.some((root) => block.isChildOf(root)));
     // A layout moved for the blocks covering it whole stays selected as those blocks.
     const lifted = new Set(liftLayouts(kept));
     const roots = moved.filter((block) => !lifted.has(block) || held.includes(block));
-    edytor.selection.selectBlocks(...roots, ...kept);
-};
-/**
- * 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 const revealing = (blocks, move) => {
-    const had = new Map(blocks.map((block) => [block, block.children.length]));
-    const moved = move();
-    for (const block of moved) {
-        reveal(block);
-        if (block.children.length > (had.get(block) ?? Infinity))
-            open(block);
-    }
-    return moved;
+    edytor.selection.select(blockSelection([...roots, ...kept].map((block) => block.id)));
 };
 /** Open `block` when it is a closed toggle (`open` is view state). */
 const open = (block) => {
@@ -199,33 +185,41 @@ const open = (block) => {
         block.node.open = true;
 };
 /**
- * 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 const reveal = (block) => {
     for (let parent = block.parent; parent; parent = parent.parent)
         open(parent);
 };
-/**
- * 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 const revealed = (command) => function (...args) {
-    let out;
-    const moving = args[0]?.blocks ?? [this];
-    revealing(moving, () => [(out = command.apply(this, args)) ?? []].flat());
-    return out;
-};
-export const replaceSelectionWithCollapsedTarget = (edytor, state = getSelectionReplacementState(edytor)) => {
-    const { startText, yStart } = state;
-    if (!startText || state.isCollapsed) {
+export const replaceSelectionWithCollapsedTarget = (edytor, range) => {
+    const { startText, yStart } = range ?? edytor.selection.textRange();
+    if (!startText || (range ?? edytor.selection.projection).isCollapsed) {
         return startText && { text: startText, offset: yStart };
     }
-    const [text, offset] = edytor.deleteContentWithinSelection({ replace: true, selection: state }) ?? [];
-    return text ? { text, offset: offset } : null;
+    return deleteRange(edytor, true, range);
+};
+/**
+ * The document's range deletion of the selected range (or `selection`,
+ * `del.range.*`; `replace`: the deletion half of a replacement, the head
+ * kept), which selects its caret. Answers that caret; refused by the
+ * document, the range's start; by the view or a hook, none.
+ */
+const deleteRange = (edytor, replace, selection) => {
+    const { startText, endText, yStart, yEnd } = selection ?? edytor.selection.textRange();
+    if (!startText || !endText)
+        return null;
+    const at = (text, offset) => ({
+        block: text.parent.id,
+        offset: text.segStart + offset
+    });
+    const [from, to] = [at(startText, yStart), at(endText, yEnd)];
+    const result = replace ? edytor.replaceRange(from, to) : edytor.deleteRange(from, to);
+    if (result.status === 'refused')
+        return result.reason === 'view' ? null : { text: startText, offset: yStart };
+    return caretLeft(edytor, result);
 };
 /**
  * The first or last text `block` shows: its own line's (a block selection is
@@ -235,7 +229,7 @@ export const replaceSelectionWithCollapsedTarget = (edytor, state = getSelection
  * 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 const shownText = (block, edge, whole = false) => {
@@ -346,8 +340,8 @@ export const deleteSelectedBlocks = (edytor, blocks = selectedMembers(edytor)) =
             ...beside(blocks[0], 'blockBefore', blocks),
             ...beside(blocks.at(-1), 'blockAfter', blocks)
         ];
-    const deleted = edytor.dispatcher.caret(at?.text, at?.offset ?? 0, () => edytor.deleteBlocks({ blocks }));
-    if (!deleted)
+    const deleted = edytor.dispatcher.caret(at?.text, at?.offset ?? 0, () => edytor.deleteBlocks(blocks.map((block) => block.id)));
+    if (deleted?.status !== 'applied')
         return null;
     edytor.announcer.deleted(what);
     if (at)
@@ -362,7 +356,7 @@ export const deleteSelectedBlocks = (edytor, blocks = selectedMembers(edytor)) =
     if (text)
         edytor.dispatcher.caret(text, 0);
     else if (survivor)
-        edytor.selection.selectBlocks(survivor);
+        edytor.selection.select(blockSelection([survivor.id]));
     return text ?? null;
 };
 /**
@@ -383,9 +377,9 @@ const beside = (from, step, blocks) => {
 };
 /** Delete the selected range (or `selection`) as Backspace does (`del.range.*`), then its caret. */
 export const deleteSelectedRange = (edytor, payload = {}) => {
-    const [text, offset] = edytor.deleteContentWithinSelection(payload) ?? [];
-    if (text)
-        edytor.selection.setAtTextOffset(text, offset);
+    const at = deleteRange(edytor, false, payload.selection);
+    if (at)
+        edytor.selection.selectText(at.text, at.offset);
 };
 /**
  * Typing or a composition over a block selection (`flow.slot`),
@@ -398,14 +392,11 @@ const replaceSelectedBlocksWithEmptyBlock = (edytor) => {
     const parent = selected[0]?.parent;
     if (!parent || keepsSelectedBlocks(edytor, selected))
         return null;
-    const [text, offset] = edytor.insertFlow({
-        flow: { lines: [{ id: id('b'), type: edytor.defaultChild(parent) }] },
-        target: { replace: selected.map((block) => block.id) }
-    });
-    if (!text)
+    const at = caretLeft(edytor, edytor.insertFlow({ replace: selected.map((block) => block.id) }, { lines: [{ id: id('b'), type: edytor.defaultChild(parent) }] }));
+    if (!at)
         return null;
-    edytor.selection.selectBlocks();
-    return { text, offset };
+    edytor.selection.select(noSelection);
+    return at;
 };
 /** Where typed text lands: over selected blocks, one empty block in their place; else the range replaced. */
 export const replaceSelectionForInsertion = (edytor, state) => edytor.selection.selectedBlocks.size