edytor 1.0.0-rc.3 → 2.0.0

package/dist/selection/selection.svelte.js

@@ -1,31 +1,16 @@
 import { Text } from '../text/text.svelte.js';
-import { climbDom, getElementFromNode, getInlineBlockOfNode, getInlineBlockInSelectedRange, getRangesFromSelection, getTextOfNode, getTextsInSelection, getYIndex, getMarkEdgeSide, isTextBoundSelectionPoint, normalizeUtf16Boundary, SYNTHETIC_TEXT_OVERLAY_SELECTOR } from './selection.utils.js';
-import { clearDomSelection, getActiveElement, getDomSelectionSnapshot } from './domSelection.js';
-import { Block } from '../block/block.svelte.js';
+import { getElementFromNode, getInlineBlockOfNode, getInlineBlockInSelectedRange, getTextOfNode, getYIndex, getMarkEdgeSide, offsetIn, ordered, isTextBoundSelectionPoint, normalizeUtf16Boundary, SYNTHETIC_TEXT_OVERLAY_SELECTOR } from './selection.utils.js';
+import { clearDomSelection, createDomRange, getActiveElement } from './domSelection.js';
+import { getDomSelectionSnapshot } from './domSelection.js';
 import { SvelteSet } from 'svelte/reactivity';
 import { InlineBlock } from '../block/inlineBlock.svelte.js';
-import { isNativeFormControl, isNestedForeignEditableTarget } from '../events/nativeInteractiveControl.js';
-import { atomSelection, blockSelection, noSelection, project, sameValue, segmentsOf, serialize, textSelection } from '../session/selection.js';
+import { isKindControl, isNativeInteractiveControl, isOwnPoint } from '../events/nativeInteractiveControl.js';
+import { atomSelection, blockSelection, noSelection, project, sameEnds, sameValue, serialize, textSelection } from '../session/selection.js';
 import { seam } from '../crdt/anchors.js';
 import { landed } from '../session/navigation.js';
 import * as visibility from './visibility.js';
 import { SelectionPointer } from './pointer.svelte.js';
 import { caretBeside, shownText } from './replaceSelection.js';
-/** The compatibility state of no (or an unresolvable) selection. */
-const EMPTY_STATE = Object.freeze({
-    yStart: 0,
-    yEnd: 0,
-    isCollapsed: true,
-    isReversed: false,
-    texts: [],
-    blocks: [],
-    startText: null,
-    endText: null,
-    startBlock: null,
-    endBlock: null,
-    isBlockSpanning: false,
-    isVoidEditableElement: false
-});
 /**
  * Whether a DOM selection runs backward (focus before anchor in document
  * order), comparing boundary points — a focus on an ancestor element of the
@@ -38,7 +23,7 @@ export const isBackward = (selection) => {
     if (anchorNode === focusNode)
         return selection.focusOffset < selection.anchorOffset;
     try {
-        const range = (anchorNode.ownerDocument ?? document).createRange();
+        const range = createDomRange(anchorNode);
         range.setStart(anchorNode, selection.anchorOffset);
         return range.comparePoint(focusNode, selection.focusOffset) < 0;
     }
@@ -46,66 +31,42 @@ export const isBackward = (selection) => {
         return Boolean(anchorNode.compareDocumentPosition(focusNode) & Node.DOCUMENT_POSITION_PRECEDING);
     }
 };
-const getSyntheticTextOverlayElement = (node, offset) => {
-    let syntheticOverlay = null;
-    climbDom(node, (currentNode) => {
-        if (currentNode instanceof HTMLElement &&
-            currentNode.matches(SYNTHETIC_TEXT_OVERLAY_SELECTOR)) {
-            syntheticOverlay = currentNode;
-            return true;
-        }
-    });
-    if (syntheticOverlay || !(node instanceof Element)) {
-        return syntheticOverlay;
-    }
-    for (const boundaryNode of [node.childNodes[offset], node.childNodes[offset - 1]]) {
-        if (!(boundaryNode instanceof HTMLElement)) {
+/** A text suggestion's preview at a DOM point: around it, or the child at either side of it. */
+const overlayAt = (node, offset) => {
+    const own = getElementFromNode(node)?.closest(SYNTHETIC_TEXT_OVERLAY_SELECTOR);
+    if (own || !(node instanceof Element))
+        return own ?? null;
+    for (const child of [node.childNodes[offset], node.childNodes[offset - 1]]) {
+        if (!(child instanceof HTMLElement))
             continue;
-        }
-        if (boundaryNode.matches(SYNTHETIC_TEXT_OVERLAY_SELECTOR)) {
-            return boundaryNode;
-        }
-        const descendant = boundaryNode.querySelector(SYNTHETIC_TEXT_OVERLAY_SELECTOR);
-        if (descendant) {
-            return descendant;
-        }
+        if (child.matches(SYNTHETIC_TEXT_OVERLAY_SELECTOR))
+            return child;
+        const inner = child.querySelector(SYNTHETIC_TEXT_OVERLAY_SELECTOR);
+        if (inner)
+            return inner;
     }
     return null;
 };
