@voithos-labs/aragonite 0.10.4 → 0.10.7

package/dist/selection/primitives.js

@@ -1,22 +1,36 @@
 /**
- * Pure primitives for cross-block selection: types, document-order walking, overlay
- * classification, the delete-commit snapshot rule. No DOM, no state. Path-level predicates
- * live in `./path-math`.
+ * Pure primitives for cross-block selection: types, overlay classification of a covered range,
+ * the delete-commit snapshot rule. Path-level predicates live in `./path-math`.
  */
-import { comparePaths, isPathBetween, isStrictAncestorOf, pathHasPrefix, pathsEqual } from './path-math';
+import { SELECTION_END } from '../block-component';
+import { comparePaths, pathsEqual } from './path-math';
 import { asCellIndex, asRawOffset, docPathFrom } from '../cursor/coordinate-spaces';
 import { devWarn } from '../dev-warn';
+/** A cell endpoint: the grid's path, a row-major cell index, and the flag saying so. */
+export function cellPoint(path, cellIdx) {
+    return { path: path.slice(), offset: cellIdx, cellCoordinate: true };
+}
 export function isWholeBlockEndpoint(endpoint) {
     return 'wholeBlock' in endpoint;
 }
-/** Offset as a char index into the leaf's `raw`. DEV-warns on a cell point, but always returns. */
+/** Whether two snapshots name the same selection. The coordinate space counts: the same
+ *  numbers as a cell index and as a character offset are different positions. */
+export function selectionsEqual(a, b) {
+    if (a === null || b === null)
+        return a === b;
+    return pointsEqual(a.anchor, b.anchor) && pointsEqual(a.focus, b.focus);
+}
+function pointsEqual(a, b) {
+    return (a.offset === b.offset && !a.cellCoordinate === !b.cellCoordinate && pathsEqual(a.path, b.path));
+}
+/** Offset as a char index into the leaf's `raw`. Warns in dev on a cell point, but always returns. */
 export function charOffsetOf(point, tag) {
     if (point.cellCoordinate) {
         devWarn(tag, 'char-offset site received a cell-coordinate SelectionPoint', point);
     }
     return asRawOffset(point.offset);
 }
