@voithos-labs/aragonite 0.10.4 → 0.10.7

package/dist/selection/shared-keydown.js

@@ -1,41 +1,29 @@
 /**
  * Shared keydown prelude for contenteditable blocks: Ctrl+A counter, cross-block dispatch,
- * sticky-column capture/reset, undo/redo, arrow boundary navigation. Block-specific handlers
+ * the caret memory's key note, undo/redo, arrow boundary navigation. Block-specific handlers
  * (Enter, Backspace, Tab, formatting) stay in each component.
  */
+import { commandAtBlock } from './cross-block/keydown';
 import { extendFocusToNextBlock, extendFocusToPreviousBlock, scrollFocusBlockIntoView } from './keyboard-extend';
 import { getCurrentCursorEditorRelativeX } from '../cursor/sticky-measure';
 import { landableRawBounds } from '../cursor/widget-offset';
 import { isAtFirstVisualLine, isAtLastVisualLine } from '../cursor/visual-lines';
-import { eventToChord } from '../schema/keybindings';
+import { endsSelectAllRun, eventToChord } from '../schema/keybindings';
 import { isDefaultGlobalChord } from '../schema/commands';
 /** True when the event was fully handled; the caller must skip its block-specific branches. */
 export async function handleSharedKeydown(e, ctx) {
-    // Bare modifier keys don't reset the Ctrl+A doubling counter: pressing Control before 'a' is
-    // part of the chord, not a separate action.
-    const isCtrlA = (e.ctrlKey || e.metaKey) && e.key === 'a' && !e.shiftKey;
-    const isBareModifier = e.key === 'Control' ||
-        e.key === 'Shift' ||
-        e.key === 'Alt' ||
-        e.key === 'Meta' ||
-        e.key === 'AltGraph' ||
-        e.key === 'CapsLock';
-    if (!isCtrlA && !isBareModifier) {
+    if (endsSelectAllRun(e))
         ctx.selection.resetSelectAllCount();
-    }
     if (await ctx.crossBlock.handleKeyDown(e))
         return true;
     const el = ctx.getEl();
     if (!el)
         return false;
-    ctx.stickyColumn.noteKey(e, () => getCurrentCursorEditorRelativeX(el));
-    ctx.edgeAffinity.note(e);
-    // Native contenteditable history stays suppressed on keydown, since Ctrl+Y doesn't fire
-    // beforeinput historyRedo in Chromium/WebView2. The DEFAULT table is the right question here:
-    // it names the chords with a native history default, and running the command is the block's
-    // own override-aware dispatch, one branch further on.
+    ctx.caretMemory.noteKey(e, commandAtBlock(e, ctx), () => getCurrentCursorEditorRelativeX(el));
+    // Ctrl+Y fires no `historyRedo` beforeinput in Chromium and WebView2, so every chord with a
+    // native history default is suppressed here; the block's own dispatch runs the command.
     const historyChord = eventToChord(e);
-    if (historyChord && isDefaultGlobalChord(historyChord, ctx.activePlugins)) {
+    if (historyChord && isDefaultGlobalChord(historyChord, ctx.commands.activation)) {
         e.preventDefault();
         return false;
     }
@@ -51,13 +39,13 @@ export async function handleSharedKeydown(e, ctx) {
     const shiftOffset = e.shiftKey ? ctx.getFocusOffset() : null;
     if (e.key === 'ArrowUp') {
         const offset = shiftOffset ?? ctx.getCursorOffset() ?? 0;
-        if (isAtFirstVisualLine(el, offset, bounds().start)) {
+        if (isAtFirstVisualLine(el, offset, bounds())) {
             // Cross the boundary only when focus is already at the block's first reachable
             // offset, so native Shift+ArrowUp extension has nowhere left to go within it.
             if (e.shiftKey && offset <= bounds().start) {
                 e.preventDefault();
-                extendFocusToPreviousBlock(ctx.selection, ctx.getDoc(), el, myPath, 'start');
-                scrollFocusBlockIntoView(ctx.selection, ctx.getBlockElByPath);
+                extendFocusToPreviousBlock(ctx.selection, ctx.getDoc(), ctx.reading.grammar, el, myPath, 'start');
+                scrollFocusBlockIntoView(ctx.selection, ctx.scrollOwner);
                 return true;
             }
             if (!e.shiftKey && !e.altKey) {
@@ -69,13 +57,13 @@ export async function handleSharedKeydown(e, ctx) {
     }
     if (e.key === 'ArrowDown') {
         const offset = shiftOffset ?? ctx.getCursorOffset() ?? 0;
-        if (isAtLastVisualLine(el, offset, bounds().end)) {
+        if (isAtLastVisualLine(el, offset, bounds())) {
             // Cross the boundary only when focus is already at the block's last reachable
             // offset, so native Shift+ArrowDown extension has nowhere left to go.
             if (e.shiftKey && offset >= bounds().end) {
                 e.preventDefault();
-                extendFocusToNextBlock(ctx.selection, ctx.getDoc(), el, myPath, 'vertical');
-                scrollFocusBlockIntoView(ctx.selection, ctx.getBlockElByPath);
+                extendFocusToNextBlock(ctx.selection, ctx.getDoc(), ctx.reading.grammar, el, myPath, 'vertical');
+                scrollFocusBlockIntoView(ctx.selection, ctx.scrollOwner);
                 return true;
             }
             if (!e.shiftKey && !e.altKey) {
@@ -86,15 +74,14 @@ export async function handleSharedKeydown(e, ctx) {
         }
     }
     if (e.key === 'ArrowLeft') {
-        // Shift+Arrow reads focus, not anchor: getCursorOffset() gives the range start, which is
-        // the anchor for a forward selection. That would extend cross-block while focus is
-        // contracting toward a non-zero anchor, and misfire for backward selections.
+        // Shift+Arrow reads the focus, since `getCursorOffset()` gives the range start: the anchor
+        // of a forward selection, which would extend across blocks while the focus contracts.
         const offset = e.shiftKey ? (ctx.getFocusOffset() ?? bounds().start) : ctx.getCursorOffset();
         if (offset !== null && offset <= bounds().start) {
             if (e.shiftKey) {
                 e.preventDefault();
-                extendFocusToPreviousBlock(ctx.selection, ctx.getDoc(), el, myPath);
-                scrollFocusBlockIntoView(ctx.selection, ctx.getBlockElByPath);
+                extendFocusToPreviousBlock(ctx.selection, ctx.getDoc(), ctx.reading.grammar, el, myPath);
+                scrollFocusBlockIntoView(ctx.selection, ctx.scrollOwner);
                 return true;
             }
             e.preventDefault();
@@ -107,8 +94,8 @@ export async function handleSharedKeydown(e, ctx) {
         if (offset !== null && offset >= bounds().end) {
             if (e.shiftKey) {
                 e.preventDefault();
-                extendFocusToNextBlock(ctx.selection, ctx.getDoc(), el, myPath);
-                scrollFocusBlockIntoView(ctx.selection, ctx.getBlockElByPath);
+                extendFocusToNextBlock(ctx.selection, ctx.getDoc(), ctx.reading.grammar, el, myPath);
+                scrollFocusBlockIntoView(ctx.selection, ctx.scrollOwner);
                 return true;
             }
             e.preventDefault();
@@ -118,21 +105,14 @@ export async function handleSharedKeydown(e, ctx) {
     }
     return false;
 }
-/**
- * The raw offsets a caret can actually reach in this block, from the walk that decides where a
- * caret lands. A mode that hides a block's own markers with no reveal puts those bytes out of
- * reach, so the exits move in to what the DOM can land — the kind's declared content range is
- * not that bound: paragraph, fenced code and table cell each declare the whole raw and still
- * open or close with a run nothing paints. Every block-edge gate reads this, not 0/length.
- */
+/** The raw offsets a caret can reach in the block, from the same walk that places it: hidden
+ *  markers put bytes out of reach, so every block-edge check reads this, not 0 and length. */
 export function caretLandableBounds(ctx, el) {
-    return landableRawBounds(el, ctx.getAmbientLength()) ?? { start: 0, end: ctx.getTextLen() };
+    return landableRawBounds(el) ?? { start: 0, end: ctx.getTextLen() };
 }
 // ── Shared beforeinput prelude ─────────────────────────────────────────────
-/**
- * Routes historyUndo/historyRedo through the undo controller and delegates cross-block
- * paste/type-replace. True when the caller should return early from its own `onBeforeInput`.
- */
+/** Routes historyUndo/historyRedo through the undo controller and delegates cross-block paste
+ *  and typing; true when the caller should return early from its own `onBeforeInput`. */
 export async function handleSharedBeforeInput(e, ctx) {
     if (e.inputType === 'historyUndo') {
         e.preventDefault();

package/dist/selection/table-endpoint-snap.d.ts

@@ -1,53 +1,29 @@
 /**
- * The cell-index space a selection endpoint inside a grid lives in. Offsets are INCLUSIVE cell
- * indices, the space SelectionPoint already uses. The whole-row snap and the two metadata reads
- * answer for a table alone; the coverage tenants answer for any `containerContract: 'grid'` kind.
- * An intra-table pair is deliberately left unsnapped, so rectangular sub-cell selection survives.
+ * The cell-index space a selection endpoint inside a grid lives in. Offsets are inclusive cell
+ * indices, and every endpoint on a table path carries `cellCoordinate`. The whole-row snap and
+ * the metadata reads are for tables only; the cell lists serve any `containerContract: 'grid'`
+ * kind. A pair inside one table is left unsnapped, so a rectangle of cells can be selected.
  */
 import type { DocumentView, NodeView } from '../core/node-views';
-import type { SelectionPoint } from './primitives';
-/**
- * The char→cell conversion funnel: a cross-block endpoint inside a table must address the table
- * block by row-major cell index, or a deep `[tableIdx, row, col]` path with a char offset routes
- * the delete down the generic branch and corrupts the grid. SelectionState applies this to every
- * incoming point, so entry paths never call it themselves. Non-table paths pass through.
- */
+import type { CellSelectionPoint, SelectionPoint } from './primitives';
+import { type CellRect } from '../cursor/coordinate-spaces';
+/** The one conversion into cell space, which `SelectionState` applies to every incoming point: an
+ *  endpoint on or inside a table becomes the table path plus a flagged row-major cell index. */
 export declare function normalizeTableEndpoint(doc: DocumentView, path: number[], offset: number): SelectionPoint;
-/**
- * How many cells a table's index space holds, the exclusive upper bound on any row-major cell
- * index. `node` must be a table block; the metadata read is unchecked, so other kinds give NaN.
- * Lives beside the bounds check below so a caller's clamp and the check cannot drift apart.
- */
-export declare function tableCellCount(node: NodeView): number;
+/** A table taken whole, as the cell on one side of it; null when `path` names no table. */
+export declare function wholeTableEndpoint(doc: DocumentView, path: number[], side: 'start' | 'end'): CellSelectionPoint | null;
 /** One cell of a grid, with the doc-absolute path that addresses it. */
 export interface GridCell {
     node: NodeView;
     path: number[];
 }
-/**
- * `point`'s index in `grid`'s cell space, null where it addresses no cell of it — the side the
- * range runs past, which reads as the grid's own edge. A table's endpoint arrives on the grid path
- * already carrying the index; a plugin grid's keeps the deep `[grid, row, col]` path G1.29 permits,
- * and resolves through the same width {@link coveredGridCells} decodes with.
- */
-export declare function gridEndpointCellIndex(grid: NodeView, gridPath: number[], point: SelectionPoint): number | null;
-/**
- * The cells a range covers inside one grid, in document order. `from`/`to` are the range's own cell
- * indices IN DOCUMENT ORDER (`from <= to`; unordered inputs answer with fewer cells or none), null
- * on a side the range runs past. Both inside is the RECTANGLE they span — what the overlay paints
- * and `range-delete-table` clears; one inside is a run to that cell inclusive. Rows of cells is the
- * whole shape asked: children that are not rows of cells answer with no cells, rows of unequal
- * width with the wrong cells or none, every index being row 0's width.
- */
-export declare function coveredGridCells(grid: NodeView, gridPath: number[], from: number | null, to: number | null): GridCell[];
-/**
- * Inverse of {@link normalizeTableEndpoint}: expand an endpoint addressing a table block to its
- * deep `[tableIdx, row, col]` leaf path so reveal/caret placement reaches an off-window cell.
- * Null when the path is already a leaf or the index lands outside the grid. Resolution is on the
- * NODE KIND, not the `cellCoordinate` flag: an intra-table focus is unflagged (see
- * {@link SelectionPoint}) yet still a cell index. Callers reach it through
- * `SelectionState.cellLandingFor`, which is where the landing rule lives.
- */
+/** The cells of `rect` inside one grid, row by row. */
+export declare function gridCellsInRect(grid: NodeView, gridPath: number[], rect: CellRect): GridCell[];
+/** The cells a run covers inside one grid, in row-major order, a null side running to the grid's
+ *  edge. Rows must share row 0's width. */
+export declare function gridCellsInRun(grid: NodeView, gridPath: number[], from: number | null, to: number | null): GridCell[];
+/** The inverse of {@link normalizeTableEndpoint}: a cell endpoint's `[tableIdx, row, col]` leaf
+ *  path, or null. Reach it through `SelectionState.cellLandingFor`. */
 export declare function cellEndpointDeepPath(doc: DocumentView, point: SelectionPoint): number[] | null;
 export declare function snapCrossBlockTableEndpoints(doc: DocumentView, start: SelectionPoint, end: SelectionPoint): {
     start: SelectionPoint;

package/dist/selection/table-endpoint-snap.js

@@ -1,77 +1,60 @@
 /**
- * The cell-index space a selection endpoint inside a grid lives in. Offsets are INCLUSIVE cell
- * indices, the space SelectionPoint already uses. The whole-row snap and the two metadata reads
- * answer for a table alone; the coverage tenants answer for any `containerContract: 'grid'` kind.
- * An intra-table pair is deliberately left unsnapped, so rectangular sub-cell selection survives.
+ * The cell-index space a selection endpoint inside a grid lives in. Offsets are inclusive cell
+ * indices, and every endpoint on a table path carries `cellCoordinate`. The whole-row snap and
+ * the metadata reads are for tables only; the cell lists serve any `containerContract: 'grid'`
+ * kind. A pair inside one table is left unsnapped, so a rectangle of cells can be selected.
  */
 import { metadataOf } from '../core/nodes';
-import { isBlockNode, nodeAt } from '../tree-operations/node-primitives';
-import { cellIndexOf } from './primitives';
-import { asCellIndex, cellRowCol } from '../cursor/coordinate-spaces';
-import { comparePaths, pathHasPrefix } from './path-math';
+import { nodeAt } from '../tree-operations/node-primitives';
+import { clampCellIndex, countsCells, tableCellCount } from '../schema/block-kind-descriptor';
+import { cellIndexOf, cellPoint } from './primitives';
+import { asCellIndex, rowMajorCellIndex, cellRowCol } from '../cursor/coordinate-spaces';
+import { comparePaths } from './path-math';
 import { devWarn } from '../dev-warn';
-/**
- * The char→cell conversion funnel: a cross-block endpoint inside a table must address the table
- * block by row-major cell index, or a deep `[tableIdx, row, col]` path with a char offset routes
- * the delete down the generic branch and corrupts the grid. SelectionState applies this to every
- * incoming point, so entry paths never call it themselves. Non-table paths pass through.
- */
+/** The one conversion into cell space, which `SelectionState` applies to every incoming point: an
+ *  endpoint on or inside a table becomes the table path plus a flagged row-major cell index. */
 export function normalizeTableEndpoint(doc, path, offset) {
-    for (let d = 0; d < path.length - 1; d++) {
-        const node = nodeAt(doc, path.slice(0, d + 1));
-        if (node && isBlockNode(node) && node.kind === 'table') {
-            const colCount = metadataOf(node, 'table').columnCount;
-            const rowIdx = path[d + 1];
-            const colIdx = path[d + 2] ?? 0;
-            return {
-                path: path.slice(0, d + 1),
-                offset: asCellIndex(rowIdx * colCount + colIdx),
-                cellCoordinate: true
-            };
-        }
+    for (let d = 0; d < path.length; d++) {
+        const tablePath = path.slice(0, d + 1);
+        const node = nodeAt(doc, tablePath);
+        if (!node || !countsCells(node))
+            continue;
+        // On the table's own path the offset is already the cell index.
+        if (d === path.length - 1)
+            return cellPoint(tablePath, clampCellIndex(node, offset));
+        const colCount = metadataOf(node, 'table').columnCount;
+        return cellPoint(tablePath, rowMajorCellIndex(path[d + 1], path[d + 2] ?? 0, colCount));
     }
     return { path: path.slice(), offset };
 }
-/**
- * How many cells a table's index space holds, the exclusive upper bound on any row-major cell
- * index. `node` must be a table block; the metadata read is unchecked, so other kinds give NaN.
- * Lives beside the bounds check below so a caller's clamp and the check cannot drift apart.
- */
-export function tableCellCount(node) {
-    return (node.children?.length ?? 0) * metadataOf(node, 'table').columnCount;
+/** A table taken whole, as the cell on one side of it; null when `path` names no table. */
+export function wholeTableEndpoint(doc, path, side) {
+    const node = nodeAt(doc, path);
+    if (!node || !countsCells(node))
+        return null;
+    const offset = side === 'end' ? clampCellIndex(node, Infinity) : 0;
+    return cellPoint(path, offset);
 }
-/** A grid's own width, row 0's cell count — not `metadata.columnCount`: `containerContract: 'grid'`
- *  is a plugin contract, and a kind with no table metadata reaches here. A column mutation splices
- *  each row and the count together, so the two agree on a table. */
+/** A grid's width as row 0's cell count, not `metadata.columnCount`: a plugin grid kind has no
+ *  table metadata. On a table the two agree, since a column edit changes both together. */
 function gridColumnCount(grid) {
     return grid.children?.[0]?.children?.length ?? 0;
 }
-/**
- * `point`'s index in `grid`'s cell space, null where it addresses no cell of it — the side the
- * range runs past, which reads as the grid's own edge. A table's endpoint arrives on the grid path
- * already carrying the index; a plugin grid's keeps the deep `[grid, row, col]` path G1.29 permits,
- * and resolves through the same width {@link coveredGridCells} decodes with.
- */
-export function gridEndpointCellIndex(grid, gridPath, point) {
-    if (!pathHasPrefix(point.path, gridPath))
-        return null;
-    // On the grid's own path, resolution is the NODE KIND's, not the flag's ({@link
-    // cellEndpointDeepPath}): a table path IS cell space, so an intra-table rectangle's unflagged
-    // corner counts cells, while any other grid holds a char offset addressing no cell.
-    if (point.path.length === gridPath.length)
-        return point.cellCoordinate || grid.kind === 'table' ? point.offset : null;
-    const [row, col = 0] = point.path.slice(gridPath.length);
-    return row * gridColumnCount(grid) + col;
+/** The cells of `rect` inside one grid, row by row. */
+export function gridCellsInRect(grid, gridPath, rect) {
+    const cells = [];
+    for (let row = rect.top; row < rect.top + rect.rows; row++) {
+        for (let col = rect.left; col < rect.left + rect.cols; col++) {
+            const node = grid.children?.[row]?.children?.[col];
+            if (node)
+                cells.push({ node, path: [...gridPath, row, col] });
+        }
+    }
+    return cells;
 }
-/**
- * The cells a range covers inside one grid, in document order. `from`/`to` are the range's own cell
- * indices IN DOCUMENT ORDER (`from <= to`; unordered inputs answer with fewer cells or none), null
- * on a side the range runs past. Both inside is the RECTANGLE they span — what the overlay paints
- * and `range-delete-table` clears; one inside is a run to that cell inclusive. Rows of cells is the
- * whole shape asked: children that are not rows of cells answer with no cells, rows of unequal
- * width with the wrong cells or none, every index being row 0's width.
- */
-export function coveredGridCells(grid, gridPath, from, to) {
+/** The cells a run covers inside one grid, in row-major order, a null side running to the grid's
+ *  edge. Rows must share row 0's width. */
+export function gridCellsInRun(grid, gridPath, from, to) {
     const rows = grid.children ?? [];
     const colCount = gridColumnCount(grid);
     if (rows.length === 0 || colCount < 1)
@@ -80,15 +63,10 @@ export function coveredGridCells(grid, gridPath, from, to) {
     const clamp = (index) => Math.min(Math.max(index, 0), lastIndex);
     const first = cellRowCol(asCellIndex(clamp(from ?? 0)), colCount);
     const last = cellRowCol(asCellIndex(clamp(to ?? lastIndex)), colCount);
-    const rectangle = from !== null && to !== null;
     const cells = [];
     for (let row = first.row; row <= last.row; row++) {
-        const startCol = rectangle ? Math.min(first.col, last.col) : row === first.row ? first.col : 0;
-        const endCol = rectangle
-            ? Math.max(first.col, last.col)
-            : row === last.row
-                ? last.col
-                : colCount - 1;
+        const startCol = row === first.row ? first.col : 0;
+        const endCol = row === last.row ? last.col : colCount - 1;
         for (let col = startCol; col <= endCol; col++) {
             const node = rows[row]?.children?.[col];
             if (node)
@@ -97,17 +75,13 @@ export function coveredGridCells(grid, gridPath, from, to) {
     }
     return cells;
 }
-/**
- * Inverse of {@link normalizeTableEndpoint}: expand an endpoint addressing a table block to its
- * deep `[tableIdx, row, col]` leaf path so reveal/caret placement reaches an off-window cell.
- * Null when the path is already a leaf or the index lands outside the grid. Resolution is on the
- * NODE KIND, not the `cellCoordinate` flag: an intra-table focus is unflagged (see
- * {@link SelectionPoint}) yet still a cell index. Callers reach it through
- * `SelectionState.cellLandingFor`, which is where the landing rule lives.
- */
+/** The inverse of {@link normalizeTableEndpoint}: a cell endpoint's `[tableIdx, row, col]` leaf
+ *  path, or null. Reach it through `SelectionState.cellLandingFor`. */
 export function cellEndpointDeepPath(doc, point) {
+    if (!point.cellCoordinate)
+        return null;
     const node = nodeAt(doc, point.path);
-    if (!node || !isBlockNode(node) || node.kind !== 'table')
+    if (!node || !countsCells(node))
         return null;
     const colCount = metadataOf(node, 'table').columnCount;
     const cellIdx = asCellIndex(point.offset);
@@ -131,13 +105,13 @@ function snapEndpoint(doc, point, side) {
     if (!point.cellCoordinate)
         return point;
     const node = nodeAt(doc, point.path);
-    if (!node || !isBlockNode(node) || node.kind !== 'table')
+    if (!node || !countsCells(node))
         return point;
     const colCount = metadataOf(node, 'table').columnCount;
     const cellIdx = cellIndexOf(point, 'snapCrossBlockTableEndpoints');
     const { row } = cellRowCol(cellIdx, colCount);
-    const snappedOffset = side === 'start' ? row * colCount : row * colCount + colCount - 1;
+    const snappedOffset = rowMajorCellIndex(row, side === 'start' ? 0 : colCount - 1, colCount);
     if (snappedOffset === cellIdx)
         return point;
-    return { ...point, offset: snappedOffset };
+    return cellPoint(point.path, snappedOffset);
 }

package/dist/selection/table-rect-extend.d.ts

@@ -5,7 +5,7 @@
  * horizontal extension clamps at the column edges, since a rectangle has no sideways exit.
  */
 import type { DocumentView } from '../core/node-views';
-import type { SelectionPoint } from './primitives';
+import { type SelectionPoint } from './primitives';
 export type ArrowKey = 'ArrowUp' | 'ArrowDown' | 'ArrowLeft' | 'ArrowRight';
 export type TableRectExtension = {
     kind: 'cell';
@@ -15,9 +15,6 @@ export type TableRectExtension = {
     direction: 'forward' | 'backward';
     fromCellPath: number[];
 };
-/**
- * The extension a Shift+Arrow produces for an intra-table rectangle, or null when the selection
- * is not a same-table rectangle. `anchor === focus` is a valid one-cell rectangle, so the first
- * Shift+Arrow starts here too. Offsets are cell indices, context-established by the shared path.
- */
+/** The extension a Shift+Arrow produces for an intra-table rectangle, or null unless the selection
+ *  is a same-table pair of cell endpoints (`anchor === focus` is a one-cell rectangle). */
 export declare function intraTableRectExtension(doc: DocumentView, anchor: SelectionPoint | null, focus: SelectionPoint | null, key: ArrowKey): TableRectExtension | null;

package/dist/selection/table-rect-extend.js

@@ -5,30 +5,35 @@
  * horizontal extension clamps at the column edges, since a rectangle has no sideways exit.
  */
 import { metadataOf } from '../core/nodes';
-import { isBlockNode, nodeAt } from '../tree-operations/node-primitives';
-import { cellRowCol } from '../cursor/coordinate-spaces';
+import { nodeAt } from '../tree-operations/node-primitives';
+import { countsCells } from '../schema/block-kind-descriptor';
+import { rowMajorCellIndex, cellRowCol } from '../cursor/coordinate-spaces';
+import { cellIndexOf } from './primitives';
 import { pathsEqual } from './path-math';
-/**
- * The extension a Shift+Arrow produces for an intra-table rectangle, or null when the selection
- * is not a same-table rectangle. `anchor === focus` is a valid one-cell rectangle, so the first
- * Shift+Arrow starts here too. Offsets are cell indices, context-established by the shared path.
- */
+/** The extension a Shift+Arrow produces for an intra-table rectangle, or null unless the selection
+ *  is a same-table pair of cell endpoints (`anchor === focus` is a one-cell rectangle). */
 export function intraTableRectExtension(doc, anchor, focus, key) {
-    if (!anchor || !focus || !pathsEqual(anchor.path, focus.path))
+    if (!anchor?.cellCoordinate || !focus?.cellCoordinate)
+        return null;
+    if (!pathsEqual(anchor.path, focus.path))
         return null;
     const node = nodeAt(doc, focus.path);
-    if (!node || !isBlockNode(node) || node.kind !== 'table')
+    if (!node || !countsCells(node))
         return null;
     const colCount = metadataOf(node, 'table').columnCount;
     const rowCount = node.children?.length ?? 0;
     if (colCount === 0 || rowCount === 0)
         return null;
     const path = focus.path;
-    const { row, col } = cellRowCol(focus.offset, colCount);
+    const { row, col } = cellRowCol(cellIndexOf(focus, 'intraTableRectExtension'), colCount);
+    const at = (r, c) => ({
+        kind: 'cell',
+        offset: rowMajorCellIndex(r, c, colCount)
+    });
     switch (key) {
         case 'ArrowDown':
             return row < rowCount - 1
-                ? { kind: 'cell', offset: (row + 1) * colCount + col }
+                ? at(row + 1, col)
                 : {
                     kind: 'exit',
                     direction: 'forward',
@@ -36,11 +41,11 @@ export function intraTableRectExtension(doc, anchor, focus, key) {
                 };
         case 'ArrowUp':
             return row > 0
-                ? { kind: 'cell', offset: (row - 1) * colCount + col }
+                ? at(row - 1, col)
                 : { kind: 'exit', direction: 'backward', fromCellPath: [...path, 0, 0] };
         case 'ArrowRight':
-            return { kind: 'cell', offset: row * colCount + Math.min(col + 1, colCount - 1) };
+            return at(row, Math.min(col + 1, colCount - 1));
         case 'ArrowLeft':
-            return { kind: 'cell', offset: row * colCount + Math.max(col - 1, 0) };
+            return at(row, Math.max(col - 1, 0));
     }
 }