edytor 1.0.0-rc.3 → 2.0.0

package/dist/selection/selection.utils.d.ts

@@ -1,6 +1,6 @@
 import type { EdytorSelection } from './selection.svelte.js';
 import type { Text } from '../text/text.svelte.js';
-import type { InlineBlock } from '../block/inlineBlock.svelte.js';
+import type { Edytor } from '../edytor.svelte.js';
 import type { DomSelectionSnapshot } from './domSelection.js';
 import type { EdgeSide } from '../session/editing/text.js';
 export declare const SYNTHETIC_TEXT_OVERLAY_SELECTOR = "[data-edytor-text-suggestion]";
@@ -17,31 +17,54 @@ export declare const isInsideTrailingNewlineMarker: (node: Node) => boolean;
  * extending horizontally.
  */
 export declare const isTextBoundSelectionPoint: (node: Node | null) => boolean;
+/**
+ * The text a DOM point is in: its text element; in a text suggestion's
+ * overlay, its block's last text; at an element boundary (with `offset`),
+ * the text beside it; on a stray node or in a block suggestion's preview,
+ * the nearest text at that boundary.
+ */
 export declare function getTextOfNode(this: EdytorSelection, node: Node | null, offset?: number): Text | null;
-export declare function getInlineBlockOfNode(this: EdytorSelection, node: Node | null): InlineBlock | null;
-export declare function getInlineBlockInSelectedRange(this: EdytorSelection, range: Range | undefined): InlineBlock | null;
-export declare function getTextsInSelection(this: EdytorSelection, startNode: Node | null, endNode: Node | null, startOffset?: number, endOffset?: number): {
-    startText: Text | null;
-    endText: Text | null;
-    inlineBlock: InlineBlock | null;
-};
+/** The inline atom at `node`: around it, or the first one inside it. */
+export declare const getInlineBlockOfNode: (edytor: Edytor, node: Node | null) => import("../index.js").InlineBlock | null;
+/** The one inline atom a non-collapsed range covers, touching no text. */
+export declare const getInlineBlockInSelectedRange: (edytor: Edytor, range: Range | undefined) => import("../index.js").InlineBlock | null;
 /**
  * The edge side of a collapsed DOM point at `offset` of `text`: inside
  * when every mark element rendering the character before it contains the
  * point, outside when one does not; `undefined` when that character has none.
  */
 export declare const getMarkEdgeSide: (text: Text, node: Node | null, offset: number) => EdgeSide | undefined;
-export declare const getYIndex: (text: Text | null, node: Node | null, _start: number) => number;
+/**
+ * The offset the DOM point `(node, offset)` stands for in the rendered text
+ * `text` as the DOM holds it: its trailing newline's marker reads the end;
+ * no model rule (the DOM may be ahead of the model: a native insertion read
+ * before its adoption).
+ */
+export declare const domOffsetIn: (text: Text, node: Node, offset: number) => number;
+/**
+ * The one DOM point → text offset mapper ({@link domOffsetIn} with the
+ * model's rules; `domPointOf` is its inverse): a point outside the text
+ * element beside it (an element boundary, past an inline atom) reads its
+ * edge, and an empty text's filler reads 0.
+ */
+export declare const getYIndex: (text: Text | null, node: Node | null, offset: number) => number;
+/** {@link getYIndex} within the text's length (a caret the model can hold). */
+export declare const offsetIn: (text: Text, node: Node | null, offset: number) => number;
 /** The mounted text and display offset a DOM point stands in, or `null` (`edytor.ports.surface.pointAt`). */
 export declare function textPointAt(this: EdytorSelection, node: Node, offset: number): {
     text: Text;
     offset: number;
 } | null;
