@voithos-labs/aragonite 0.10.1

package/dist/components/blocks/table/TableCellBlock.svelte.d.ts

@@ -0,0 +1,30 @@
+import { type BlockComponent } from '../../../block-component';
+import { type CommandId } from '../../../schema/commands';
+import type { NodeView } from '../../../core/node-views';
+import type { TableAlignment } from '../../../core/nodes';
+import { type RefSlots } from '../../../reactivity/publish-ref.svelte';
+type $$ComponentProps = {
+    node: NodeView;
+    index: number;
+    myPath?: number[];
+    rowIdx: number;
+    columnCount: number;
+    rowCount: number;
+    alignment?: TableAlignment;
+    slots?: RefSlots<BlockComponent>;
+};
+declare const TableCellBlock: import("svelte").Component<$$ComponentProps, {
+    editable: true;
+    focusable: true;
+    focus: (offset: number) => void;
+    parkCaret: (offset: number) => void;
+    focusAtColumn: (x: number, from: import("../../../block-component").StickyColumnDirection) => void;
+    getCursorOffset: () => number | null;
+    getSelectedText: () => string;
+    setSelection: (start: number, end: number) => void;
+    measurePartialRects: (startOffset: number, endOffset: number) => DOMRect[];
+    isCommandActive: (id: CommandId) => boolean;
+    runCommand: (id: CommandId) => boolean;
+}, "">;
+type TableCellBlock = ReturnType<typeof TableCellBlock>;
+export default TableCellBlock;

package/dist/components/blocks/table/TableGrip.svelte