-const getInlineBlockBetweenBoundaryTexts = (startText, endText, yStart, yEnd) => {
-    if (!endText || startText.parent !== endText.parent) {
-        return null;
-    }
-    if (yStart !== startText.length || yEnd !== 0) {
-        return null;
-    }
-    const content = startText.parent.content;
-    const startIndex = content.indexOf(startText);
-    const endIndex = content.indexOf(endText);
-    if (startIndex === -1 || endIndex === -1 || endIndex <= startIndex) {
+/** The one inline atom between the end of `start` and the start of `end`, in one block. */
+const atomBetween = (start, end, yStart, yEnd) => {
+    if (!end || start.parent !== end.parent || yStart !== start.length || yEnd !== 0)
         return null;
-    }
-    const selectedParts = content.slice(startIndex + 1, endIndex);
-    return selectedParts.length === 1 && selectedParts[0] instanceof InlineBlock
-        ? selectedParts[0]
-        : null;
+    const content = start.parent.content;
+    const [from, to] = [content.indexOf(start), content.indexOf(end)];
+    const part = from !== -1 && to === from + 2 ? content[from + 1] : null;
+    return part instanceof InlineBlock ? part : null;
 };
 /**
- * Where a range over `block` starts (`first`) or ends (`last`): its first or
- * last shown line (a list's items, a code block's lines). A block that
- * shows none (a divider) passes to its neighbours as a caret does, the next
- * line first; to `cover` it, a start passes to the line before it and an end
- * to the line after it, so the range still holds it — when a line lies on
- * that side: a divider with none beyond it (it starts or ends the
- * document, or only dividers follow to that edge) is left out.
+ * Where a range ending in `block` starts (`first`) or ends (`last`): its
+ * first or last shown line (a list's items, a code block's lines); a block
+ * that shows none (a divider) passes to its neighbours as a caret does, the
+ * next line first.
  */
-const rangeEdge = (block, edge, cover = false) => {
+const rangeEdge = (block, edge) => {
     const text = shownText(block, edge);
     if (text)
         return { text, offset: edge === 'first' ? 0 : text.length };
-    const before = cover && edge === 'first';
-    return (caretBeside(block, before ? 'blockBefore' : 'blockAfter') ??
-        caretBeside(block, before ? 'blockAfter' : 'blockBefore'));
+    return caretBeside(block, 'blockAfter') ?? caretBeside(block, 'blockBefore');
 };
 /** One block's membership of the selected and focused sets, as its own two signals. */
 class Membership {
@@ -154,12 +115,9 @@ export class EdytorSelection {
      * @internal
      */
     expectHistoryRestore = false;
-    /** A primary press in the host on a text, until its release (reactive: the chrome reads `dragging`). */
     /** @internal The selection under a pointer: a press, its drag and its release. */
     pointer = new SelectionPointer(this);
-    selectionDocument = null;
-    shouldKeepModelSelectionForNextTextInsertion = false;
-    modelSelectionPreservationBlock = null;
+    #document = null;
     /**
      * The selection: a value — none, a text range of two anchors,
      * one inline atom, or a set of block ids. Read-only: only `select()`
@@ -181,12 +139,12 @@ export class EdytorSelection {
     scrollOnDisplay = false;
     /** @internal The intent serial (gestures but `input`) when the last display was requested. */
     requestSerial = 0;
-    /** @internal Why the last `select()` ran. */
-    cause = 'model';
-    /** DOM fields (Surface) observed with the value they describe. */
-    /** The mark-edge side a display or a DOM derive observed the value with. */
+    /**
+     * DOM fields (Surface) observed with the value they describe: the
+     * mark-edge side a display or a DOM derive observed it with, and whether
+     * a DOM derive read it from a node-bound native range.
+     */
     #surface = null;
-    #compat = new WeakMap();
     constructor(edytor, edytorOnSelectionChange) {
         this.edytorOnSelectionChange = edytorOnSelectionChange;
         this.edytor = edytor;
@@ -197,74 +155,43 @@ export class EdytorSelection {
         return project(this.value, this.edytor.facade);
     }
     /**
-     * The read-only wrapper view of the projection: every field is a
-     * projection of (value, document version); `edge` comes from the Surface
-     * for the value it was observed with.
+     * The text segment and the offset in it that a projection point shows
+     * (`block.textAtOffset`, the one offset → segment mapper).
+     * @internal
      */
-    get state() {
-        const projection = this.projection;
-        const surface = this.#surface?.value === this.value ? this.#surface : null;
-        const hit = this.#compat.get(projection);
-        if (hit && hit.surface === surface)
-            return hit.state;
-        const state = this.#view(this.value, projection, surface?.edge);
-        this.#compat.set(projection, { surface, state });
-        return state;
-    }
-    #textOf = (block, segment) => {
-        if (segment?.kind !== 'text')
-            return null;
-        return this.edytor.idToBlock.text(block.id, segment.segOrd);
-    };
-    #view = (value, projection, edge) => {
-        const { start, end } = projection;
-        const blockOf = (id) => this.edytor.idToBlock.get(id) ?? null;
-        const startBlock = start && blockOf(start.block);
-        const endBlock = end && blockOf(end.block);
-        if (!start || !end || !startBlock || !endBlock)
-            return EMPTY_STATE;
-        let parts = projection.segments;
-        if (value.kind === 'atom') {
-            const all = segmentsOf(this.edytor.facade, start.block);
-            const index = all.findIndex((part) => part.kind === 'inline' && part.id === value.atomId);
-            parts = all.slice(index - 1, index + 2);
-        }
-        const segments = parts.filter((part) => part.kind === 'text');
-        const [startSegment, endSegment] = [segments[0], segments.at(-1)];
-        const startText = this.#textOf(startBlock, startSegment);
-        const endText = this.#textOf(endBlock, endSegment);
-        if (!startText || !endText || !startSegment || !endSegment)
-            return EMPTY_STATE;
-        const texts = segments.flatMap((part) => {
-            const block = blockOf(part.block);
-            return (block && this.#textOf(block, part)) ?? [];
-        });
-        const blocks = value.kind === 'blocks'
-            ? value.ids
-                .filter((id) => this.edytor.facade.isVisibleBlock(id))
-                .sort((a, b) => this.edytor.facade.compare(a, b))
-                .flatMap((id) => blockOf(id) ?? [])
-            : projection.blocks.flatMap((id) => blockOf(id) ?? []);
-        const node = this.edytor.node;
-        return Object.defineProperty({
-            yStart: start.offset - startSegment.start,
-            yEnd: end.offset - endSegment.start,
-            isCollapsed: projection.isCollapsed,
-            isReversed: projection.isReversed,
-            isBlockSpanning: projection.isBlockSpanning,
-            texts,
-            blocks,
-            edge,
-            startText,
-            endText,
-            startBlock,
-            endBlock
-        }, 'isVoidEditableElement', {
-            enumerable: true,
-            get: () => projection.voidRoot !== null &&
-                ['INPUT', 'TEXTAREA'].includes(getActiveElement(node)?.tagName.toUpperCase() ?? '')
-        });
+    textAt = (point) => (point && this.edytor.idToBlock.get(point.block)?.textAtOffset(point.offset)) || null;
+    /**
+     * A projection's endpoints in text segments (`textAt`) and the texts it
+     * covers (an atom's: the texts on its two sides): what the text-handle
+     * operations take.
+     * @internal
+     */
+    textRange = (projection = this.projection) => {
+        const start = this.textAt(projection.start);
+        const end = this.textAt(projection.end);
+        const handles = this.edytor.idToBlock;
+        const texts = projection.kind === 'atom'
+            ? [start, end].flatMap((at) => (at ? [at.text] : []))
+            : projection.segments.flatMap((part) => part.kind === 'text' && handles.has(part.block)
+                ? [handles.text(part.block, part.segOrd)]
+                : []);
+        return {
+            startText: start?.text ?? null,
+            yStart: start?.offset ?? 0,
+            endText: end?.text ?? null,
+            yEnd: end?.offset ?? 0,
+            texts
+        };
     };
+    /** @internal The mark-edge side the DOM showed the current caret with (`marksForInsertion`). */
+    get edge() {
+        return this.#surface?.value === this.value ? this.#surface.edge : undefined;
+    }
+    /** @internal Focus is in a void block's own `input` or `textarea`. */
+    get voidField() {
+        const tag = getActiveElement(this.edytor.node)?.tagName.toUpperCase();
+        return this.projection.voidRoot !== null && (tag === 'INPUT' || tag === 'TEXTAREA');
+    }
     /**
      * Replace the selection with `next` (none, a text range of two anchors,
      * one inline atom, or a set of block ids), keeping the selected and
@@ -291,37 +218,29 @@ export class EdytorSelection {
             this.edytor.surface.update();
         else if (cause !== 'dom')
             this.display();
-        this.cause = cause;
         if (surface)
             this.#surface = { value, ...surface };
         const projection = project(value, this.edytor.facade);
-        const blockOf = (id) => this.edytor.idToBlock.get(id);
-        const selected = value.kind === 'blocks'
-            ? value.ids
-                .filter((id) => this.edytor.facade.isVisibleBlock(id))
-                .flatMap((id) => blockOf(id) ?? [])
-            : [];
-        const atom = value.kind === 'atom'
-            ? blockOf(value.blockId)?.content.find((part) => part instanceof InlineBlock && part.id === value.atomId)
+        const blocksOf = (ids) => ids.flatMap((id) => this.edytor.idToBlock.get(id) ?? []);
+        const atom = value.kind === 'atom' && projection.start
+            ? this.edytor.idToBlock.atom(value.blockId, value.atomId)
             : undefined;
-        const focused = value.kind === 'text'
-            ? projection.blocks.flatMap((id) => blockOf(id) ?? [])
+        this.#sync(this.#selected, value.kind === 'blocks' ? blocksOf(value.ids) : [], 'selected');
+        this.#sync(this.#focused, value.kind === 'text'
+            ? blocksOf(projection.blocks)
             : value.kind === 'atom'
-                ? [blockOf(value.blockId) ?? []].flat()
-                : [];
-        this.#sync(this.#selected, selected, 'selected');
-        this.#sync(this.#focused, focused, 'focused');
+                ? blocksOf([value.blockId])
+                : [], 'focused');
         if (atom !== this.inlineBlockDeletionTarget || (!atom && this.selectedInlineBlock.size)) {
             this.selectedInlineBlock.clear();
             if (atom)
                 this.selectedInlineBlock.add(atom);
             this.inlineBlockDeletionTarget = atom ?? null;
         }
-        const state = this.state;
         this.edytor.history?.selected(value);
-        if (state.startText) {
-            this.#lastText = state.startText;
-            this.#lastBlock = state.startBlock?.id ?? null;
+        const start = this.textAt(projection.start);
+        if (start) {
+            this.#lastText = start.text;
         }
         if (!changed)
             return;
@@ -355,7 +274,7 @@ export class EdytorSelection {
     setCaret = (caret) => {
         const at = caret && caret.block.textAtOffset(Math.max(0, caret.offset));
         if (at)
-            this.setAtTextOffset(at.text, at.offset);
+            this.selectText(at.text, at.offset);
     };
     /** The marks the next insertion at the caret takes (values kept). */
     get pending() {
@@ -410,9 +329,8 @@ export class EdytorSelection {
         const prev = this.value;
         if (prev.kind !== 'text' || !prev.pending || next.kind !== 'text' || 'pending' in next)
             return next;
-        const [a, b] = [project(prev, this.edytor.facade), project(next, this.edytor.facade)];
-        const at = (p, q) => p !== null && q !== null && p.block === q.block && p.offset === q.offset;
-        return at(a.start, b.start) && at(a.end, b.end)
+        const a = project(prev, this.edytor.facade);
+        return a.start && sameEnds(a, project(next, this.edytor.facade))
             ? textSelection(next.anchor, next.focus, prev.pending)
             : next;
     };
@@ -482,15 +400,40 @@ export class EdytorSelection {
         return isReversed ? textSelection(end, start) : textSelection(start, end);
     };
     /**
-     * A write's intent: `textValue` minted from each text's block record,
-     * live or not — the atoms of a text that died to a merge live on in the
-     * block that claimed them, so resolution follows them before any seam.
+     * Select from `yStart` of `startText` to `yEnd` of `endText` (a caret by
+     * default; endpoints in document order, `isReversed` makes the end the
+     * anchor; offsets clamped to each text). The anchors are minted now from
+     * each text's block record, live or not — the atoms of a text that died
+     * to a merge live on in the block that claimed them, so resolution follows
+     * them — else the selection lands at the seam of the start's block. The
+     * projector displays it after the flush.
+     * @internal
      */
-    #intent = (startText, yStart, endText = startText, yEnd = yStart, isReversed = false) => this.textValue(startText, yStart, endText, yEnd, isReversed, undefined, (text, at, side) => {
-        return text.parent.isRoot
+    selectText = (startText, yStart, endText = startText ?? null, yEnd = yStart, isReversed = false) => {
+        if (!startText || !endText)
+            return;
+        const at = (text, offset) => Math.min(Math.max(offset, 0), text.length);
+        const value = this.textValue(startText, at(startText, yStart), endText, at(endText, yEnd), isReversed, undefined, (text, offset, side) => text.parent.isRoot
             ? null
-            : this.edytor.facade.anchorAt(text.blockId, text.segStart + at, side);
-    });
+            : this.edytor.facade.anchorAt(text.blockId, text.segStart + offset, side));
+        const target = project(value, this.edytor.facade).start
+            ? value
+            : this.#seamValue(startText.parent?.id ?? null);
+        if (target)
+            this.select(target);
+    };
+    /**
+     * Select `block`'s lines (Mod+A, a triple click): from its first shown
+     * line's start to its last's end (a list's items, a code block's lines),
+     * the start bound left so text typed before it stays inside. A block that
+     * shows no line keeps the current value.
+     * @internal
+     */
+    selectLines = (block) => {
+        const [first, last] = block ? [shownText(block, 'first'), shownText(block, 'last')] : [];
+        if (first && last)
+            this.select(this.textValue(first, 0, last, last.length, false, 'left'));
+    };
     /** @internal Ask the projector to display the current value after the flush. */
     display = () => {
         this.scrollOnDisplay =
@@ -500,7 +443,7 @@ export class EdytorSelection {
     };
     /** @internal The mark-edge side a display showed the current value with. */
     observed = (surface) => {
-        this.#surface = { value: this.value, ...surface };
+        this.#surface = { value: this.value, nodeBound: this.hasNativeNodeSelection(), ...surface };
     };
     /**
      * A pointer drag is in progress (a press in the host, until its release):
@@ -511,137 +454,41 @@ export class EdytorSelection {
     get dragging() {
         return this.pointer.dragging;
     }
-    getBlockByPath = (path) => {
-        if (!path?.length) {
-            return null;
-        }
-        let block = this.edytor.root;
-        for (const index of path) {
-            block = block?.children[index];
-        }
-        return block ?? null;
-    };
     /** @internal */
     destroy = () => {
-        if (this.selectionDocument) {
-            this.selectionDocument.removeEventListener('selectionchange', this.onSelectionChange);
-            this.selectionDocument = null;
-        }
+        this.#document?.removeEventListener('selectionchange', this.onSelectionChange);
+        this.#document = null;
     };
     /**
-     * `selectedInlineBlock` and `inlineBlockDeletionTarget` are one
-     * selection — every mutation must go through these two helpers so the
-     * armed Backspace/delete target can never outlive the cleared set
-     * (a stale target feeds `deleteSelectedInlineBlock` and makes
-     * `restoreSelectionAfterRepair` bail forever).
+     * Leave an atom selection: a caret at the atom's start (the end of the
+     * text before it), else none. `selectedInlineBlock` and
+     * `inlineBlockDeletionTarget` follow the value (`commit`).
      */
     clearInlineBlockSelection = () => {
         const value = this.value;
         if (value.kind !== 'atom')
             return;
-        // Leaving the atom: a caret at its start (the end of the text before it).
-        const atom = this.edytor.idToBlock
-            .get(value.blockId)
-            ?.content.find((part) => part instanceof InlineBlock && part.id === value.atomId);
-        const before = atom?.parent.content[atom.parent.content.indexOf(atom) - 1];
-        this.select(before instanceof Text ? this.textValue(before, before.length) : noSelection);
+        const { start } = this.projection;
+        const before = start && this.textAt(start);
+        this.select(before ? this.textValue(before.text, before.offset) : noSelection);
     };
     selectInlineBlock = (inlineBlock, from = 'before') => {
         this.select(atomSelection(inlineBlock.parent.id, inlineBlock.id, from));
     };
     /** @internal */
-    clearModelSelectionPreservation = () => {
-        this.shouldKeepModelSelectionForNextTextInsertion = false;
-        this.modelSelectionPreservationBlock = null;
-    };
-    isStateBlockContentRange = (block) => Boolean(!this.state.isCollapsed &&
-        this.state.startBlock === block &&
-        this.state.endBlock === block &&
-        this.state.startText === block.firstText &&
-        this.state.endText === block.lastText &&
-        this.state.yStart === 0 &&
-        this.state.yEnd === block.lastText.length);
-    /** @internal */
-    consumeModelSelectionPreservationForTextInsertion = () => {
-        const preservedBlock = this.modelSelectionPreservationBlock;
-        const shouldKeepPreservedBlock = this.shouldKeepModelSelectionForNextTextInsertion &&
-            preservedBlock instanceof Block &&
-            this.getBlockByPath(preservedBlock.path) === preservedBlock;
-        const shouldKeepSelection = shouldKeepPreservedBlock ||
-            (this.shouldKeepModelSelectionForNextTextInsertion &&
-                this.state.startBlock instanceof Block &&
-                this.isStateBlockContentRange(this.state.startBlock));
-        if (shouldKeepPreservedBlock) {
-            this.setStateFromBlockContentRange(preservedBlock);
-        }
-        this.shouldKeepModelSelectionForNextTextInsertion = false;
-        this.modelSelectionPreservationBlock = null;
-        return shouldKeepSelection;
-    };
-    /** @internal */
     getTextOfNode = getTextOfNode.bind(this);
-    /** @internal */
-    getTextsInSelection = getTextsInSelection.bind(this);
-    /** @internal */
-    getInlineBlockOfNode = getInlineBlockOfNode.bind(this);
-    /** @internal */
-    getInlineBlockInSelectedRange = getInlineBlockInSelectedRange.bind(this);
     /** @internal The block whose element holds `node`, in this editor. */
     getBlockOfNode = (node) => {
-        const element = getElementFromNode(node);
-        const blockElement = element?.closest('[data-edytor-block]');
-        if (!(blockElement instanceof HTMLElement) || !this.edytor.node?.contains(blockElement)) {
-            return null;
-        }
-        const id = blockElement.dataset.edytorId;
-        return id ? (this.edytor.idToBlock.get(id) ?? null) : null;
-    };
-    getNonNativeEditableIslandBlock = (node) => {
-        const element = getElementFromNode(node);
-        const island = element?.closest('[contenteditable="false"]');
-        if (!(island instanceof HTMLElement) || !this.edytor.node?.contains(island)) {
-            return null;
-        }
-        if (island.closest('input, textarea, select, button, a[href]')) {
-            return null;
-        }
-        return this.getBlockOfNode(island);
-    };
-    normalizeTextRangePoints = (startText, startOffset, endText, endOffset, isReversed) => {
-        const clampedStart = Math.min(Math.max(startOffset, 0), startText.length);
-        const clampedEnd = Math.min(Math.max(endOffset, 0), endText.length);
-        const order = startText === endText
-            ? clampedStart - clampedEnd
-            : startText.parent === endText.parent
-                ? startText.index - endText.index
-                : this.edytor.compareBlocks(startText.parent, endText.parent);
-        if (order <= 0) {
-            return {
-                startText,
-                startOffset: clampedStart,
-                endText,
-                endOffset: clampedEnd,
-                isReversed: order === 0 ? false : isReversed
-            };
-        }
-        return {
-            startText: endText,
-            startOffset: clampedEnd,
-            endText: startText,
-            endOffset: clampedStart,
-            // Text atoms never reorder inside one text. Undo can nevertheless
-            // resolve the two deleted-boundary anchors on opposite sides of
-            // their restored atoms. Sort those offsets without changing the
-            // selection direction stored independently in the snapshot.
-            isReversed: startText === endText ? isReversed : !isReversed
-        };
+        const element = getElementFromNode(node)?.closest('[data-edytor-block]');
+        const id = element && this.edytor.node?.contains(element) && element.dataset.edytorId;
+        return (id && this.edytor.idToBlock.get(id)) || null;
     };
     /** @internal */
     init = () => {
-        if (typeof document !== 'undefined') {
-            this.selectionDocument = this.edytor.node?.ownerDocument ?? document;
-            this.selectionDocument.addEventListener('selectionchange', this.onSelectionChange);
-        }
+        if (typeof document === 'undefined')
+            return;
+        this.#document = this.edytor.node?.ownerDocument ?? document;
+        this.#document.addEventListener('selectionchange', this.onSelectionChange);
     };
     /**
      * The block selection value over which the DOM caret was put — a primary
@@ -684,73 +531,48 @@ export class EdytorSelection {
         // A block selection ignores the DOM, but the one a drag across columns made while it lasts.
         if (this.selectedBlocks.size > 0 && !(this.dragging && this.pointer.across))
             return;
+        // A selection in a kind's own control (a form control, a nested
+        // editable island) or a focused one belongs to it, not the model —
+        // deriving it would map the caret into the control's host text and
+        // corrupt the next model-routed write. Both endpoints are checked: a
+        // range anchored in host text but focused inside an island must not
+        // resolve either.
         const container = this.edytor.node;
-        if (!selection?.anchorNode ||
-            !selection.focusNode ||
-            !container?.contains(selection.anchorNode) ||
-            !container.contains(selection.focusNode)) {
-            return;
-        }
-        const activeElement = getActiveElement(this.edytor.node);
-        if (activeElement instanceof Element &&
-            this.edytor.node?.contains(activeElement) &&
-            isNativeFormControl(activeElement)) {
+        const read = this.#read(selection);
+        if (!selection || !read || isKindControl(container, getActiveElement(container)))
             return;
-        }
-        // A selection inside a nested foreign editable belongs to the
-        // island, not the model — deriving it would map the caret into the
-        // island's host text and corrupt the next model-routed write. Both
-        // endpoints are checked: a range anchored in host text but focused
-        // inside an island must not resolve either.
-        if (isNestedForeignEditableTarget(this.edytor.node, selection.anchorNode) ||
-            isNestedForeignEditableTarget(this.edytor.node, selection.focusNode)) {
-            return;
-        }
-        const { anchorNode, focusNode, anchorOffset, focusOffset } = selection;
-        const isCollapsed = selection.isCollapsed;
+        const { anchorNode, focusNode, isCollapsed } = selection;
         // A native vertical move that landed on no caret stop takes the key's line stop.
         if (isCollapsed &&
             !isTextBoundSelectionPoint(anchorNode) &&
-            !this.getInlineBlockOfNode(anchorNode) &&
+            !getInlineBlockOfNode(this.edytor, anchorNode) &&
             landed(this.edytor))
             return;
-        const ranges = getRangesFromSelection(selection);
-        const isReversed = isBackward(selection);
-        const startNode = isReversed ? focusNode : anchorNode;
-        const endNode = isReversed ? anchorNode : focusNode;
-        const start = isReversed ? focusOffset : anchorOffset;
-        const end = isReversed ? anchorOffset : focusOffset;
-        const selectedInlineBlock = this.getInlineBlockInSelectedRange(ranges[0]);
-        const selectionParts = selectedInlineBlock
-            ? { startText: null, endText: null, inlineBlock: selectedInlineBlock }
-            : this.getTextsInSelection(startNode, endNode, start, end);
-        let { startText, endText, inlineBlock } = selectionParts;
+        const { isReversed, startNode, start, endNode, end } = read;
+        const atom = getInlineBlockInSelectedRange(this.edytor, selection.rangeCount ? selection.getRangeAt(0) : undefined);
+        const startText = atom ? null : this.getTextOfNode(startNode, start);
+        let endText = startText && this.getTextOfNode(endNode, end);
         if (!startText) {
-            const islandBlock = this.getNonNativeEditableIslandBlock(startNode);
-            if (islandBlock?.firstText) {
-                return this.setAtTextOffset(islandBlock.firstText, 0);
-            }
+            const inlineBlock = atom ?? getInlineBlockOfNode(this.edytor, startNode);
+            // A press in a non-native editable island (contenteditable=false, no control).
+            const island = getElementFromNode(startNode)?.closest('[contenteditable="false"]');
+            const islandBlock = island && !isNativeInteractiveControl(island) && this.getBlockOfNode(island);
+            if (islandBlock && islandBlock.firstText)
+                return this.selectText(islandBlock.firstText, 0);
             // A point on a white space node: the model caret is displayed again.
-            if (this.state.startText && !inlineBlock) {
-                this.display();
-                return;
-            }
-            else {
-                clearDomSelection(this.edytor.node);
-                if (inlineBlock) {
-                    this.selectInlineBlock(inlineBlock);
-                }
-                else {
-                    this.clearInlineBlockSelection();
-                }
-                return;
-            }
+            if (!inlineBlock && this.textAt(this.projection.start))
+                return this.display();
+            clearDomSelection(this.edytor.node);
+            if (inlineBlock)
+                this.selectInlineBlock(inlineBlock);
+            else
+                this.clearInlineBlockSelection();
+            return;
         }
-        const syntheticOverlay = isCollapsed ? getSyntheticTextOverlayElement(startNode, start) : null;
-        if (syntheticOverlay) {
-            const overlayBlock = this.getBlockOfNode(syntheticOverlay);
-            const targetText = overlayBlock?.lastText ?? startText;
-            return this.setAtTextOffset(targetText, targetText.length);
+        const overlay = isCollapsed ? overlayAt(startNode, start) : null;
+        if (overlay) {
+            const text = this.getBlockOfNode(overlay)?.lastText ?? startText;
+            return this.selectText(text, text.length);
         }
         const rawYStart = getYIndex(startText, startNode, start);
         const rawYEnd = isCollapsed ? rawYStart : getYIndex(endText, endNode, end);
@@ -760,77 +582,62 @@ export class EdytorSelection {
             : endText
                 ? normalizeUtf16Boundary(endText.stringContent, rawYEnd, 'forward')
                 : rawYEnd;
-        let shouldRestoreNormalizedDomRange = yStart !== rawYStart || yEnd !== rawYEnd;
+        // An empty native range reads as a caret; the DOM is normalized to one.
+        let restore = yStart !== rawYStart ||
+            yEnd !== rawYEnd ||
+            (!isCollapsed && startText === endText && yStart === yEnd);
         if (!isCollapsed &&
             endText &&
             startText.parent !== endText.parent &&
             endText === endText.parent.firstText &&
             yEnd === 0) {
             // The shown block before: a closed toggle's header, not its hidden body.
-            const previousEndText = visibility.shown(endText.parent, 'blockBefore')?.lastText ?? null;
-            if (previousEndText?.node?.isConnected) {
-                endText = previousEndText;
-                yEnd = previousEndText.length;
-                shouldRestoreNormalizedDomRange = true;
+            const previous = visibility.shown(endText.parent, 'blockBefore')?.lastText ?? null;
+            if (previous?.node?.isConnected) {
+                endText = previous;
+                yEnd = previous.length;
+                restore = true;
             }
         }
-        if (!isCollapsed && startText === endText && yStart === yEnd) {
-            // An empty native range reads as a caret; the DOM is normalized to one.
-            shouldRestoreNormalizedDomRange = true;
-        }
-        if (startText?.parent.isEmpty && yStart > startText.length) {
-            // In case the placeholder or suggestion is not absolutely positioned, we need to set the selection to the start of the text because caret may be placed after the placeholder which is deceptive
-            return this.setAtTextOffset(startText, startText.length);
+        if (startText.parent.isEmpty && yStart > startText.length) {
+            // A caret after a placeholder or suggestion that is not absolutely positioned: its text's end.
+            return this.selectText(startText, startText.length);
         }
-        const inlineBlockSelectedByBoundaryRange = getInlineBlockBetweenBoundaryTexts(startText, endText, yStart, yEnd);
-        if (inlineBlockSelectedByBoundaryRange) {
+        const between = atomBetween(startText, endText, yStart, yEnd);
+        if (between) {
             clearDomSelection(this.edytor.node);
-            this.selectInlineBlock(inlineBlockSelectedByBoundaryRange, isReversed ? 'after' : 'before');
+            this.selectInlineBlock(between, isReversed ? 'after' : 'before');
             return;
         }
-        this.commit(this.textValue(startText, yStart, endText ?? startText, yEnd, isReversed), 'dom', {
-            edge: isCollapsed ? getMarkEdgeSide(startText, startNode, yStart) : undefined
+        const value = this.textValue(startText, yStart, endText ?? startText, yEnd, isReversed);
+        // A node-bound native range (endpoints outside text elements: a block
+        // node selection, a stray boundary node) is the shape engines extend
+        // their own way. They normalize it into text points asynchronously,
+        // so a keydown may find the DOM no longer node-bound: the same value
+        // derived again keeps the fact, any other derive clears it.
+        const nodeBound = !isTextBoundSelectionPoint(anchorNode) ||
+            !isTextBoundSelectionPoint(focusNode) ||
+            (this.hasNativeNodeSelection() && sameValue(this.value, value));
+        this.commit(value, 'dom', {
+            edge: isCollapsed ? getMarkEdgeSide(startText, startNode, yStart) : undefined,
+            nodeBound
         });
         this.edytor.projector.observe();
-        if (shouldRestoreNormalizedDomRange && options.restoreNormalizedDomRange !== false && endText) {
+        if (restore && options.restoreNormalizedDomRange !== false && endText) {
             // Writing the DOM under a pointer drag would reset its anchor: after it.
             if (this.dragging)
                 this.pointer.hold();
             else
-                this.setAtRange(startText, yStart, endText, yEnd, { isReversed });
-        }
-        // Remember when the derived selection came from a node-bound
-        // native range (endpoints outside text elements — e.g. a block
-        // node selection or a stray boundary node). Engines asynchronously
-        // normalize such DOM selections into text points, so by the time a
-        // keydown arrives the live DOM selection may no longer look
-        // node-bound — the signature pins the flag to the derived
-        // selection it describes and any differently-shaped derive clears
-        // it.
-        const derivedKey = `${startText.id}:${yStart}:${endText?.id}:${yEnd}:${isReversed ? 1 : 0}`;
-        if (!isTextBoundSelectionPoint(selection.anchorNode) ||
-            !isTextBoundSelectionPoint(selection.focusNode)) {
-            this.#nodeBoundSelectionKey = derivedKey;
-        }
-        else if (this.#nodeBoundSelectionKey !== derivedKey) {
-            this.#nodeBoundSelectionKey = null;
+                this.selectText(startText, yStart, endText, yEnd, isReversed);
         }
     };
-    #nodeBoundSelectionKey = null;
     /**
      * Whether the live model selection was derived from a node-bound
      * native range — the shape whose Shift+Arrow extension is
      * engine-defined and therefore intercepted by the hotkey layer.
      * @internal
      */
-    hasNativeNodeSelection = () => {
-        const { startText, endText, yStart, yEnd, isReversed } = this.state;
-        if (!startText || !endText) {
-            return false;
-        }
-        return (this.#nodeBoundSelectionKey ===
-            `${startText.id}:${yStart}:${endText.id}:${yEnd}:${isReversed ? 1 : 0}`);
-    };
+    hasNativeNodeSelection = () => this.#surface?.value === this.value && this.#surface.nodeBound === true;
     /**
      * Anchor a text position into the BACKING text that owns the atom at
      * that display position — the v14 replacement for
@@ -864,19 +671,11 @@ export class EdytorSelection {
      * bound item — callers fall back to id/path restore).
      */
     resolveTextAnchor = (anchor) => {
-        const facade = this.edytor.facade;
-        if (!facade) {
-            return null;
-        }
-        const resolved = facade.resolveAnchor(anchor);
-        if (!resolved) {
-            return null;
-        }
-        return this.edytor.idToBlock.get(resolved.blockId)?.textAtOffset(resolved.offset) ?? null;
+        const resolved = this.edytor.facade?.resolveAnchor(anchor);
+        return resolved ? this.textAt({ block: resolved.blockId, offset: resolved.offset }) : null;
     };
-    /** The text and block the selection's start last resolved to (the seam origin once they die). */
+    /** The text the selection's start last resolved to (its block is the seam origin once it dies). */
     #lastText = null;
-    #lastBlock = null;
     /**
      * Displayable (a fact of the rendering layer): the block's own content is mounted
      * and not hidden by view state — a collapsed toggle's body, a `hidden`
@@ -925,6 +724,8 @@ export class EdytorSelection {
         }
         const { value } = this;
         const facade = this.edytor.facade;
+        const { start, isCollapsed } = this.projection;
+        const at = this.textAt(start);
         let dead;
         if (value.kind === 'blocks') {
             const live = value.ids.filter((id) => facade.isVisibleBlock(id));
@@ -937,7 +738,7 @@ export class EdytorSelection {
             dead = value.ids[0] ?? null;
         }
         else if (value.kind === 'atom') {
-            if (this.state.startText)
+            if (at)
                 return;
             const anchor = facade.isVisibleBlock(value.blockId)
                 ? facade.anchorAt(value.blockId, 0, 'left')
@@ -956,9 +757,7 @@ export class EdytorSelection {
                 this.#land(shown);
                 return;
             }
-            const state = this.state;
-            const { start, isCollapsed } = this.projection;
-            if (state.startText && start && isCollapsed && value.anchor !== value.focus) {
+            if (at && start && isCollapsed && value.anchor !== value.focus) {
                 // A range whose content died is a caret at the seam (`sel.seam.covered-atom`):
                 // its two anchors would re-open around text re-inserted there.
                 const caret = facade.anchorAt(start.block, start.offset, 'left');
@@ -967,15 +766,14 @@ export class EdytorSelection {
                     return;
                 }
             }
-            if (state.startText) {
+            if (at) {
                 // The text it was displayed in died while its anchor moved on: display again.
                 if (this.#lastText !== null && !this.#lastText.isInDocument)
                     this.display();
-                this.#lastText = state.startText;
-                this.#lastBlock = state.startBlock?.id ?? null;
+                this.#lastText = at.text;
                 return;
             }
-            dead = this.#lastBlock;
+            dead = this.#lastText?.blockId ?? null;
         }
         else {
             // An emptied document rests the caret in its virtual paragraph (`doc.empty.virtual`).
@@ -996,148 +794,32 @@ export class EdytorSelection {
     };
     /** Select a repaired caret (the projector displays it). */
     #land = (target) => this.commit(target, 'repair');
-    /**
-     * A text range from `first`'s first shown line to `last`'s last (the
-     * triple-click shape; `rangeEdge`); the start binds left. None when no
-     * line is shown.
-     */
-    #contentRange = (first, last = first) => {
-        const [from, to] = [rangeEdge(first, 'first', true), rangeEdge(last, 'last', true)];
-        return from && to
-            ? this.textValue(from.text, from.offset, to.text, to.offset, false, 'left')
-            : null;
-    };
-    /** Select `block`'s content range (the triple-click shape), when it shows a line. */
-    /**
-     * Select `block`'s content (a triple click) and keep that selection for
-     * the next text insertion.
-     * @internal
-     */
-    preserveBlockRange = (block) => {
-        this.setStateFromBlockContentRange(block);
-        this.shouldKeepModelSelectionForNextTextInsertion = true;
-        this.modelSelectionPreservationBlock = block;
-    };
-    setStateFromBlockContentRange = (block) => {
-        const range = this.#contentRange(block);
-        if (range)
-            this.select(range);
-    };
-    /**
-     * Select a set of whole blocks. With no block, leave block selection:
-     * the value becomes the text range the set showed, from its first shown
-     * line to its last (a list's items; a divider at an edge stays covered
-     * unless no line lies beyond it, `rangeEdge`), and stays as it is
-     * when no line is shown anywhere.
-     */
-    selectBlocks = (...blocks) => {
-        if (blocks.length) {
-            this.select(blockSelection(blocks.map((block) => block.id)));
-            return;
-        }
-        const { value } = this;
-        if (value.kind !== 'blocks')
-            return;
-        const [first, last] = [this.state.blocks[0], this.state.blocks.at(-1)];
-        const range = first && last ? this.#contentRange(first, last) : noSelection;
-        if (range)
-            this.select(range);
-    };
-    addBlockToSelection = (block) => {
-        const ids = this.value.kind === 'blocks' ? this.value.ids : [];
-        if (!ids.includes(block.id))
-            this.select(blockSelection([...ids, block.id]));
-    };
-    removeBlockFromSelection = (block) => {
-        const ids = this.value.kind === 'blocks' ? this.value.ids : [];
-        if (ids.includes(block.id))
-            this.select(blockSelection(ids.filter((id) => id !== block.id)));
-    };
-    /**
-     * Select a caret at `offset` of `text`; the projector displays it after
-     * the flush. The value is minted now: a text that dies before the
-     * display is followed through its atoms, else the seam of its block.
-     */
-    setAtTextOffset = (text, textOffset = this.state.yStart) => {
-        if (!text || typeof textOffset !== 'number')
-            return;
-        this.#admit(this.#intent(text, Math.min(Math.max(textOffset, 0), text.length)), text);
-    };
-    /**
-     * A write's model-side fallback: the value minted when the write was
-     * requested (anchors are captured at call time, before any await, so
-     * a target merged away meanwhile is followed through its atoms), or the
-     * seam of `origin`'s block when nothing of it resolves any more.
-     */
-    #admit = (intended, origin) => {
-        this.clearModelSelectionPreservation();
-        if (project(intended, this.edytor.facade).start) {
-            this.select(intended);
-            return;
-        }
-        const target = origin && this.#seamValue(origin.parent?.id ?? null);
-        if (target)
-            this.select(target);
-    };
-    /** Select the whole content from `startText` to `endText` (the code block's select-all). */
-    setAtTextsRange = (startText, endText) => {
-        this.setAtRange(startText, 0, endText, endText.length);
-    };
-    /** Select a text range; the projector displays it after the flush. */
-    setAtRange = (startText, startOffset, endText, endOffset, options = {}) => {
-        if (!startText ||
-            !endText ||
-            typeof startOffset !== 'number' ||
-            typeof endOffset !== 'number') {
-            return;
-        }
-        const state = this.state;
-        const range = this.normalizeTextRangePoints(startText, startOffset, endText, endOffset, options.isReversed ??
-            (!state.isCollapsed &&
-                state.isReversed &&
-                state.startText === startText &&
-                state.endText === endText &&
-                state.yStart === startOffset &&
-                state.yEnd === endOffset));
-        this.#admit(this.#intent(range.startText, range.startOffset, range.endText, range.endOffset, range.isReversed), range.startText);
-    };
-    /**
-     * Select `block`'s content (the whole of it by default): from its first
-     * shown line to its last (a list's items, a code block's lines), the
-     * offsets in those lines. A block that shows no line (a divider) keeps the
-     * current value. Displayed after the flush.
-     */
-    setAtBlockRange = (block, startOffset = 0, endOffset) => {
-        const [first, last] = block ? [shownText(block, 'first'), shownText(block, 'last')] : [];
-        if (!first || !last)
-            return;
-        const end = endOffset || last.length;
-        if (!startOffset && end === last.length)
-            this.select(this.textValue(first, 0, last, last.length, false, 'left'));
-        else
-            this.setAtRange(first, startOffset, last, end);
-    };
     /**
      * Anchors from a DOM selection, without selecting them: the projector mints
      * an unobserved native move before a transaction it did not issue.
      * @internal
      */
     mint = (snapshot) => {
-        const container = this.edytor.node;
-        const { anchorNode, focusNode } = snapshot;
-        if (!container || !anchorNode || !focusNode)
+        const read = this.#read(snapshot);
+        if (!read)
             return null;
-        for (const node of [anchorNode, focusNode])
-            if (!container.contains(node) || isNestedForeignEditableTarget(container, node))
-                return null;
-        const reversed = isBackward(snapshot);
-        const [startNode, start, endNode, end] = reversed
-            ? [focusNode, snapshot.focusOffset, anchorNode, snapshot.anchorOffset]
-            : [anchorNode, snapshot.anchorOffset, focusNode, snapshot.focusOffset];
-        const { startText, endText } = this.getTextsInSelection(startNode, endNode, start, end);
+        const { isReversed, startNode, start, endNode, end } = read;
+        const startText = this.getTextOfNode(startNode, start);
+        const endText = startText && this.getTextOfNode(endNode, end);
         if (!startText || !endText)
             return null;
-        const at = (text, node, offset) => Math.min(Math.max(getYIndex(text, node, offset), 0), text.length);
-        return this.textValue(startText, at(startText, startNode, start), endText, at(endText, endNode, end), reversed);
+        const from = offsetIn(startText, startNode, start);
+        return this.textValue(startText, from, endText, offsetIn(endText, endNode, end), isReversed);
+    };
+    /**
+     * A DOM selection whose two endpoints are this editor's own points (not
+     * in a kind's control): its endpoints in document order and its direction.
+     */
+    #read = (dom) => {
+        const container = this.edytor.node;
+        if (!dom || !isOwnPoint(container, dom.anchorNode) || !isOwnPoint(container, dom.focusNode))
+            return null;
+        const isReversed = isBackward(dom);
+        return { isReversed, ...ordered(dom, isReversed) };
     };
 }