@voithos-labs/aragonite 0.10.2 → 0.10.3

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

@@ -26,8 +26,17 @@
 	import type { TableAlignment } from '../../../core/nodes';
 	import { trimTrailingLineEnding, normalizeLineEndings } from '../../../core/lines';
 	import { pasteDispatch } from '../../../tree-operations/paste/dispatch';
-	import { blockNodeAt, cutRangeFromDisplay } from '../../../tree-operations/node-ops';
+	import { blockNodeAt, isBlockNode, nodeAt } from '../../../tree-operations/node-primitives';
+	import { cutRangeFromDisplay } from '../../../tree-operations/node-ops';
 	import { applyLiveRangeEdit } from '../text/live-selection-edit';
+	import {
+		gridToHtmlTable,
+		parseClipboardGrid,
+		tileGridTo
+	} from '../../../tree-operations/table-grid-clipboard';
+	import { tableCellCount } from '../../../selection/table-endpoint-snap';
+	import { pathsEqual } from '../../../selection/path-math';
+	import { applyDelimiterAutoPair } from '../text/delimiter-autopair';
 	import { hasSelection as hasSelectionHelper } from '../../../cursor/content-offsets';
 	import { FALLBACK_CONTENT_WIDTH } from '../../../cursor/typography-estimates';
 	import {
@@ -45,7 +54,8 @@
 	import {
 		createEditableSurface,
 		createClipboardHandlers,
-		consumePendingRestore
+		consumePendingRestore,
+		withKeydownVerdict
 	} from '../editable-surface';
 	import { wireSurfaceContexts, useParkFocusOnUnmount } from '../surface-wiring.svelte';
 	import { resetForPointerDown } from '../../../selection/cross-block/pointer';
@@ -59,7 +69,11 @@
 	import { isAtFirstVisualLine, isAtLastVisualLine } from '../../../cursor/visual-lines';
 	import { cellKeydownPlan, type CellKeyPlan, type CellKeyState } from './cell-keydown-plan';
 	import { tableAxisCommand } from './cell-table-commands';
-	import { intraTableRectPayload } from './cell-clipboard';
+	import {
+		intraTableRectPayload,
+		intraTableRectBounds,
+		intraTableRectGrid
+	} from './cell-clipboard';
 	import { escapedCellOffset } from './table-cell-paste';
 	import type { CellSelectionPoint, SelectionPoint } from '../../../selection/primitives';
 	import type { ClipboardAction } from './table-menu-model';
@@ -325,6 +339,7 @@
 		},
 		isReading: () => readOnly,
 		getEdgeAffinity: () => edgeAffinity.get(),
+		noteOutside: edgeAffinity.noteExtreme,
 		pendingMarks,
 		installedAs: 'cell'
 	});
@@ -533,9 +548,9 @@
 			carryCaret: pendingCursorOffset === null
 		});
 		if (pendingCursorOffset !== null) {
-			consumePendingRestore(el, pendingCursorOffset, (offset) =>
-				cursor.setRaw(asRawOffset(offset))
-			);
+			consumePendingRestore(el, pendingCursorOffset, (offset) => {
+				if (!widgetInteraction.revealInterior(offset)) cursor.setRaw(asRawOffset(offset));
+			});
 			pendingCursorOffset = null;
 		}
 	});
@@ -663,23 +678,13 @@
 				if (edgeDispatch.handleKeydown(e, cursor.getRaw())) return;
 				return;
 			}
-			// Cells override the document-level 2-stage Ctrl+A with a 3-stage table-aware
-			// variant; the intra-cell step stays native.
+			// The document-level two-stage Ctrl+A, cell first: the intra-cell step stays native,
+			// the second press takes the document.
 			case 'select-all-step':
 				selection.incrementSelectAllCount();
 				if (plan.step === 'native') return;
 				e.preventDefault();
-				if (plan.step === 'table') {
-					const tablePath = myPath.slice(0, -2);
-					// Flagged row-major like the drag/shift-click anchor, so a later
-					// exit-the-table extend snaps its whole row.
-					selection.enterCrossBlock(
-						{ path: tablePath, offset: 0, cellCoordinate: true } satisfies CellSelectionPoint,
-						{ path: tablePath, offset: columnCount * rowCount - 1 }
-					);
-				} else {
-					selectWholeDocument(selection, getDoc(), getBlockElByPath);
-				}
+				selectWholeDocument(selection, getDoc(), getBlockElByPath);
 				return;
 			default:
 				e.preventDefault();