@@ -0,0 +1,91 @@
+<script lang="ts">
+	let {
+		axis,
+		onActivate,
+		onpointerdown
+	}: {
+		axis: 'row' | 'column';
+		onActivate: (e: MouseEvent) => void;
+		onpointerdown?: (e: PointerEvent) => void;
+	} = $props();
+
+	function handlePointerDown(e: PointerEvent): void {
+		// The affordance opens a menu, it doesn't place a caret, so the grip's pointer
+		// stream stays off the editor's selection/focus handlers.
+		e.stopPropagation();
+		onpointerdown?.(e);
+	}
+</script>
+
+<!-- Pointer-only affordance: the cell chords are the operable, screen-reader path, so the
+	grip stays out of the tab/SR flow. Reveal is pure CSS: hover in editor.css, touch below. -->
+<span class="table-grip-anchor table-grip-anchor-{axis}">
+	<span
+		class="table-grip table-grip-{axis}"
+		data-table-col-grip={axis === 'column' ? '' : undefined}
+		data-table-row-grip={axis === 'row' ? '' : undefined}
+		aria-hidden="true"
+		onclick={onActivate}
+		onpointerdown={handlePointerDown}
+	></span>
+</span>
+
+<style>
+	/* Zero-height so it never adds a visible band or shifts caret-measured layout;
+	   z-index lifts the dots above the DOM-later header cell, which would eat the click. */
+	.table-grip-anchor-column {
+		position: relative;
+		z-index: 2;
+		height: 0;
+	}
+
+	/* The dotted bar shared by both axes; the axis rules add only the geometry. */
+	.table-grip {
+		position: absolute;
+		color: var(--color-ui-muted, #a4a4a4);
+		background-image: radial-gradient(currentColor 40%, transparent 45%);
+		background-position: center;
+		cursor: pointer;
+		opacity: 0;
+		pointer-events: none;
+	}
+
+	/* Sits within the header cell's top padding so it never overlaps the caret-click target. */
+	.table-grip-column {
+		top: 0;
+		left: 50%;
+		transform: translateX(-50%);
+		width: 1.75rem;
+		height: 0.35rem;
+		background-size: 0.25rem 0.35rem;
+		background-repeat: repeat-x;
+	}
+
+	/* Zero-width gutter item, stretched to the row height. z-index lifts the dots above
+	   cell A, which renders DOM-later and would otherwise paint over them. */
+	.table-grip-anchor-row {
+		position: relative;
+		z-index: 2;
+	}
+
+	/* Overflows out of the zero-width gutter into cell A's left padding, clear of the text. */
+	.table-grip-row {
+		top: 50%;
+		left: 0.15rem;
+		transform: translateY(-50%);
+		width: 0.35rem;
+		height: 1rem;
+		background-size: 0.35rem 0.25rem;
+		background-repeat: repeat-y;
+	}
+
+	/* Touch fires no hover, so the editor.css reveal never runs and an opted-in host's grips
+	   would be unreachable. `touch-action` keeps a reorder drag off the table's own scroll. */
+	@media (hover: none) {
+		.table-grip {
+			opacity: 1;
+			pointer-events: auto;
+			touch-action: none;
+		}
+	}
+</style>

package/dist/components/blocks/table/TableGrip.svelte.d.ts

@@ -0,0 +1,8 @@
+type $$ComponentProps = {
+    axis: 'row' | 'column';
+    onActivate: (e: MouseEvent) => void;
+    onpointerdown?: (e: PointerEvent) => void;
+};
+declare const TableGrip: import("svelte").Component<$$ComponentProps, {}, "">;
+type TableGrip = ReturnType<typeof TableGrip>;
+export default TableGrip;

package/dist/components/blocks/table/TableRowBlock.svelte

@@ -0,0 +1,233 @@
+<script lang="ts">
+	import { getContext } from 'svelte';
+	import type {
+		BlockEditActions,
+		ContainerEditActions,
+		FocusActions
+	} from '../../../action-contracts';
+	import { CURSOR_END, CURSOR_START, type BlockComponent } from '../../../block-component';
+	import type { NodeView } from '../../../core/node-views';
+	import {
+		BLOCK_EDIT_KEY,
+		CONTAINER_EDIT_KEY,
+		EDITOR_DOC_KEY,
+		EDITOR_POLICIES_KEY,
+		EDITOR_SERVICES_KEY,
+		FOCUS_KEY,
+		PARENT_SCOPE_SINK_KEY,
+		type EditorDoc,
+		type EditorPolicies,
+		type EditorServices,
+		type ParentScopeSink
+	} from '../../../editor-keys';
+	import type { TableAlignment } from '../../../core/nodes';
+	import { createBlockListState } from '../../../reactivity/block-list-state.svelte';
+	import { useMountGauge } from '../../../perf/use-mount-gauge.svelte';
+	import {
+		createStandardNestedActions,
+		setNestedActionsContexts,
+		type NodeScope
+	} from '../../../editor-actions/nested/nested-actions';
+	import { publishRefSlot, type RefSlots } from '../../../reactivity/publish-ref.svelte';
+	import TableCellBlock from './TableCellBlock.svelte';
+	import TableGrip from './TableGrip.svelte';
+
+	let {
+		node,
+		index,
+		id,
+		columnCount,
+		rowCount,
+		alignments = [],
+		myPath = [],
+		slots,
+		onOpenRowMenu,
+		onRowGripPointerDown,
+		showGrips
+	}: {
+		node: NodeView;
+		index: number;
+		id: string;
+		columnCount: number;
+		rowCount: number;
+		alignments?: readonly TableAlignment[];
+		myPath?: number[];
+		slots?: RefSlots<BlockComponent>;
+		onOpenRowMenu?: (rowIdx: number, e: MouseEvent) => void;
+		onRowGripPointerDown?: (rowIdx: number, e: PointerEvent) => void;
+		/** The table's `blockDragHandles` read, passed down rather than re-read: the row grip
+		 *  and the gutter track it fills are one decision. */
+		showGrips: boolean;
+	} = $props();
+
+	// A row's position among the table's children IS its row index.
+	const rowIdx = $derived(index);
+
+	const parentBlockEdit = getContext<BlockEditActions>(BLOCK_EDIT_KEY);
+	const parentFocus = getContext<FocusActions>(FOCUS_KEY);
+	const parentContainerEdit = getContext<ContainerEditActions>(CONTAINER_EDIT_KEY);
+	const { stickyColumn, registryView } = getContext<EditorServices>(EDITOR_SERVICES_KEY);
+	const getPresentationMode = getContext<EditorPolicies | undefined>(
+		EDITOR_POLICIES_KEY
+	)?.presentationMode;
+	const linkRef = getContext<EditorDoc | undefined>(EDITOR_DOC_KEY)?.linkRef;
+
+	const cellsState = createBlockListState(() => node);
+
+	let rowEl: HTMLElement | undefined = $state();
+	const parentSink = getContext<ParentScopeSink | undefined>(PARENT_SCOPE_SINK_KEY);
+
+	useMountGauge();
+
+	// A `display: contents` row has no box, so measure a cell: every cell stretches to
+	// the grid row track, making its border-box height the row height. Enrolling in the
+	// table scope's batched pass keeps a fling to one reflow, not one per mounted row.
+	$effect(() => {
+		void index;
+		if (!parentSink) return;
+		const currentIndex = index;
+		return parentSink.registerRow(
+			id,
+			() => {
+				const cell = rowEl?.querySelector(':scope > .table-cell') as HTMLElement | null;
+				return cell?.getBoundingClientRect().height ?? 0;
+			},
+			(h) => parentSink.setChildSubtotal(currentIndex, h)
+		);
+	});
+
+	// Skip the mount run (mirrors BlockHost): a read here interleaved with the prior row's
+	// subtotal write forces one reflow per row mounted in the frame (VR-4). The batched
+	// pass owns mount measurement; this effect re-measures only on a later edit.
+	let firstRun = true;
+	$effect(() => {
+		void node.raw;
+		if (firstRun) {
+			firstRun = false;
+			return;
+		}
+		parentSink?.measureRowNow(id);
+	});
+
+	const scope: NodeScope = {
+		get index() {
+			return index;
+		},
+		get node() {
+			return node;
+		},
+		get path() {
+			return myPath;
+		}
+	};
+
+	const bundle = createStandardNestedActions(cellsState, {
+		scope,
+		stickyColumn,
+		grammar: registryView.grammar,
+		getPresentationMode,
+		linkRef,
+		parent: {
+			blockEdit: parentBlockEdit,
+			focus: parentFocus,
+			containerEdit: parentContainerEdit
+		}
+	});
+
+	setNestedActionsContexts(bundle);
+
+	// ── BlockComponent interface ────────────────────────────────────────
+
+	export const editable = true;
+	export const focusable = true;
+
+	// The TableBlock twin's rule: a start arrival enters the first cell, anything else the
+	// last, and the sentinel rides into the cell so its door clamps and classifies.
+	function rowLanding(offset: number): { colIdx: number; at: number } {
+		const atStart = offset === 0 || offset === CURSOR_START;
+		return atStart ? { colIdx: 0, at: CURSOR_START } : { colIdx: columnCount - 1, at: CURSOR_END };
+	}
+
+	export function focus(offset: number): void {
+		const { colIdx, at } = rowLanding(offset);
+		cellsState.innerBlockRefs[colIdx]?.focus(at);
+	}
+
+	export function parkCaret(offset: number): void {
+		const { colIdx, at } = rowLanding(offset);
+		cellsState.innerBlockRefs[colIdx]?.parkCaret?.(at);
+	}
+
+	export function getCursorOffset(): number | null {
+		return null;
+	}
+
+	export function focusByPath(path: number[], offset: number): void {
+		const [colIdx, ...rest] = path;
+		const cellRef = cellsState.innerBlockRefs[colIdx];
+		cellRef?.focus(rest.length === 0 ? offset : 0);
+	}
+
+	export function getBlockComponentByPath(path: number[]): BlockComponent | null {
+		if (path.length === 0) return null;
+		const [colIdx, ...rest] = path;
+		const cellRef = cellsState.innerBlockRefs[colIdx];
+		if (!cellRef) return null;
+		if (rest.length === 0) return cellRef;
+		return cellRef.getBlockComponentByPath?.(rest) ?? null;
+	}
+
+	export function getCursorPosition(): { path: number[]; offset: number } | null {
+		for (let colIdx = 0; colIdx < cellsState.innerBlockRefs.length; colIdx++) {
+			const cellRef = cellsState.innerBlockRefs[colIdx];
+			const offset = cellRef?.getCursorOffset();
+			if (offset !== null && offset !== undefined) return { path: [colIdx], offset };
+		}
+		return null;
+	}
+
+	// The ONE surface literal, the cell's twin: a row reaches every caller through its published
+	// slot, so a second literal to type-check against would only be a decoy.
+	$effect(() => {
+		if (!slots) return;
+		const self = {
+			editable,
+			focusable,
+			focus,
+			parkCaret,
+			getCursorOffset,
+			getCursorPosition,
+			focusByPath,
+			getBlockComponentByPath
+		} satisfies BlockComponent;
+		return publishRefSlot(slots, index, self, rowEl);
+	});
+</script>
+
+<!-- The grip is the row's first child so it lands in the table's zero-width gutter track
+	and the cells fill the rest. No whitespace between it and the cells: a stray text node
+	joins the table's raw-offset walk and misplaces a parked cross-block caret. -->
+<div bind:this={rowEl} class="table-row" role="row" data-table-row-idx={rowIdx}>
+	{#if showGrips}<TableGrip
+			axis="row"
+			onActivate={(e) => onOpenRowMenu?.(rowIdx, e)}
+			onpointerdown={(e) => onRowGripPointerDown?.(rowIdx, e)}
+		/>{/if}{#each node.children ?? [] as cellNode, colIdx (cellsState.innerBlockIds[colIdx])}
+		<TableCellBlock
+			node={cellNode}
+			index={colIdx}
+			myPath={[...myPath, colIdx]}
+			{rowIdx}
+			{columnCount}
+			{rowCount}
+			alignment={alignments[colIdx] ?? 'none'}
+			slots={cellsState.refSlots}
+		/>
+	{/each}
+</div>
+
+<style>
+	.table-row {
+		display: contents;
+	}
+</style>

package/dist/components/blocks/table/TableRowBlock.svelte.d.ts

@@ -0,0 +1,34 @@
+import { type BlockComponent } from '../../../block-component';
+import type { NodeView } from '../../../core/node-views';
+import type { TableAlignment } from '../../../core/nodes';
+import { type RefSlots } from '../../../reactivity/publish-ref.svelte';
+type $$ComponentProps = {
+    node: NodeView;
+    index: number;
+    id: string;
+    columnCount: number;
+    rowCount: number;
+    alignments?: readonly TableAlignment[];
+    myPath?: number[];
+    slots?: RefSlots<BlockComponent>;
+    onOpenRowMenu?: (rowIdx: number, e: MouseEvent) => void;
+    onRowGripPointerDown?: (rowIdx: number, e: PointerEvent) => void;
+    /** The table's `blockDragHandles` read, passed down rather than re-read: the row grip
+     *  and the gutter track it fills are one decision. */
+    showGrips: boolean;
+};
+declare const TableRowBlock: import("svelte").Component<$$ComponentProps, {
+    editable: true;
+    focusable: true;
+    focus: (offset: number) => void;
+    parkCaret: (offset: number) => void;
+    getCursorOffset: () => number | null;
+    focusByPath: (path: number[], offset: number) => void;
+    getBlockComponentByPath: (path: number[]) => BlockComponent | null;
+    getCursorPosition: () => {
+        path: number[];
+        offset: number;
+    } | null;
+}, "">;
+type TableRowBlock = ReturnType<typeof TableRowBlock>;
+export default TableRowBlock;

package/dist/components/blocks/table/cell-clipboard.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Pure clipboard payload for an intra-table multi-cell rectangle; the component
+ * owns the live ClipboardEvent wiring.
+ */
+import type { DocumentGetter } from '../../../editor-keys';
+import type { SelectionState } from '../../../selection/selection-state.svelte';
+export interface CellClipboardDeps {
+    selection: SelectionState;
+    getDoc: DocumentGetter;
+}
+export interface IntraTableRect {
+    tablePath: number[];
+    anchorCellIdx: number;
+    focusCellIdx: number;
+}
+/**
+ * Both endpoints share the table path, so each `offset` is a row-major cell index
+ * (unflagged — see `selection/primitives` on context-established cell offsets). Callers
+ * compare `tablePath` against their own; the rectangle belongs to at most one table.
+ */
+export declare function intraTableRect(selection: SelectionState): IntraTableRect | null;
+/** The GFM sub-table for the current selection, or null when it isn't a rectangle. */
+export declare function intraTableRectPayload(deps: CellClipboardDeps): string | null;

package/dist/components/blocks/table/cell-clipboard.js

@@ -0,0 +1,34 @@
+/**
+ * Pure clipboard payload for an intra-table multi-cell rectangle; the component
+ * owns the live ClipboardEvent wiring.
+ */
+import { metadataOf } from '../../../core/nodes';
+import { isBlockNode, nodeAt } from '../../../tree-operations/node-ops';
+import { pathsEqual } from '../../../selection/path-math';
+import { cellRowCol } from '../../../cursor/coordinate-spaces';
+import { copyRectangleAsSubTable } from '../../../tree-operations/sub-table-copy';
+/**
+ * Both endpoints share the table path, so each `offset` is a row-major cell index
+ * (unflagged — see `selection/primitives` on context-established cell offsets). Callers
+ * compare `tablePath` against their own; the rectangle belongs to at most one table.
+ */
+export function intraTableRect(selection) {
+    const { anchor, focus } = selection;
+    if (!selection.isCustomRendered || !anchor || !focus || !pathsEqual(anchor.path, focus.path)) {
+        return null;
+    }
+    return { tablePath: anchor.path, anchorCellIdx: anchor.offset, focusCellIdx: focus.offset };
+}
+/** The GFM sub-table for the current selection, or null when it isn't a rectangle. */
+export function intraTableRectPayload(deps) {
+    const rect = intraTableRect(deps.selection);
+    if (!rect)
+        return null;
+    const tableNode = nodeAt(deps.getDoc(), rect.tablePath);
+    if (!tableNode || !isBlockNode(tableNode) || tableNode.kind !== 'table')
+        return null;
+    const colCount = metadataOf(tableNode, 'table').columnCount;
+    const a = cellRowCol(rect.anchorCellIdx, colCount);
+    const b = cellRowCol(rect.focusCellIdx, colCount);
+    return copyRectangleAsSubTable(tableNode, { rowIdx: a.row, colIdx: a.col }, { rowIdx: b.row, colIdx: b.col });
+}

package/dist/components/blocks/table/cell-keydown-plan.d.ts

@@ -0,0 +1,37 @@
+export interface CellKeyInput {
+    key: string;
+    ctrlOrMeta: boolean;
+    shiftKey: boolean;
+    altKey: boolean;
+}
+export interface CellKeyState {
+    rowIdx: number;
+    colIdx: number;
+    columnCount: number;
+    rowCount: number;
+    offset: number;
+    /** The cell's landable extremes. A mode that paints no marker puts a leading or trailing
+     *  run out of the caret's reach, and a hop testing raw 0 / raw length never fires. */
+    contentStart: number;
+    contentEnd: number;
+    collapsed: boolean;
+    selectAllCount: number;
+}
+export type CellKeyPlan = {
+    kind: 'native';
+} | {
+    kind: 'select-all-step';
+    step: 'native' | 'table' | 'document';
+} | {
+    kind: 'focus-cell';
+    rowIdx: number;
+    colIdx: number;
+    position: 'start' | 'end';
+    setStickyColumn?: number;
+} | {
+    kind: 'insert-row-below';
+} | {
+    kind: 'exit';
+    direction: 'up' | 'down';
+};
+export declare function cellKeydownPlan(e: CellKeyInput, s: CellKeyState): CellKeyPlan;

package/dist/components/blocks/table/cell-keydown-plan.js

@@ -0,0 +1,66 @@
+/**
+ * Pure keydown → plan for a table cell's caret-dependent navigation: cell hop at a text boundary,
+ * row hop, table exit, the row-appending end of Tab/Enter. The branches ignore Alt and Mod, which
+ * the command dispatcher claims first: an unclaimed modified arrow must still navigate, and
+ * `native` hands it to the prose prelude, which moves among siblings by index.
+ */
+import { cellAbove, cellBelow, nextCell, prevCell } from './table-navigation';
+// CapsLock reports the letter uppercased, so the select-all chord tests for both
+// spellings rather than against a single literal.
+function isLetterA(key) {
+    return key === 'a' || key === 'A';
+}
+export function cellKeydownPlan(e, s) {
+    const pos = { rowIdx: s.rowIdx, colIdx: s.colIdx };
+    if (e.ctrlOrMeta && isLetterA(e.key) && !e.shiftKey && !e.altKey) {
+        return {
+            kind: 'select-all-step',
+            step: s.selectAllCount === 0 ? 'native' : s.selectAllCount === 1 ? 'table' : 'document'
+        };
+    }
+    if (e.key === 'ArrowLeft' && !e.shiftKey && s.offset <= s.contentStart && s.collapsed) {
+        return horizontalMove(prevCell(pos, s.columnCount), 'end', 'up');
+    }
+    if (e.key === 'ArrowRight' && !e.shiftKey && s.offset >= s.contentEnd && s.collapsed) {
+        return horizontalMove(nextCell(pos, s.columnCount, s.rowCount), 'start', 'down');
+    }
+    if (e.key === 'ArrowUp' && !e.shiftKey)
+        return verticalMove(cellAbove(pos), 'up');
+    if (e.key === 'ArrowDown' && !e.shiftKey)
+        return verticalMove(cellBelow(pos, s.rowCount), 'down');
+    if (e.key === 'Tab' && !e.shiftKey) {
+        return orAppendRow(nextCell(pos, s.columnCount, s.rowCount));
+    }
+    if (e.key === 'Tab' && e.shiftKey)
+        return horizontalMove(prevCell(pos, s.columnCount), 'end', 'up');
+    if (e.key === 'Enter' && !e.shiftKey)
+        return orAppendRow(cellBelow(pos, s.rowCount));
+    if (e.key === 'Backspace' && s.offset <= s.contentStart && s.collapsed) {
+        return horizontalMove(prevCell(pos, s.columnCount), 'end', 'up');
+    }
+    if (e.key === 'Delete' && s.offset >= s.contentEnd && s.collapsed) {
+        return horizontalMove(nextCell(pos, s.columnCount, s.rowCount), 'start', 'down');
+    }
+    return { kind: 'native' };
+}
+function orAppendRow(move) {
+    return move
+        ? { kind: 'focus-cell', rowIdx: move.rowIdx, colIdx: move.colIdx, position: 'start' }
+        : { kind: 'insert-row-below' };
+}
+function horizontalMove(move, position, exit) {
+    return move
+        ? { kind: 'focus-cell', rowIdx: move.rowIdx, colIdx: move.colIdx, position }
+        : { kind: 'exit', direction: exit };
+}
+function verticalMove(move, exit) {
+    return move
+        ? {
+            kind: 'focus-cell',
+            rowIdx: move.rowIdx,
+            colIdx: move.colIdx,
+            position: 'start',
+            setStickyColumn: move.colIdx
+        }
+        : { kind: 'exit', direction: exit };
+}

package/dist/components/blocks/table/cell-pointer.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Cell-aware pointer drag and shift+click for tables. Builds the shallow-path
+ * intra-table multi-cell SelectionState (anchor.path === focus.path === tablePath,
+ * offsets are cellIdx-based) when input crosses cell boundaries inside one table.
+ */
+import type { SelectionState } from '../../../selection/selection-state.svelte';
+export interface CellAnchor {
+    tableEl: HTMLElement;
+    tablePath: number[];
+    rowIdx: number;
+    colIdx: number;
+    columnCount: number;
+}
+export interface CellDragContext {
+    editorRoot: HTMLElement;
+    selection: SelectionState;
+    lifetimeSignal?: AbortSignal;
+}
+/**
+ * Pointer-drag from inside `anchor`'s cell: drives the multi-cell encoding while the
+ * pointer stays in the table, and extends focus to the foreign block underneath once
+ * it leaves. Anchor cell coords are frozen; only the focus tracks the pointer.
+ */
+export declare function installCellDragListener(ctx: CellDragContext, anchor: CellAnchor, down: PointerEvent): {
+    dispose(): void;
+};
+/** Shift+click on a cell when the previous focus was another cell of the same table. */
+export declare function handleCellShiftClick(selection: SelectionState, anchor: CellAnchor, target: {
+    rowIdx: number;
+    colIdx: number;
+}): void;
+/**
+ * The mounted table rows, in DOM order. Row windowing unmounts row 0 once the table
+ * scrolls past it (VR-K1), so index 0 is the first MOUNTED row — still fine for column
+ * geometry, since the column tracks are uniform.
+ */
+export declare function mountedRowEls(tableEl: HTMLElement): HTMLElement[];
+/** The cells of one row, in column order. */
+export declare function rowCellEls(rowEl: Element): HTMLElement[];
+/**
+ * A viewport point → its cell within `tableEl`, or null when the point falls outside
+ * this specific table. Thin entry over `cellCoordsOfElement`.
+ */
+export declare function cellAtPoint(clientX: number, clientY: number, tableEl: HTMLElement): {
+    rowIdx: number;
+    colIdx: number;
+    cellEl: HTMLElement;
+} | null;
+/**
+ * An element (click target, previously focused element) → its cell coords within
+ * `tableEl`. Identity-checks the owning table, so a sibling table can't masquerade
+ * as the originating one.
+ */
+export declare function cellCoordsOfElement(el: Element | null, tableEl: HTMLElement): {
+    rowIdx: number;
+    colIdx: number;
+    cellEl: HTMLElement;
+} | null;