+/** A DOM selection's endpoints in document order, and whether it runs backward. */
+export declare const ordered: (selection: Pick<DomSelectionSnapshot, "anchorNode" | "anchorOffset" | "focusNode" | "focusOffset">, reversed: boolean) => {
+    startNode: Node | null;
+    start: number;
+    endNode: Node | null;
+    end: number;
+};
 /**
  * DOM Range offsets use UTF-16 code units and programmatic ranges can land
  * between the two units of a surrogate pair. Browser target ranges disagree
  * about that invalid boundary, so normalize it before it reaches editor state.
  */
 export declare const normalizeUtf16Boundary: (value: string, offset: number, direction: "backward" | "forward") => number;
-export declare const getRangesFromSelection: (selection: Pick<Selection, "getRangeAt" | "rangeCount"> | DomSelectionSnapshot) => Range[];
-export declare const climbDom: (node: Node | undefined | null, cb: (node: Node) => void | true) => void;

package/dist/selection/selection.utils.js

@@ -3,29 +3,21 @@ const TRAILING_NEWLINE_SELECTOR = '[data-edytor-trailing-newline]';
 export const SYNTHETIC_TEXT_OVERLAY_SELECTOR = '[data-edytor-text-suggestion]';
 /** A block suggestion's preview group: view-only, never a selection endpoint (`session/suggestions`). */
 export const SUGGESTION = '[data-edytor-suggestion]';
-export const getElementFromNode = (node) => {
-    if (!node || typeof Element === 'undefined') {
-        return null;
-    }
-    if (node instanceof Element) {
-        return node;
-    }
-    return node.nodeType === Node.TEXT_NODE ? node.parentElement : null;
-};
-export const isInsideTrailingNewlineMarker = (node) => {
-    const element = getElementFromNode(node);
-    return element instanceof Element && Boolean(element.closest(TRAILING_NEWLINE_SELECTOR));
-};
-const findClosestTextElement = (node) => {
-    const element = getElementFromNode(node);
-    const textElement = element?.closest('[data-edytor-text]');
-    return textElement instanceof HTMLElement ? textElement : null;
-};
-const findSyntheticTextOverlayElement = (node) => {
-    const element = getElementFromNode(node);
-    const overlay = element?.closest(SYNTHETIC_TEXT_OVERLAY_SELECTOR);
-    return overlay instanceof HTMLElement ? overlay : null;
-};
+const TEXT = '[data-edytor-text]';
+const INLINE = '[data-edytor-inline-block]';
+const BLOCK = '[data-edytor-block]';
+export const getElementFromNode = (node) => !node || typeof Element === 'undefined'
+    ? null
+    : node instanceof Element
+        ? node
+        : node.nodeType === Node.TEXT_NODE
+            ? node.parentElement
+            : null;
+/** The element around `node` (itself included) matching `selector`. */
+const closestTo = (node, selector) => getElementFromNode(node)?.closest(selector) ?? null;
+/** `node` is an element matching `selector` or holding one. */
+const holds = (node, selector) => node instanceof Element && (node.matches(selector) || !!node.querySelector(selector));
+export const isInsideTrailingNewlineMarker = (node) => !!closestTo(node, TRAILING_NEWLINE_SELECTOR);
 /**
  * A selection endpoint counts as text-bound when it lives inside a
  * `data-edytor-text` element — either a text node inside it or an
@@ -34,93 +26,52 @@ const findSyntheticTextOverlayElement = (node) => {
  * native selection "node-bound" — the shape engines disagree on when
  * extending horizontally.
  */