@@ -690,6 +695,8 @@
 		}
 	}
 
+	const onKeyDownTraced = withKeydownVerdict(onKeyDown);
+
 	// The navigation plans, no live event needed; the caller preventDefaults. The fold is here
 	// rather than at each caller: insert-row-below rebuilds every row from cell raws, so an open
 	// reveal's edit would be re-derived away.
@@ -778,9 +785,29 @@
 		);
 	}
 
+	// The cell at the prose surface's self-closing delimiter arm (delimiter-autopair.ts).
+	function handleDelimiterAutoPair(e: InputEvent): boolean {
+		return applyDelimiterAutoPair(e, {
+			text: readCellText,
+			content: () => ({ start: 0, end: readCellText().length }),
+			caret: () => cursor.getRaw(),
+			hasSelection: () => cursor.getRawSelection() !== null,
+			isRevealing: widgetInteraction.isRevealing,
+			foldReveal: () => widgetInteraction.foldRevealBeforeMutation(),
+			markersPaint: () => paintsFocusedMarkers(presentationMode),
+			setCaret: (offset) => cursor.setRaw(asRawOffset(offset)),
+			seatOutside: edgeAffinity.noteExtreme,
+			write: (text, caretBefore, caretAfter) => {
+				void blockEdit.updateBlockContent(index, text, caretBefore, caretAfter);
+				parkCursor(caretAfter, text);
+			}
+		});
+	}
+
 	async function onBeforeInput(e: InputEvent): Promise<void> {
 		if (await handleSharedBeforeInput(e, sharedCtx)) return;
 		if (handleLiveSelectionEdit(e)) return;
+		if (handleDelimiterAutoPair(e)) return;
 		if (e.inputType === 'insertLineBreak') {
 			// GFM cells can't carry raw newlines, so a line break is a literal `<br>`,
 			// which the inline-HTML pipeline renders as a live widget.
@@ -853,6 +880,36 @@
 	// Copy/cut/paste through the shared skeleton. The cell's extra arms are the intra-table
 	// rectangle (copied as a GFM sub-table) and the intra-cell raw slice, which preserves
 	// widget bytes like `<br>` that the browser's rendered-textContent copy drops.
+	// The rectangle's spreadsheet form rides beside the GFM: Excel and Sheets read text/html.
+	function writeRectHtml(e: ClipboardEvent): void {
+		const grid = intraTableRectGrid({ selection, getDoc });
+		if (grid) e.clipboardData?.setData('text/html', gridToHtmlTable(grid));
+	}
+
+	// A grid (tabs from a spreadsheet, or a GFM table) fills cells from here — the rectangle's
+	// top-left when one is live, else this cell — growing the table to fit. A whole-table
+	// selection keeps its replace route; a non-grid payload keeps the ordinary paste.
+	async function pasteGridHere(text: string): Promise<boolean> {
+		const grid = parseClipboardGrid(text);
+		if (!grid) return false;
+		const tablePath = myPath.slice(0, -2);
+		const bounds = intraTableRectBounds({ selection, getDoc });
+		const inThisTable = bounds !== null && pathsEqual(bounds.tablePath, tablePath);
+		if (bounds && !inThisTable) return false;
+		const tableNode = nodeAt(getDoc(), tablePath);
+		const wholeTable =
+			bounds !== null &&
+			tableNode !== null &&
+			isBlockNode(tableNode) &&
+			bounds.rows * bounds.cols === tableCellCount(tableNode);
+		if (wholeTable) return false;
+		const origin = bounds ? { rowIdx: bounds.top, colIdx: bounds.left } : { rowIdx, colIdx };
+		const fitted = bounds ? tileGridTo(grid, bounds.rows, bounds.cols) : grid;
+		if (bounds) selection.collapse();
+		await tableContext.pasteGrid(origin, fitted);
+		return true;
+	}
+
 	const clipboard = createClipboardHandlers({
 		stickyColumn,
 		edgeAffinity,
@@ -869,8 +926,10 @@
 			if (rectPayload === null) return false;
 			e.preventDefault();
 			e.clipboardData?.setData('text/plain', rectPayload);
+			writeRectHtml(e);
 			return true;
 		},
+		pastePreHook: pasteGridHere,
 		// During a reveal the swapped DOM holds an edit `node.raw` hasn't seen; copy never
 		// mutates, so it slices the live DOM text rather than folding first.
 		copyTail: (e) => {
@@ -889,6 +948,7 @@
 			const rectPayload = intraTableRectPayload({ selection, getDoc });
 			if (rectPayload === null) return false;
 			e.clipboardData?.setData('text/plain', rectPayload);
+			writeRectHtml(e);
 			await crossBlock.performCrossBlockDeleteFromEvent();
 			return true;
 		},
@@ -982,7 +1042,7 @@
 		// mutating: execCommand needs the restored range, paste needs a focused caret.
 		stickyColumn.reset();
 		edgeAffinity.reset();
-		el.focus();
+		el.focus({ preventScroll: true });
 		if (action === 'paste') {
 			let raw: string;
 			try {
@@ -1046,7 +1106,7 @@
 	role="cell"
 	style:text-align={alignment === 'none' ? undefined : alignment}
 	oninput={onInput}
-	onkeydown={onKeyDown}
+	onkeydown={onKeyDownTraced}
 	onbeforeinput={onBeforeInput}
 	onpointerdown={onPointerDown}
 	onclick={onClick}
@@ -1060,13 +1120,18 @@
 ></div>
 
 <style>
+	/* Two sides only. The grid has no `border-collapse`, so a cell drawing all four put two
+	   1px lines on every shared edge — visibly heavier inside the table than around it. The
+	   container draws the top and left, these draw the right and bottom, and every rule in
+	   the grid is one line wide. */
 	.table-cell {
 		outline: none;
 		padding: 4px 8px;
 		min-height: 1.4em;
 		white-space: pre-wrap;
 		word-wrap: break-word;
-		border: 1px solid var(--color-ui-muted, #a4a4a4);
+		border-right: 1px solid var(--color-border, #3e3e3b);
+		border-bottom: 1px solid var(--color-border, #3e3e3b);
 	}
 	.table-cell:focus {
 		outline: 2px solid var(--color-accent, #567b67);

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

@@ -30,7 +30,6 @@
 	} 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,
@@ -40,10 +39,7 @@
 		rowCount,
 		alignments = [],
 		myPath = [],
-		slots,
-		onOpenRowMenu,
-		onRowGripPointerDown,
-		showGrips
+		slots
 	}: {
 		node: NodeView;
 		index: number;
@@ -53,11 +49,6 @@
 		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.
@@ -204,15 +195,10 @@
 	});
 </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. -->
+<!-- No whitespace between the row and its 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])}
+	{#each node.children ?? [] as cellNode, colIdx (cellsState.innerBlockIds[colIdx])}
 		<TableCellBlock
 			node={cellNode}
 			index={colIdx}

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

@@ -11,11 +11,6 @@ type $$ComponentProps = {
     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;

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

@@ -21,3 +21,13 @@ export interface IntraTableRect {
 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;
+/** The rectangle's bounds in row/column terms, or null when the selection isn't one. */
+export declare function intraTableRectBounds(deps: CellClipboardDeps): {
+    tablePath: number[];
+    top: number;
+    left: number;
+    rows: number;
+    cols: number;
+} | null;
+/** The rectangle's cell texts as a grid (pipes unescaped), for the spreadsheet formats. */
+export declare function intraTableRectGrid(deps: CellClipboardDeps): string[][] | null;

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

@@ -3,10 +3,11 @@
  * owns the live ClipboardEvent wiring.
  */
 import { metadataOf } from '../../../core/nodes';
-import { isBlockNode, nodeAt } from '../../../tree-operations/node-ops';
+import { isBlockNode, nodeAt } from '../../../tree-operations/node-primitives';
 import { pathsEqual } from '../../../selection/path-math';
 import { cellRowCol } from '../../../cursor/coordinate-spaces';
 import { copyRectangleAsSubTable } from '../../../tree-operations/sub-table-copy';
+import { rectangleGrid } from '../../../tree-operations/table-grid-clipboard';
 /**
  * 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
@@ -32,3 +33,35 @@ export function intraTableRectPayload(deps) {
     const b = cellRowCol(rect.focusCellIdx, colCount);
     return copyRectangleAsSubTable(tableNode, { rowIdx: a.row, colIdx: a.col }, { rowIdx: b.row, colIdx: b.col });
 }
+/** The rectangle's bounds in row/column terms, or null when the selection isn't one. */
+export function intraTableRectBounds(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);
+    const top = Math.min(a.row, b.row);
+    const left = Math.min(a.col, b.col);
+    return {
+        tablePath: rect.tablePath,
+        top,
+        left,
+        rows: Math.max(a.row, b.row) - top + 1,
+        cols: Math.max(a.col, b.col) - left + 1
+    };
+}
+/** The rectangle's cell texts as a grid (pipes unescaped), for the spreadsheet formats. */
+export function intraTableRectGrid(deps) {
+    const bounds = intraTableRectBounds(deps);
+    if (!bounds)
+        return null;
+    const tableNode = nodeAt(deps.getDoc(), bounds.tablePath);
+    if (!tableNode || !isBlockNode(tableNode))
+        return null;
+    const { top, left, rows, cols } = bounds;
+    return rectangleGrid(tableNode, { rowIdx: top, colIdx: left }, { rowIdx: top + rows - 1, colIdx: left + cols - 1 });
+}

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

@@ -21,7 +21,7 @@ export type CellKeyPlan = {
     kind: 'native';
 } | {
     kind: 'select-all-step';
-    step: 'native' | 'table' | 'document';
+    step: 'native' | 'document';
 } | {
     kind: 'focus-cell';
     rowIdx: number;

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

@@ -12,10 +12,12 @@ function isLetterA(key) {
 }
 export function cellKeydownPlan(e, s) {
     const pos = { rowIdx: s.rowIdx, colIdx: s.colIdx };
+    // Two stages, like every other block: the cell's own text natively, then the document. A
+    // table stage in between was this editor's alone; Docs and friends go straight to the page.
     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'
+            step: s.selectAllCount === 0 ? 'native' : 'document'
         };
     }
     if (e.key === 'ArrowLeft' && !e.shiftKey && s.offset <= s.contentStart && s.collapsed) {

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

@@ -6,7 +6,8 @@
  */
 import { CURSOR_END } from '../../../block-component';
 import { normalizeCellRaw } from '../../../schema/table-cell-raw';
-import { blockNodeAt, cutRangeFromDisplay } from '../../../tree-operations/node-ops';
+import { blockNodeAt } from '../../../tree-operations/node-primitives';
+import { cutRangeFromDisplay } from '../../../tree-operations/node-ops';
 import { sliceTableAtRow } from '../../../tree-operations/paste/table-slice';
 import { focusIndexBeforeResidue } from '../../../tree-operations/paste/focus-target';
 import { replaceBlockAtParent } from '../../../tree-operations/paste/replace-block-at-parent';

package/dist/components/blocks/table/table-menu-model.d.ts

@@ -1,14 +1,14 @@
 /**
- * Pure model for the table affordance menu: which items a target cell, row, or column
- * offers and whether each is enabled. Enablement reuses the context's own refusal
- * predicates, so a disabled item can never reach a no-op commit.
+ * Pure model for the cell menu: which items a cell offers and whether each is enabled.
+ * Enablement reuses the context's own refusal predicates, so a disabled item can never reach
+ * a no-op commit.
  */
 import type { TableAxisAction } from '../../../action-contracts';
 import type { TableAlignment } from '../../../core/nodes';
 export type ClipboardAction = 'cut' | 'copy' | 'paste';
 /**
  * Clamp a fixed-position menu's top-left into the viewport (minus `margin`) — menus
- * open at a raw pointer/grip coordinate. Larger than the viewport pins to top/left.
+ * open at a raw pointer coordinate. Larger than the viewport pins to top/left.
  */
 export declare function clampMenuToViewport(desired: {
     x: number;
@@ -23,6 +23,26 @@ export declare function clampMenuToViewport(desired: {
     x: number;
     y: number;
 };
+/**
+ * Where a flyout hung off its parent row ends up on screen: shifted UP just enough to clear the
+ * viewport bottom (never above the top margin) and, when its right edge would overflow, flipped
+ * to the parent menu's left side. Shifting vertically keeps the hovered row pointing into it;
+ * flipping horizontally keeps it off its own parent. Pure, so the two flyouts share one rule.
+ */
+export declare function flyoutPlacement(flyout: {
+    top: number;
+    bottom: number;
+    right: number;
+    width: number;
+}, parentMenu: {
+    left: number;
+}, viewport: {
+    width: number;
+    height: number;
+}, margin?: number): {
+    dy: number;
+    flip: boolean;
+};
 export type TableMenuItem = {
     kind: 'action';
     action: TableAxisAction;
@@ -39,14 +59,21 @@ export type TableMenuItem = {
     current: TableAlignment;
 } | {
     kind: 'separator';
+}
+/** A flyout: the row's or column's less-used actions behind one entry. */
+ | {
+    kind: 'group';
+    id: 'row' | 'column';
+    label: string;
+    items: TableMenuItem[];
 };
-export declare function tableMenuItems(target: {
-    rowIdx?: number;
-    colIdx?: number;
+export declare function tableMenuItems(cell: {
+    rowIdx: number;
+    colIdx: number;
 }, dims: {
     rowCount: number;
     colCount: number;
-}, alignments: readonly TableAlignment[], clipboard?: {
+}, alignments: readonly TableAlignment[], clipboard: {
     hasSelection: boolean;
     hasRect?: boolean;
 }): TableMenuItem[];

package/dist/components/blocks/table/table-menu-model.js

@@ -2,7 +2,7 @@ import { tableRowReorderTarget, tableColumnReorderTarget } from '../../../editor
 import { canDeleteRow, canDeleteColumn } from '../../../tree-operations/table-mutations';
 /**
  * Clamp a fixed-position menu's top-left into the viewport (minus `margin`) — menus
- * open at a raw pointer/grip coordinate. Larger than the viewport pins to top/left.
+ * open at a raw pointer coordinate. Larger than the viewport pins to top/left.
  */
 export function clampMenuToViewport(desired, menu, viewport, margin = 8) {
     const maxX = Math.max(margin, viewport.width - menu.width - margin);
@@ -12,23 +12,42 @@ export function clampMenuToViewport(desired, menu, viewport, margin = 8) {
         y: Math.min(Math.max(margin, desired.y), maxY)
     };
 }
-export function tableMenuItems(target, dims, alignments, 
-// Present only for a cell right-click; grip menus never show the clipboard group. A
-// live rectangle (`hasRect`) suppresses the cell-local selection but still serves Cut/Copy.
+/**
+ * Where a flyout hung off its parent row ends up on screen: shifted UP just enough to clear the
+ * viewport bottom (never above the top margin) and, when its right edge would overflow, flipped
+ * to the parent menu's left side. Shifting vertically keeps the hovered row pointing into it;
+ * flipping horizontally keeps it off its own parent. Pure, so the two flyouts share one rule.
+ */
+export function flyoutPlacement(flyout, parentMenu, viewport, margin = 8) {
+    const overflow = flyout.bottom + margin - viewport.height;
+    const dy = overflow > 0 ? -Math.min(overflow, Math.max(0, flyout.top - margin)) : 0;
+    const overflowsRight = flyout.right + margin > viewport.width;
+    const fitsLeft = parentMenu.left - flyout.width - margin >= 0;
+    return { dy, flip: overflowsRight && fitsLeft };
+}
+export function tableMenuItems(cell, dims, alignments, 
+// A live rectangle (`hasRect`) suppresses the cell-local selection but still serves Cut/Copy.
 clipboard) {
-    const items = [];
-    const isCell = target.rowIdx != null && target.colIdx != null;
-    if (isCell && clipboard)
-        items.push(...clipboardGroup(clipboard.hasSelection || clipboard.hasRect === true), {
-            kind: 'separator'
-        });
-    if (target.rowIdx != null)
-        items.push(...rowGroup(target.rowIdx, dims.rowCount));
-    if (isCell)
-        items.push({ kind: 'separator' });
-    if (target.colIdx != null)
-        items.push(...columnGroup(target.colIdx, dims.colCount, alignments));
-    return items;
+    const rows = rowGroup(cell.rowIdx, dims.rowCount);
+    const cols = columnGroup(cell.colIdx, dims.colCount, alignments);
+    const isDelete = (i) => i.kind === 'action' && (i.action === 'deleteRow' || i.action === 'deleteColumn');
+    // A cell knows both axes, so each axis's inserts and moves fold behind one flyout and only
+    // the two deletes and the alignment stay in the list.
+    return [
+        ...clipboardGroup(clipboard.hasSelection || clipboard.hasRect === true),
+        { kind: 'separator' },
+        { kind: 'group', id: 'row', label: 'Row', items: rows.filter((i) => !isDelete(i)) },
+        {
+            kind: 'group',
+            id: 'column',
+            label: 'Column',
+            items: cols.filter((i) => !isDelete(i) && i.kind !== 'alignment')
+        },
+        { kind: 'separator' },
+        ...rows.filter(isDelete),
+        ...cols.filter(isDelete),
+        ...cols.filter((i) => i.kind === 'alignment')
+    ];
 }
 // Paste always applies: clipboard contents aren't readable synchronously to gate it.
 function clipboardGroup(hasContent) {