-/** Offset as a row-major table cell index. DEV-warns on a char point, but always returns. */
+/** Offset as a row-major table cell index. Warns in dev on a char point, but always returns. */
 export function cellIndexOf(point, tag) {
     if (!point.cellCoordinate) {
         devWarn(tag, 'cell-index site received a char-offset SelectionPoint', point);
@@ -24,13 +38,8 @@ export function cellIndexOf(point, tag) {
     return asCellIndex(point.offset);
 }
 // ── Normalization ──────────────────────────────────────────────────────────
-/**
- * `{start, end}` in document order: by path, then by offset when paths match. Published on the
- * consumer barrel as `normalizeSelection`, which is what a host anchors UI to. The offset tiebreak
- * is coordinate-space agnostic: two endpoints sharing a table's path carry row-major CELL indices,
- * whose order IS document order inside that table. A caller with no selection has nothing to
- * order, since `getSelection()` answers null with nothing focused and at a gap caret.
- */
+/** `{start, end}` in document order: by path, then by offset, which orders cell indices on a
+ *  shared table path too, since row-major order is document order inside the table. */
 export function normalize(selection) {
     const { anchor, focus } = selection;
     const cmp = comparePaths(anchor.path, focus.path);
@@ -43,67 +52,48 @@ export function normalize(selection) {
     return { start: focus, end: anchor };
 }
 // ── Undo snapshot ──────────────────────────────────────────────────────────
-/** A join delete rides the caller's snapshot; every other one seats undo at its own coordinate. */
-export function deleteSnapshot(options, path, offset = 0) {
-    return options?.undoEntry === 'join' ? 'skip' : { path: docPathFrom(path), offset };
-}
-// ── Range walk ─────────────────────────────────────────────────────────────
-/** Every block path strictly between `start` and `end`, at every nesting level. */
-export function walkBetween(doc, start, end) {
-    if (comparePaths(start, end) >= 0)
-        return [];
-    const result = [];
-    function visit(node, path) {
-        if (isPathBetween(path, start, end)) {
-            result.push([...path]);
-        }
-        if (!node.children)
-            return;
-        for (let i = 0; i < node.children.length; i++) {
-            const childPath = [...path, i];
-            // Skip subtrees entirely before start (an ancestor of start still holds it) or after end.
-            if (!pathHasPrefix(start, childPath) && comparePaths(childPath, start) < 0)
-                continue;
-            if (comparePaths(childPath, end) >= 0)
-                break;
-            visit(node.children[i], childPath);
-        }
-    }
-    visit(doc, []);
-    return result;
+/** Where undo puts the caret back after a range delete, when nothing is focused. */
+export function deleteSnapshot(path, offset = 0) {
+    return { path: docPathFrom(path), offset };
 }
-/**
- * Position of a block relative to a selection, for overlay rendering. 'single-block'
- * tells the caller to delegate to the browser instead of painting.
- */
-export function classifyBlockForSelection(path, selection) {
-    const { start, end } = normalize(selection);
-    if (comparePaths(start.path, end.path) === 0) {
-        return comparePaths(path, start.path) === 0 ? 'single-block' : 'outside';
+/** Where a block stands in a covered range, for the overlay: 'single-block' delegates to the
+ *  browser, and a subtree the range holds whole is 'middle' with nothing inside it painting. */
+export function classifyBlockForSelection(path, coverage) {
+    const { start, end } = coverage.range;
+    if (pathsEqual(start.path, end.path)) {
+        return pathsEqual(path, start.path) ? 'single-block' : 'outside';
     }
-    if (comparePaths(path, start.path) === 0)
+    const root = coverage.rootHolding(path);
+    if (root)
+        return pathsEqual(root, path) ? 'middle' : 'outside';
+    if (coverage.startEdge && pathsEqual(path, start.path))
         return 'start';
-    if (comparePaths(path, end.path) === 0)
+    if (coverage.endEdge && pathsEqual(path, end.path))
         return 'end';
-    if (isPathBetween(path, start.path, end.path))
-        return 'middle';
     return 'outside';
 }
-/**
- * Whether this block paints the range over its whole box: the range holds its entire subtree and
- * no ancestor's box already covers it, or it is the whole unit a single-block range holds. Chrome
- * a container derives from its markers (a GitHub alert's badge) has no child host to paint it, so
- * the covering block takes the box in one piece and its children paint nothing.
- */
-export function blockPaintsWholeBox(path, selection, wholeUnitPath) {
+/** Whether the block paints the range over its whole box, so a container's own decoration (an
+ *  alert's badge), which no child host covers, is painted too; its children then paint nothing. */
+export function blockPaintsWholeBox(path, coverage, wholeUnitPath) {
     if (wholeUnitPath)
         return pathsEqual(path, wholeUnitPath);
-    const { start, end } = normalize(selection);
-    return (holdsSubtree(path, start.path, end.path) &&
-        !holdsSubtree(path.slice(0, -1), start.path, end.path));
+    const { start, end } = coverage.range;
+    if (pathsEqual(start.path, end.path))
+        return false;
+    const root = coverage.rootHolding(path);
+    return root !== null && pathsEqual(root, path);
+}
+/** The end-exclusive offsets an endpoint block measures its highlight between: a kept table
+ *  edge's cells, or its text from the start or up to the end. */
+export function endpointMeasureSpan(classification, coverage) {
+    const { startEdge, endEdge, startCells, endCells } = coverage;
+    const from = classification === 'end' ? 0 : (startCells?.from ?? textOffset(startEdge, 0));
+    const to = classification === 'start'
+        ? SELECTION_END
+        : (endCells?.to ?? textOffset(endEdge, SELECTION_END));
+    return { from, to };
 }
-/** The range holds this block's whole subtree: inside it in document order, and not an ancestor
- *  of the end endpoint, whose own descendants the range cuts through. */
-function holdsSubtree(path, start, end) {
-    return isPathBetween(path, start, end) && !isStrictAncestorOf(path, end);
+// A cell pair inside one table measures its rectangle, which reads no offset.
+function textOffset(edge, fallback) {
+    return edge && !edge.cellCoordinate ? charOffsetOf(edge, 'endpointMeasureSpan') : fallback;
 }

package/dist/selection/range-coverage.d.ts

@@ -0,0 +1,94 @@
+/**
+ * What a live range covers, decided once from the document so the delete, the copy and the
+ * overlay all read one answer. Every reader takes a `CoveredRange`, and only `coverRange` builds
+ * one, so no consumer can be handed a pair that skipped the rule; `rangeCoverage` then says which
+ * edges the range keeps a part of and which subtrees it holds whole.
+ */
+import type { DocumentView, NodeView } from '../core/node-views';
+import { type SelectionPoint } from './primitives';
+import { type DocPath } from './path-math';
+import { type CellRect } from '../cursor/coordinate-spaces';
+declare const SEAL: unique symbol;
+/** A live range in document order as every reader must see it: table endpoints snapped to whole
+ *  rows, and each closed container the range takes whole named in `wholeUnits`. */
+export declare class CoveredRange {
+    #private;
+    readonly start: SelectionPoint;
+    readonly end: SelectionPoint;
+    /** Collapsed containers taken whole, outermost only, in document order. */
+    readonly wholeUnits: readonly DocPath[];
+    /** Built by `coverRange` only, which holds the module-private key. */
+    constructor(key: typeof SEAL, start: SelectionPoint, end: SelectionPoint, wholeUnits: readonly DocPath[]);
+    /** The container in `wholeUnits` holding `path`, or null. */
+    unitHolding(path: readonly number[]): DocPath | null;
+}
+/** A half-open run of row-major cell indices inside one table. */
+export interface CellRun {
+    readonly from: number;
+    readonly to: number;
+}
+/** How much of a table a pair inside it holds: all of it, whole rows or columns, or less. */
+export type GridKind = 'table' | 'row' | 'column' | 'cells';
+/** The cells a pair inside one table holds, as a rectangle, and what that rectangle amounts to. */
+export type GridCoverage = {
+    [K in GridKind]: {
+        readonly kind: K;
+        readonly path: DocPath;
+        readonly rect: CellRect;
+    };
+}[GridKind];
+/** A same-path pair (a block held whole, a cell rectangle) is returned as is. A closed title row
+ *  the range starts on, or ends on past its first byte, takes its container whole. */
+export declare function coverRange(doc: DocumentView, a: SelectionPoint, b: SelectionPoint): CoveredRange;
+/** What a covered range holds, read once by the delete, the copy, the format toggle and the
+ *  overlay. Built by `rangeCoverage` only, so no consumer can be handed a hand-made answer. */
+export declare class RangeCoverage {
+    #private;
+    readonly range: CoveredRange;
+    /** The start block's kept head, from its first byte or cell to the start; null where the
+     *  range holds the block whole. */
+    readonly startEdge: SelectionPoint | null;
+    /** The end block's kept tail, from the end to its last byte or cell; null likewise. */
+    readonly endEdge: SelectionPoint | null;
+    /** Every subtree the range removes whole, outermost only, in document order. */
+    readonly wholeRoots: readonly DocPath[];
+    /** Every subtree whose bytes the range covers end to end, outermost only: the whole roots and
+     *  a kept edge at its block's first or last byte, with the containers they complete. */
+    readonly coveredWhole: readonly DocPath[];
+    /** For a pair inside one table, which of its cells the range holds; null otherwise. */
+    readonly grid: GridCoverage | null;
+    /** The cells a kept table edge hands to the range, as a half-open row-major run: from the
+     *  start's cell to the table's end, or from its first cell through the end's. */
+    readonly startCells: CellRun | null;
+    readonly endCells: CellRun | null;
+    /** Built by `rangeCoverage` only, which holds the module-private key. */
+    constructor(key: typeof SEAL, range: CoveredRange, fields: CoverageFields);
+    /** The whole root holding `path`, or null. */
+    rootHolding(path: readonly number[]): DocPath | null;
+    /** The subtree in `coveredWhole` holding `path`, or null. */
+    coveredRootHolding(path: readonly number[]): DocPath | null;
+}
+/** A text edge always keeps its head or tail, even an empty one; a block with no character
+ *  position, a table from its first or to its last row, or a whole unit keeps none. */
+export declare function rangeCoverage(doc: DocumentView, range: CoveredRange): RangeCoverage;
+/** Every block path strictly between `start` and `end`, at every nesting level, in document
+ *  order; an ancestor of `end` counts, since it starts before `end` does. */
+export declare function walkBetween(doc: DocumentView, start: readonly number[], end: readonly number[]): number[][];
+/** A container whose kind reserves its first child as a title row (a details block's summary). */
+export interface ChromeContainer {
+    path: number[];
+    node: NodeView;
+}
+/** The deepest strict ancestor of `path` whose kind reserves a title row. */
+export declare function nearestChromeContainer(doc: DocumentView, path: readonly number[]): ChromeContainer | null;
+export declare function isChromeChild(container: ChromeContainer, leafPath: readonly number[]): boolean;
+interface CoverageFields {
+    startEdge: SelectionPoint | null;
+    endEdge: SelectionPoint | null;
+    wholeRoots: readonly DocPath[];
+    coveredWhole: readonly DocPath[];
+    grid: GridCoverage | null;
+    startCells: CellRun | null;
+    endCells: CellRun | null;
+}
+export {};

package/dist/selection/range-coverage.js

@@ -0,0 +1,365 @@
+/**
+ * What a live range covers, decided once from the document so the delete, the copy and the
+ * overlay all read one answer. Every reader takes a `CoveredRange`, and only `coverRange` builds
+ * one, so no consumer can be handed a pair that skipped the rule; `rangeCoverage` then says which
+ * edges the range keeps a part of and which subtrees it holds whole.
+ */
+import { displayLength } from '../core/lines';
+import { metadataOf } from '../core/nodes';
+import { cellIndexOf, normalize } from './primitives';
+import { snapCrossBlockTableEndpoints } from './table-endpoint-snap';
+import { collapsedContainerHiding } from './path-lookup';
+import { comparePaths, isPathBetween, isPathSubtreeBetween, pathHasPrefix, pathsEqual } from './path-math';
+import { cellRectBounds, docPathFrom } from '../cursor/coordinate-spaces';
+import { isBlockNode, nodeAt } from '../tree-operations/node-primitives';
+import { isBlankParagraph } from '../core/parser';
+import { countsCells, isGridKind, tableCellCount } from '../schema/block-kind-descriptor';
+import { isWholeBlockUnit } from '../schema/whole-block-unit';
+import { isCollapsedContainer, isReservedChromeChild, reservedChromeKindOf } from '../schema/reserved-chrome';
+const SEAL = Symbol('coverRange');
+/** A live range in document order as every reader must see it: table endpoints snapped to whole
+ *  rows, and each closed container the range takes whole named in `wholeUnits`. */
+export class CoveredRange {
+    // Never read: the private field makes the type nominal, so a spread or a literal isn't one.
+    // eslint-disable-next-line no-unused-private-class-members
+    #covered = true;
+    start;
+    end;
+    /** Collapsed containers taken whole, outermost only, in document order. */
+    wholeUnits;
+    /** Built by `coverRange` only, which holds the module-private key. */
+    constructor(key, start, end, wholeUnits) {
+        if (key !== SEAL)
+            throw new Error('a CoveredRange is built by coverRange');
+        this.start = start;
+        this.end = end;
+        this.wholeUnits = wholeUnits;
+        Object.freeze(this);
+    }
+    /** The container in `wholeUnits` holding `path`, or null. */
+    unitHolding(path) {
+        return this.wholeUnits.find((unit) => pathHasPrefix(path, unit)) ?? null;
+    }
+}
+/** A same-path pair (a block held whole, a cell rectangle) is returned as is. A closed title row
+ *  the range starts on, or ends on past its first byte, takes its container whole. */
+export function coverRange(doc, a, b) {
+    const ordered = normalize({ anchor: a, focus: b });
+    if (pathsEqual(ordered.start.path, ordered.end.path)) {
+        return sealed(ordered.start, ordered.end, []);
+    }
+    const { start, end } = snapCrossBlockTableEndpoints(doc, ordered.start, ordered.end);
+    const units = [];
+    const startUnit = closedTitleOwner(doc, start.path);
+    if (startUnit)
+        units.push(startUnit);
+    const endUnit = end.offset > 0 ? closedTitleOwner(doc, end.path) : null;
+    if (endUnit)
+        units.push(endUnit);
+    return sealed(start, end, units);
+}
+/** What a covered range holds, read once by the delete, the copy, the format toggle and the
+ *  overlay. Built by `rangeCoverage` only, so no consumer can be handed a hand-made answer. */
+export class RangeCoverage {
+    // Private, so the type is nominal as `CoveredRange` is; keyed so a lookup costs the path's depth.
+    #wholeByKey;
+    #coveredByKey;
+    range;
+    /** The start block's kept head, from its first byte or cell to the start; null where the
+     *  range holds the block whole. */
+    startEdge;
+    /** The end block's kept tail, from the end to its last byte or cell; null likewise. */
+    endEdge;
+    /** Every subtree the range removes whole, outermost only, in document order. */
+    wholeRoots;
+    /** Every subtree whose bytes the range covers end to end, outermost only: the whole roots and
+     *  a kept edge at its block's first or last byte, with the containers they complete. */
+    coveredWhole;
+    /** For a pair inside one table, which of its cells the range holds; null otherwise. */
+    grid;
+    /** The cells a kept table edge hands to the range, as a half-open row-major run: from the
+     *  start's cell to the table's end, or from its first cell through the end's. */
+    startCells;
+    endCells;
+    /** Built by `rangeCoverage` only, which holds the module-private key. */
+    constructor(key, range, fields) {
+        if (key !== SEAL)
+            throw new Error('a RangeCoverage is built by rangeCoverage');
+        this.range = range;
+        this.startEdge = fields.startEdge;
+        this.endEdge = fields.endEdge;
+        this.wholeRoots = fields.wholeRoots;
+        this.coveredWhole = fields.coveredWhole;
+        this.grid = fields.grid;
+        this.startCells = fields.startCells;
+        this.endCells = fields.endCells;
+        this.#wholeByKey = byKey(fields.wholeRoots);
+        this.#coveredByKey = byKey(fields.coveredWhole);
+        Object.freeze(this);
+    }
+    /** The whole root holding `path`, or null. */
+    rootHolding(path) {
+        return rootAmong(this.#wholeByKey, path);
+    }
+    /** The subtree in `coveredWhole` holding `path`, or null. */
+    coveredRootHolding(path) {
+        return rootAmong(this.#coveredByKey, path);
+    }
+}
+/** A text edge always keeps its head or tail, even an empty one; a block with no character
+ *  position, a table from its first or to its last row, or a whole unit keeps none. */
+export function rangeCoverage(doc, range) {
+    const { start, end } = range;
+    if (pathsEqual(start.path, end.path)) {
+        return new RangeCoverage(SEAL, range, samePathCoverage(doc, start, end));
+    }
+    const held = walkBetween(doc, start.path, end.path).filter((p) => isPathSubtreeBetween(p, start.path, end.path));
+    for (const unit of range.wholeUnits)
+        held.push(unit);
+    const startHeld = range.unitHolding(start.path) !== null || edgeHeld(doc, start, 'start');
+    const endHeld = range.unitHolding(end.path) !== null || endConsumed(doc, range);
+    if (startHeld)
+        held.push(start.path);
+    if (endHeld)
+        held.push(end.path);
+    // A kept edge still hands over every byte of its block when it sits on that block's edge.
+    const covered = held.slice();
+    if (!startHeld && edgeCoversBlock(doc, start, 'start'))
+        covered.push(start.path);
+    if (!endHeld && edgeCoversBlock(doc, end, 'end'))
+        covered.push(end.path);
+    return new RangeCoverage(SEAL, range, {
+        startEdge: startHeld ? null : start,
+        endEdge: endHeld ? null : end,
+        wholeRoots: outermost(withWholeParents(doc, held)),
+        coveredWhole: outermost(withWholeParents(doc, covered)),
+        grid: null,
+        startCells: startHeld ? null : keptTableRun(doc, start, 'start'),
+        endCells: endHeld ? null : keptTableRun(doc, end, 'end')
+    });
+}
+/** Every block path strictly between `start` and `end`, at every nesting level, in document
+ *  order; an ancestor of `end` counts, since it starts before `end` does. */
+export function walkBetween(doc, start, end) {
+    if (comparePaths(start, end) >= 0)
+        return [];
+    const result = [];
+    const visit = (node, path) => {
+        if (isPathBetween(path, start, end))
+            result.push([...path]);
+        const children = node.children ?? [];
+        for (let i = 0; i < children.length; i++) {
+            const childPath = [...path, i];
+            // Skip subtrees entirely before start (an ancestor of start still holds it) or after end.
+            if (!pathHasPrefix(start, childPath) && comparePaths(childPath, start) < 0)
+                continue;
+            if (comparePaths(childPath, end) >= 0)
+                break;
+            visit(children[i], childPath);
+        }
+    };
+    visit(doc, []);
+    return result;
+}
+/** The deepest strict ancestor of `path` whose kind reserves a title row. */
+export function nearestChromeContainer(doc, path) {
+    let found = null;
+    let children = doc.children;
+    for (let i = 0; i < path.length - 1; i++) {
+        const node = children[path[i]];
+        if (!node)
+            break;
+        if (reservedChromeKindOf(node.kind) !== undefined)
+            found = { path: path.slice(0, i + 1), node };
+        children = node.children ?? [];
+    }
+    return found;
+}
+export function isChromeChild(container, leafPath) {
+    return (leafPath.length === container.path.length + 1 &&
+        isReservedChromeChild(container.node, leafPath[container.path.length]));
+}
+// ── Internal ────────────────────────────────────────────────────────────────
+function sealed(start, end, wholeUnits) {
+    return new CoveredRange(SEAL, start, end, wholeUnits);
+}
+/** The collapsed container whose title row `path` is; null for a row inside another container's
+ *  hidden body, since the range already covers what follows it. */
+function closedTitleOwner(doc, path) {
+    if (path.length < 2)
+        return null;
+    const ownerPath = path.slice(0, -1);
+    const owner = nodeAt(doc, ownerPath);
+    if (!owner || !isBlockNode(owner))
+        return null;
+    if (!isReservedChromeChild(owner, path[path.length - 1]) || !isCollapsedContainer(owner)) {
+        return null;
+    }
+    return collapsedContainerHiding(doc, ownerPath) ? null : docPathFrom(ownerPath);
+}
+function samePathCoverage(doc, start, end) {
+    const node = nodeAt(doc, start.path);
+    const path = docPathFrom(start.path);
+    if (node && isBlockNode(node) && countsCells(node) && start.cellCoordinate) {
+        const grid = gridCoverage(node, path, start.offset, end.offset);
+        return grid.kind === 'table' ? heldWhole(path, grid) : { ...kept(start, end), grid };
+    }
+    // A paragraph emptied stays as the blank line between its neighbours; another kind emptied
+    // reads back as no block of that kind at all, so it goes.
+    const heldAsUnit = node !== null &&
+        isBlockNode(node) &&
+        start.offset === 0 &&
+        end.offset >= displayLength(node.raw) &&
+        !isBlankParagraph({ kind: node.kind, raw: '' });
+    return heldAsUnit ? heldWhole(path, null) : kept(start, end);
+}
+function kept(start, end) {
+    return {
+        startEdge: start,
+        endEdge: end,
+        wholeRoots: [],
+        coveredWhole: [],
+        grid: null,
+        startCells: null,
+        endCells: null
+    };
+}
+function heldWhole(path, grid) {
+    return {
+        startEdge: null,
+        endEdge: null,
+        wholeRoots: [path],
+        coveredWhole: [path],
+        grid,
+        startCells: null,
+        endCells: null
+    };
+}
+/** The cells a kept table edge's side of the range spans; null for an edge that isn't a table. */
+function keptTableRun(doc, point, side) {
+    const node = nodeAt(doc, point.path);
+    if (!node || !isBlockNode(node) || !countsCells(node))
+        return null;
+    const cell = cellIndexOf(point, 'rangeCoverage:tableEdge');
+    return side === 'start' ? { from: cell, to: tableCellCount(node) } : { from: 0, to: cell + 1 };
+}
+/** A whole table beats the row or column that spans it (a one-row or one-column table). */
+function gridCoverage(table, path, a, b) {
+    const columnCount = metadataOf(table, 'table').columnCount;
+    const rowCount = table.children?.length ?? 0;
+    const rect = cellRectBounds(a, b, columnCount);
+    const fullWidth = rect.left === 0 && rect.cols === columnCount;
+    const fullHeight = rect.top === 0 && rect.rows === rowCount;
+    const kind = fullWidth && fullHeight
+        ? 'table'
+        : fullWidth && rect.rows === 1
+            ? 'row'
+            : fullHeight && rect.cols === 1
+                ? 'column'
+                : 'cells';
+    return { kind, path, rect };
+}
+/** An edge holds its block whole when nothing of it lies outside the range. A character offset on
+ *  a plugin grid's own path addresses no cell, so it reads as the grid's edge. */
+function edgeHeld(doc, point, side) {
+    const node = nodeAt(doc, point.path);
+    if (!node || !isBlockNode(node))
+        return false;
+    if (countsCells(node)) {
+        return point.offset === (side === 'start' ? 0 : tableCellCount(node) - 1);
+    }
+    if (isGridKind(node.kind))
+        return true;
+    if (!isWholeBlockUnit(node))
+        return false;
+    return side === 'start' ? point.offset === 0 : point.offset >= displayLength(node.raw);
+}
+/** A text edge at its block's first byte (a start) or last (an end), so a copy takes the block. */
+function edgeCoversBlock(doc, point, side) {
+    if (point.cellCoordinate)
+        return false;
+    const node = nodeAt(doc, point.path);
+    if (!node || !isBlockNode(node))
+        return false;
+    return side === 'start' ? point.offset === 0 : point.offset >= displayLength(node.raw);
+}
+/** The end holds its block whole as a start does, and also on the last byte of a title-line
+ *  container's last block with the start outside it, since nothing merges across that edge. */
+function endConsumed(doc, range) {
+    const { start, end } = range;
+    if (edgeHeld(doc, end, 'end'))
+        return true;
+    const container = nearestChromeContainer(doc, end.path);
+    if (!container || pathHasPrefix(start.path, container.path))
+        return false;
+    const node = lastChildDescendant(container, end.path);
+    return node !== null && 'raw' in node && end.offset >= displayLength(node.raw);
+}
+/** The node at `path` when every step down from the container is a last child, else null. */
+function lastChildDescendant(container, path) {
+    let node = container.node;
+    for (let i = container.path.length; i < path.length; i++) {
+        const children = node.children ?? [];
+        if (path[i] !== children.length - 1)
+            return null;
+        node = children[path[i]];
+    }
+    return node;
+}
+/** `held` plus every container all of whose children it holds, up to the document, each once. */
+function withWholeParents(doc, held) {
+    const all = [];
+    const keys = new Set();
+    const add = (path) => {
+        const key = pathKey(path);
+        if (keys.has(key))
+            return;
+        keys.add(key);
+        all.push(path.slice());
+    };
+    held.forEach(add);
+    // Each container counts its held children as they arrive, so it is found whole in one pass.
+    const heldChildren = new Map();
+    for (let i = 0; i < all.length; i++) {
+        const parentPath = all[i].slice(0, -1);
+        if (parentPath.length === 0)
+            continue;
+        const parentKey = pathKey(parentPath);
+        let tally = heldChildren.get(parentKey);
+        if (!tally) {
+            tally = { held: 0, of: nodeAt(doc, parentPath)?.children?.length ?? 0 };
+            heldChildren.set(parentKey, tally);
+        }
+        if (++tally.held === tally.of)
+            add(parentPath);
+    }
+    return all;
+}
+/** The paths no other path holds, each once, in document order. */
+function outermost(paths) {
+    const roots = [];
+    // Document order puts every path a root holds right behind it, so only the last root can hold one.
+    for (const path of paths.slice().sort(comparePaths)) {
+        const last = roots.at(-1);
+        if (!last || !pathHasPrefix(path, last))
+            roots.push(docPathFrom(path));
+    }
+    return roots;
+}
+function byKey(roots) {
+    return new Map(roots.map((root) => [pathKey(root), root]));
+}
+/** The root in `roots` that is `path` or one of its ancestors; roots never nest, so at most one. */
+function rootAmong(roots, path) {
+    let key = '';
+    for (let depth = 0; depth < path.length; depth++) {
+        key = depth === 0 ? `${path[0]}` : `${key}.${path[depth]}`;
+        const root = roots.get(key);
+        if (root)
+            return root;
+    }
+    return null;
+}
+function pathKey(path) {
+    return path.join('.');
+}