-export const isTextBoundSelectionPoint = (node) => {
-    const element = node?.nodeType === Node.TEXT_NODE ? node.parentElement : node;
-    return element instanceof Element && Boolean(element.closest('[data-edytor-text]'));
-};
-const isIgnoredBoundaryNode = (node) => {
-    if (node.nodeType === Node.COMMENT_NODE) {
-        return true;
-    }
-    if (node instanceof Element) {
-        return (node.matches(SUGGESTION) ||
-            !(node.matches('[data-edytor-text], [data-edytor-inline-block], [data-edytor-block]') ||
-                node.querySelector('[data-edytor-text], [data-edytor-inline-block], [data-edytor-block]')));
-    }
-    if (node.nodeType !== Node.TEXT_NODE) {
-        return false;
-    }
-    return (node.textContent ?? '').replace(/[\u200B-\u200D\uFEFF]/g, '').trim() === '';
-};
-const getBoundaryChild = (element, offset, direction) => {
-    const step = direction === 'previous' ? -1 : 1;
-    let index = direction === 'previous' ? offset - 1 : offset;
-    while (index >= 0 && index < element.childNodes.length) {
-        const child = element.childNodes[index];
-        if (!isIgnoredBoundaryNode(child)) {
-            return child;
-        }
-        index += step;
-    }
+export const isTextBoundSelectionPoint = (node) => !!closestTo(node, TEXT);
+/** A node a boundary looks past: a comment, blank text, a suggestion, an element with no editor content. */
+const isIgnoredBoundaryNode = (node) => node.nodeType === Node.COMMENT_NODE ||
+    (node instanceof Element
+        ? node.matches(SUGGESTION) || !holds(node, `${TEXT}, ${INLINE}, ${BLOCK}`)
+        : node.nodeType === Node.TEXT_NODE &&
+            !(node.textContent ?? '').replace(/[\u200B-\u200D\uFEFF]/g, '').trim());
+/** The first child of `element` from `offset` in `step`'s direction a boundary does not look past. */
+const boundaryChild = (element, offset, step) => {
+    for (let i = step < 0 ? offset - 1 : offset; i >= 0 && i < element.childNodes.length; i += step)
+        if (!isIgnoredBoundaryNode(element.childNodes[i]))
+            return element.childNodes[i];
     return null;
 };
 /** The first or last text element at `node`: itself, or one nested in it. */
-const getEdgeTextElement = (edge, node) => {
+const edgeText = (edge, node) => {
     const element = getElementFromNode(node);
     if (!(element instanceof HTMLElement))
         return null;
     if (element.hasAttribute('data-edytor-text'))
         return element;
-    const nested = element.querySelectorAll('[data-edytor-text]');
-    const found = nested.item(edge === 'first' ? 0 : nested.length - 1);
-    return found instanceof HTMLElement ? found : null;
-};
-const containsInlineBlock = (node) => {
-    if (!(node instanceof Element)) {
-        return false;
-    }
-    return (node.matches('[data-edytor-inline-block]') ||
-        Boolean(node.querySelector('[data-edytor-inline-block]')));
+    const nested = element.querySelectorAll(TEXT);
+    return nested[edge === 'first' ? 0 : nested.length - 1] ?? null;
 };
-const containsBlock = (node) => {
-    if (!(node instanceof Element)) {
-        return false;
-    }
-    return node.matches('[data-edytor-block]') || Boolean(node.querySelector('[data-edytor-block]'));
-};
-const getElementBoundary = (node, offset) => {
-    if (!(node instanceof Element)) {
+/** The children on either side of an element boundary, and the text elements they end and start with. */
+const boundaryOf = (node, offset) => {
+    if (!(node instanceof Element))
         return null;
-    }
-    const previous = getBoundaryChild(node, offset, 'previous');
-    const next = getBoundaryChild(node, offset, 'next');
-    return {
-        previousText: getEdgeTextElement('last', previous),
-        nextText: getEdgeTextElement('first', next),
-        previousInline: containsInlineBlock(previous),
-        nextInline: containsInlineBlock(next),
-        previousBlock: containsBlock(previous),
-        nextBlock: containsBlock(next)
-    };
+    const [previous, next] = [boundaryChild(node, offset, -1), boundaryChild(node, offset, 1)];
+    return { previous, next, before: edgeText('last', previous), after: edgeText('first', next) };
 };
-const getTextElementAtBoundary = (node, offset) => {
-    const boundary = getElementBoundary(node, offset);
-    if (!boundary) {
+/** The text element an element boundary stands in: past an atom or a block, the text beside it. */
+const textAtBoundary = (node, offset) => {
+    const at = boundaryOf(node, offset);
+    if (!at)
         return null;
-    }
-    if (boundary.previousInline && boundary.nextText) {
-        return boundary.nextText;
-    }
-    if (boundary.nextInline && boundary.previousText) {
-        return boundary.previousText;
-    }
-    if (boundary.nextBlock && boundary.nextText) {
-        return boundary.nextText;
-    }
-    if (boundary.previousBlock && boundary.previousText) {
-        return boundary.previousText;
-    }
-    return boundary.previousText ?? boundary.nextText;
+    const { previous, next, before, after } = at;
+    if (holds(previous, INLINE) && after)
+        return after;
+    if (holds(next, INLINE) && before)
+        return before;
+    if (holds(next, BLOCK) && after)
+        return after;
+    if (holds(previous, BLOCK) && before)
+        return before;
+    return before ?? after;
 };
 /**
  * Resolve an endpoint that sits on a stray DOM node — a text node or
@@ -133,146 +84,71 @@ const getTextElementAtBoundary = (node, offset) => {
  * as element boundaries apply (comments, whitespace/zero-width text
  * nodes, and elements without editor content are skipped).
  */
-const getStrayBoundaryTextElement = (node, container) => {
-    // The first non-ignored ELEMENT sibling of `current` in `direction`.
+const strayText = (node, container) => {
+    // The first non-ignored ELEMENT sibling of `current` in `step`'s direction.
     // A non-empty stray text node stops the scan: the gap is ambiguous and
     // the caller should look at the enclosing level instead.
-    const siblingElement = (parent, index, step) => {
+    const sibling = (parent, index, step) => {
         for (let i = index + step; i >= 0 && i < parent.childNodes.length; i += step) {
             const child = parent.childNodes[i];
-            if (child instanceof Element) {
-                if (isIgnoredBoundaryNode(child))
-                    continue;
-                return child;
-            }
             if (!isIgnoredBoundaryNode(child))
-                break;
+                return child instanceof Element ? child : null;
         }
         return null;
     };
-    let current = node;
-    let parent = current.parentNode;
-    while (parent instanceof Element) {
+    for (let current = node, parent = node.parentNode; parent instanceof Element;) {
         const index = Array.prototype.indexOf.call(parent.childNodes, current);
-        if (index !== -1) {
-            const element = getEdgeTextElement('last', siblingElement(parent, index, -1)) ??
-                getEdgeTextElement('first', siblingElement(parent, index, 1));
-            if (element) {
-                return element;
-            }
-        }
-        if (parent === container) {
+        const element = index !== -1 &&
+            (edgeText('last', sibling(parent, index, -1)) ??
+                edgeText('first', sibling(parent, index, 1)));
+        if (element)
+            return element;
+        if (parent === container)
             break;
-        }
         current = parent;
         parent = current.parentNode;
     }
     return null;
 };
-const getTextOffsetAtElementBoundary = (text, node, offset) => {
-    const boundary = getElementBoundary(node, offset);
-    const textNode = text.node;
-    if (!boundary || !textNode) {
-        return null;
-    }
-    if (boundary.previousInline && boundary.nextText === textNode) {
-        return 0;
-    }
-    if (boundary.nextInline && boundary.previousText === textNode) {
-        return text.length;
-    }
-    if (boundary.previousText === textNode) {
-        return text.length;
-    }
-    if (boundary.nextText === textNode) {
-        return 0;
-    }
-    return null;
-};
+/**
+ * The text a DOM point is in: its text element; in a text suggestion's
+ * overlay, its block's last text; at an element boundary (with `offset`),
+ * the text beside it; on a stray node or in a block suggestion's preview,
+ * the nearest text at that boundary.
+ */
 export function getTextOfNode(node, offset) {
     if (!node)
         return null;
-    const textOf = (element) => (element && this.edytor.nodeToText.get(element)) || null;
+    const { edytor } = this;
+    const textOf = (element) => (element && edytor.nodeToText.get(element)) || null;
     // A point in a suggestion's preview is the stray boundary the preview sits at.
-    const preview = getElementFromNode(node)?.closest(SUGGESTION);
+    const preview = closestTo(node, SUGGESTION);
     if (preview)
-        return textOf(getStrayBoundaryTextElement(preview, this.edytor.node));
-    let text = null;
-    if (node.nodeType !== Node.TEXT_NODE) {
-        text = textOf(node);
-        if (text)
-            return text;
-        const syntheticOverlay = findSyntheticTextOverlayElement(node);
-        if (syntheticOverlay) {
-            const blockElement = syntheticOverlay.closest('[data-edytor-block]');
-            const blockId = blockElement instanceof HTMLElement ? blockElement.dataset.edytorId : undefined;
-            const block = blockId ? this.edytor.idToBlock.get(blockId) : null;
-            return block?.lastText ?? null;
-        }
-        text =
-            textOf(findClosestTextElement(node)) ??
-                (typeof offset === 'number' ? textOf(getTextElementAtBoundary(node, offset)) : null);
-    }
-    else {
-        for (let current = node; current.parentElement && !text; current = current.parentElement)
-            text = textOf(current);
-    }
-    // The endpoint lives on a stray node (whitespace/empty text between
-    // blocks, the render anchor, a non-editable gap) — resolve it to the
-    // nearest text element at that boundary so open-ended selections
-    // still map to a model text position.
-    return text ?? textOf(getStrayBoundaryTextElement(node, this.edytor.node));
+        return textOf(strayText(preview, edytor.node));
+    const element = node.nodeType !== Node.TEXT_NODE;
+    const overlay = element && !textOf(node) && closestTo(node, SYNTHETIC_TEXT_OVERLAY_SELECTOR);
+    if (overlay)
+        return this.getBlockOfNode(overlay)?.lastText ?? null;
+    return (textOf(closestTo(node, TEXT)) ??
+        (element && typeof offset === 'number' ? textOf(textAtBoundary(node, offset)) : null) ??
+        textOf(strayText(node, edytor.node)));
 }
-export function getInlineBlockOfNode(node) {
-    if (!node)
-        return null;
+/** The inline atom at `node`: around it, or the first one inside it. */
+export const getInlineBlockOfNode = (edytor, node) => {
     const element = getElementFromNode(node);
-    const inlineElement = element?.closest('[data-edytor-inline-block]');
-    if (inlineElement instanceof Element && this.edytor.node?.contains(inlineElement)) {
-        return this.edytor.nodeToInlineBlock.get(inlineElement) || null;
-    }
-    if (element instanceof Element) {
-        const nestedInlineElement = element.querySelector('[data-edytor-inline-block]');
-        if (nestedInlineElement instanceof Element) {
-            return this.edytor.nodeToInlineBlock.get(nestedInlineElement) || null;
-        }
-    }
-    return null;
-}
-export function getInlineBlockInSelectedRange(range) {
-    if (!range || range.collapsed) {
+    const around = element?.closest(INLINE);
+    const inline = around && edytor.node?.contains(around) ? around : element?.querySelector(INLINE);
+    return (inline && edytor.nodeToInlineBlock.get(inline)) || null;
+};
+/** The one inline atom a non-collapsed range covers, touching no text. */
+export const getInlineBlockInSelectedRange = (edytor, range) => {
+    const root = range && !range.collapsed ? getElementFromNode(range.commonAncestorContainer) : null;
+    if (!root)
         return null;
-    }
-    const root = range.commonAncestorContainer instanceof Element
-        ? range.commonAncestorContainer
-        : range.commonAncestorContainer.parentElement;
-    if (!root) {
-        return null;
-    }
-    const inlineElements = [
-        ...(root.matches('[data-edytor-inline-block]') ? [root] : []),
-        ...Array.from(root.querySelectorAll('[data-edytor-inline-block]'))
-    ].filter((element) => range.intersectsNode(element));
-    const inlineBlocks = new Set(inlineElements
-        .map((element) => this.edytor.nodeToInlineBlock.get(element))
-        .filter((inlineBlock) => Boolean(inlineBlock)));
-    if (inlineBlocks.size !== 1) {
-        return null;
-    }
-    const intersectsText = Array.from(root.querySelectorAll('[data-edytor-text]')).some((element) => range.intersectsNode(element));
-    if (intersectsText) {
-        return null;
-    }
-    return inlineBlocks.values().next().value ?? null;
-}
-export function getTextsInSelection(startNode, endNode, startOffset = 0, endOffset = startOffset) {
-    const startText = this.getTextOfNode(startNode, startOffset);
-    return {
-        startText,
-        endText: startText ? this.getTextOfNode(endNode, endOffset) : null,
-        inlineBlock: this.getInlineBlockOfNode(startNode)
-    };
-}
+    const inside = (selector) => [...(root.matches(selector) ? [root] : []), ...root.querySelectorAll(selector)].filter((element) => range.intersectsNode(element));
+    const atoms = new Set(inside(INLINE).flatMap((element) => edytor.nodeToInlineBlock.get(element) ?? []));
+    return atoms.size === 1 && !inside(TEXT).length ? [...atoms][0] : null;
+};
 /**
  * The edge side of a collapsed DOM point at `offset` of `text`: inside
  * when every mark element rendering the character before it contains the
@@ -294,33 +170,51 @@ export const getMarkEdgeSide = (text, node, offset) => {
     }
     return side;
 };
-export const getYIndex = (text, node, _start) => {
+/**
+ * The offset the DOM point `(node, offset)` stands for in the rendered text
+ * `text` as the DOM holds it: its trailing newline's marker reads the end;
+ * no model rule (the DOM may be ahead of the model: a native insertion read
+ * before its adoption).
+ */
+export const domOffsetIn = (text, node, offset) => text.endsWithNewline && isInsideTrailingNewlineMarker(node)
+    ? text.length
+    : getTextContentOffsetAtPoint(text.node, node, offset);
+/**
+ * The one DOM point → text offset mapper ({@link domOffsetIn} with the
+ * model's rules; `domPointOf` is its inverse): a point outside the text
+ * element beside it (an element boundary, past an inline atom) reads its
+ * edge, and an empty text's filler reads 0.
+ */
+export const getYIndex = (text, node, offset) => {
     if (!text || !node)
-        return _start;
-    const parent = text.node;
-    const { isEmpty } = text;
-    if (text.endsWithNewline && isInsideTrailingNewlineMarker(node)) {
-        return text.length;
-    }
+        return offset;
+    const element = text.node;
     // A point inside the text element reads the text before it; the
     // element-boundary rule is for points outside it.
-    const boundaryOffset = parent.contains(node)
-        ? null
-        : getTextOffsetAtElementBoundary(text, node, _start);
-    if (boundaryOffset !== null) {
-        return boundaryOffset;
-    }
-    const start = getTextContentOffsetAtPoint(parent, node, _start);
-    if ((start === 0 || start === 1) && isEmpty) {
-        return 0;
-    }
-    return start;
-};
+    if (!element.contains(node)) {
+        const boundary = boundaryOf(node, offset);
+        if (boundary?.before === element)
+            return text.length;
+        if (boundary?.after === element)
+            return 0;
+    }
+    const at = domOffsetIn(text, node, offset);
+    return (at === 0 || at === 1) && text.isEmpty ? 0 : at;
+};
+/** {@link getYIndex} within the text's length (a caret the model can hold). */
+export const offsetIn = (text, node, offset) => Math.min(Math.max(getYIndex(text, node, offset), 0), text.length);
 /** The mounted text and display offset a DOM point stands in, or `null` (`edytor.ports.surface.pointAt`). */
 export function textPointAt(node, offset) {
     const text = getTextOfNode.call(this, node);
     return text?.node ? { text, offset: getYIndex(text, node, offset) } : null;
 }
+/** A DOM selection's endpoints in document order, and whether it runs backward. */
+export const ordered = (selection, reversed) => {
+    const { anchorNode, anchorOffset, focusNode, focusOffset } = selection;
+    return reversed
+        ? { startNode: focusNode, start: focusOffset, endNode: anchorNode, end: anchorOffset }
+        : { startNode: anchorNode, start: anchorOffset, endNode: focusNode, end: focusOffset };
+};
 const isHighSurrogate = (code) => code >= 0xd800 && code <= 0xdbff;
 const isLowSurrogate = (code) => code >= 0xdc00 && code <= 0xdfff;
 /**
@@ -338,16 +232,3 @@ export const normalizeUtf16Boundary = (value, offset, direction) => {
     }
     return direction === 'backward' ? clamped - 1 : clamped + 1;
 };
-export const getRangesFromSelection = (selection) => {
-    return Array.from({ length: selection.rangeCount }, (_, i) => selection.getRangeAt(i));
-};
-export const climbDom = (node, cb) => {
-    if (!node)
-        return;
-    let parent = node;
-    while (parent) {
-        if (cb(parent))
-            break;
-        parent = parent.parentElement;
-    }
-};

package/dist/selection/visibility.d.ts

@@ -9,7 +9,7 @@
  */
 import type { Block } from '../block/block.svelte.js';
 import type { Edytor } from '../edytor.svelte.js';
-import type { RangeEndpoints } from '../edytor.utils.js';
+import type { TextRange } from './selection.svelte.js';
 import { Text } from '../text/text.svelte.js';
 /** Content hidden by view state: a collapsed toggle's body, a `hidden` subtree. */
 export declare const HIDDEN = "[hidden], details:not([open]) > :not(summary)";
@@ -62,10 +62,6 @@ export declare const viewOf: (edytor: Edytor) => {
  * `selection.selectedBlocks`: a grip-selected list is one block to a menu.
  */
 export declare const selectedMembers: (edytor: Edytor, blocks?: Iterable<Block>) => Block[];
-/** A text range's endpoints and texts, as the selection (or an attempt's snapshot) holds them. */
-type TextRange = RangeEndpoints & {
-    texts: Text[];
-};
 /**
  * Whether a text range covers `block` (`del.range.hidden-body`): a block the
  * view shows does; a hidden one exactly when deleting the range deletes it —
@@ -78,7 +74,7 @@ type TextRange = RangeEndpoints & {
  * selected list leave it as it is. Copy, cut, delete, marks and the
  * toolbar share this one answer.
  */
-export declare const rangeCovers: (edytor: Edytor, range?: TextRange, { replace }?: {
+export declare const rangeCovers: (edytor: Edytor, snapshot?: TextRange, { replace }?: {
     replace?: boolean | undefined;
 }) => (block: Block) => boolean;
 /**
@@ -86,11 +82,10 @@ export declare const rangeCovers: (edytor: Edytor, range?: TextRange, { replace
  * document order, so marks, the toolbar's state and the marks typing over a
  * range inherits (`replace`) reach what the range's delete would.
  */
-export declare const selectedTextSpans: (edytor: Edytor, range?: TextRange, options?: {
+export declare const selectedTextSpans: (edytor: Edytor, snapshot?: TextRange, options?: {
     replace?: boolean;
 }) => {
     text: Text;
     start: number;
     end: number;
 }[];
-export {};

package/dist/selection/visibility.js

@@ -112,12 +112,13 @@ export const selectedMembers = (edytor, blocks = edytor.selection.selectedBlocks
  * selected list leave it as it is. Copy, cut, delete, marks and the
  * toolbar share this one answer.
  */
-export const rangeCovers = (edytor, range = edytor.selection.state, { replace = false } = {}) => {
+export const rangeCovers = (edytor, snapshot, { replace = false } = {}) => {
     const { selection } = edytor;
-    if (range === selection.state && selection.value.kind === 'blocks') {
+    if (!snapshot && selection.value.kind === 'blocks') {
         const members = new Set(selectedMembers(edytor));
         return (block) => members.has(block) && (selection.selectedBlocks.has(block) || !hidden(block));
     }
+    const range = snapshot ?? selection.textRange();
     const members = new Set(range.texts.map((text) => text.parent));
     const head = range.startText?.parent;
     const headDies = !replace && range.startText?.segStart === 0 && range.yStart === 0;
@@ -135,10 +136,11 @@ export const rangeCovers = (edytor, range = edytor.selection.state, { replace =
  * document order, so marks, the toolbar's state and the marks typing over a
  * range inherits (`replace`) reach what the range's delete would.
  */
-export const selectedTextSpans = (edytor, range = edytor.selection.state, options = {}) => {
-    const covers = rangeCovers(edytor, range, options);
+export const selectedTextSpans = (edytor, snapshot, options = {}) => {
+    const covers = rangeCovers(edytor, snapshot, options);
+    const range = snapshot ?? edytor.selection.textRange();
     // A block selection's texts are its members' own lines (a list's items too).
-    const texts = range === edytor.selection.state && edytor.selection.value.kind === 'blocks'
+    const texts = !snapshot && edytor.selection.value.kind === 'blocks'
         ? selectedMembers(edytor).flatMap((block) => block.rendersContent ? block.content.filter((part) => part instanceof Text) : [])
         : range.texts;
     return texts.flatMap((text) => covers(text.parent)

package/dist/session/announcer.svelte.d.ts

@@ -1,7 +1,7 @@
 /**
  * What a view tells assistive technology about a change a screen does not
  * say by itself: a block move or a block delete this view made, in the
- * view's labels (`edytor.labels`).
+ * view's `editor` labels (`labelsOf`).
  * DOM-free: the surface renders `message` in a polite live region beside
  * the host (`components/Announcer.svelte`), a new node per announcement
  * (`serial`), so the same words twice are read twice. Only this view's own
@@ -11,6 +11,7 @@ import type { Block } from '../block/block.svelte.js';
 import type { Edytor } from '../edytor.svelte.js';
 import type { BlockMoveRequest } from './moves.js';
 export declare class Announcer {
+    #private;
     private edytor;
     /** The last announcement. */
     message: string;

package/dist/session/announcer.svelte.js

@@ -1,4 +1,5 @@
 import { kindLabel } from '../kinds.js';
+import { editorEnglish, labelsOf } from '../labels.js';
 /** The label saying a move, by direction (`to`: a placement, a drop). */
 const MOVED = {
     up: 'movedUp',
@@ -16,6 +17,9 @@ export class Announcer {
     constructor(edytor) {
         this.edytor = edytor;
     }
+    get #labels() {
+        return labelsOf(this.edytor, 'editor', editorEnglish);
+    }
     /** Announce `message` (politely: after what the screen reader is saying). */
     say = (message) => {
         this.message = message;
@@ -23,7 +27,7 @@ export class Announcer {
     };
     /** `blocks` (one or several) as words: a kind's label for one, a count for several. */
     what = (blocks) => {
-        const { labels } = this.edytor;
+        const labels = this.#labels;
         return blocks.length === 1
             ? labels.block(kindLabel(this.edytor, blocks[0]))
             : labels.blocks(blocks.length);
@@ -33,8 +37,8 @@ export class Announcer {
         if (!moved.length)
             return;
         const said = MOVED['direction' in request ? request.direction : 'to'];
-        this.say(this.edytor.labels[said](this.what(moved)));
+        this.say(this.#labels[said](this.what(moved)));
     };
     /** Blocks were deleted: `what` names them, read before they went. */
-    deleted = (what) => this.say(this.edytor.labels.deleted(what));
+    deleted = (what) => this.say(this.#labels.deleted(what));
 }