@quillmark/svelte 0.27.0 → 0.28.0

package/dist/core/codec/table.js

@@ -1,4 +1,5 @@
 import { core } from '../lifecycle.js';
+import { usvLength } from './decode.js';
 import { contentEdit, pmToContent } from './encode.js';
 import { valueEqual } from './reconcile.js';
 /** The alignments a column can take: the four the content declares, `none` first
@@ -9,11 +10,9 @@ export function emptyCell() {
     return { text: '', marks: [] };
 }
 /**
- * The row index space the chrome and the ops share: **0 is the header**, 1…n the body
- * rows. The split is how a table is stored, not a rank the ops answer to: a row op
- * works {@link allRows} and whichever row lands at index 0 is the header afterwards,
- * so index 0 moves and deletes like any other. The one row the model refuses is the
- * last, there being no table under it.
+ * The row index space the chrome and the ops share: **0 is the header**, 1…n the body rows. A row
+ * op works {@link allRows}, and whichever row lands at index 0 is the header afterwards. The one
+ * row the model refuses is the last, there being no table under it.
  */
 export function rowCount(props) {
     return props.rows.length + 1;
@@ -22,8 +21,10 @@ export function rowCount(props) {
 export function rowCells(props, r) {
     return r === 0 ? props.header : (props.rows[r - 1] ?? []);
 }
-/** Whether a row holds no text, which is what tells a row on offer from one taken up
- *  (`table-view.ts` §`step`). Text alone: a mark over none is nothing a writer can see. */
+/**
+ * Whether a row holds no text, telling a row on offer from one taken up (`table-view.ts` §`step`).
+ * Text alone: a mark over none is invisible.
+ */
 export function rowEmpty(props, r) {
     return rowCells(props, r).every((cell) => cell.text === '');
 }
@@ -36,43 +37,144 @@ export function columnCount(props) {
     return props.aligns.length;
 }
 /**
- * The rectangularizing constructor: one column count across `header`, every row,
- * `aligns` and `widths`, padding with empty cells, `none` and auto-fit. The column
- * count is the widest thing present, so a caller that appended to one axis alone still
- * gets a rectangle back, and a table is never narrower than one column. The layout
- * keys ride through, each absent at its default as the store writes it.
+ * The rectangularizing constructor: one column count (the widest thing present, at least one)
+ * across `header`, every row, `aligns` and `widths`, padding with empty cells, `none` and auto-fit.
+ * The layout keys ride through, each absent at its default as the store writes it.
  */
 export function normalizeTable(props) {
     const cols = Math.max(1, props.header.length, props.aligns.length, ...props.rows.map((row) => row.length));
     const fit = (cells) => Array.from({ length: cols }, (_, c) => cells[c] ?? emptyCell());
     const widths = Array.from({ length: cols }, (_, c) => props.widths?.[c] ?? null);
+    const [header = [], ...rows] = settleSpans([fit(props.header), ...props.rows.map(fit)], props.head);
     return {
-        header: fit(props.header),
-        rows: props.rows.map(fit),
+        header,
+        rows,
         aligns: Array.from({ length: cols }, (_, c) => props.aligns[c] ?? 'none'),
         ...(widths.some((w) => w !== null) && { widths }),
         ...(props.align && { align: props.align }),
-        ...(props.headless && { headless: true })
+        ...(props.head !== undefined && props.head !== 1 && { head: props.head })
+    };
+}
+/** How many rows from the top draw as header rows, absent being one. */
+export function headRows(props) {
+    return props.head ?? 1;
+}
+const SPAN_KEYS = ['colspan', 'rowspan'];
+/** A span key as the cell holds it: a whole number from 1, else 1. */
+function spanKey(cell, key) {
+    const n = cell[key];
+    return typeof n === 'number' && Number.isInteger(n) && n >= 1 ? n : 1;
+}
+/**
+ * Per row of {@link allRows} and per cell, the extent a drawn cell spans, or `null` for a slot
+ * another's span covers: the rule upstream draws and stores by. Cells claim slots in reading order,
+ * so an earlier span wins. A span takes the columns to its right, then the rows below, while each
+ * slot it would cover holds a cell with no text and no mark that no other span covers, stopping at
+ * the grid's edge and at the end of its own section (header rows or body).
+ */
+function spansOf(rows, head) {
+    const top = Math.min(head, rows.length);
+    const covered = rows.map((row) => row.map(() => false));
+    const spans = rows.map((row) => row.map(() => null));
+    const free = (r, c) => {
+        const cell = rows[r]?.[c];
+        return !!cell && cell.text === '' && cell.marks.length === 0 && !covered[r][c];
+    };
+    for (let r = 0; r < rows.length; r++) {
+        const end = r < top ? top : rows.length;
+        for (let c = 0; c < rows[r].length; c++) {
+            if (covered[r][c])
+                continue;
+            const cell = rows[r][c];
+            let w = 1;
+            while (w < spanKey(cell, 'colspan') && free(r, c + w))
+                w++;
+            let h = 1;
+            const rowFree = (y) => Array.from({ length: w }, (_, x) => c + x).every((x) => free(y, x));
+            while (h < spanKey(cell, 'rowspan') && r + h < end && rowFree(r + h))
+                h++;
+            for (let y = r; y < r + h; y++)
+                for (let x = c; x < c + w; x++)
+                    covered[y][x] = true;
+            spans[r][c] = { colspan: w, rowspan: h };
+        }
+    }
+    return spans;
+}
+/** {@link spansOf} over a table's rows, header first. */
+export function spanGrid(props) {
+    return spansOf(allRows(props), headRows(props));
+}
+/**
+ * The drawn cell whose span covers `(r, c)`; the slot itself where nothing covers it or it lies
+ * outside the grid.
+ */
+export function anchorAt(grid, r, c) {
+    for (let y = r; y >= 0; y--)
+        for (let x = c; x >= 0; x--) {
+            const span = grid[y]?.[x];
+            if (span && y + span.rowspan > r && x + span.colspan > c)
+                return { r: y, c: x, span };
+        }
+    return { r, c, span: { colspan: 1, rowspan: 1 } };
+}
+/** `cell` holding `span`, each key absent at 1. */
+function withSpan(cell, span) {
+    const { colspan: _colspan, rowspan: _rowspan, ...rest } = cell;
+    return {
+        ...rest,
+        ...(span.colspan > 1 && { colspan: span.colspan }),
+        ...(span.rowspan > 1 && { rowspan: span.rowspan })
     };
 }
 /**
- * The rows as one list, header first: the space a row op works in. `header` is a
- * separate field because a table always has one and `header: []` is not a table — a
- * storage shape, not a rank a row op has to know about. Reading it as one list is what
- * lets move and delete treat every row alike, and {@link fromRows} splits it back.
+ * Each span written as the cell can cover it, absent at 1, and a covered cell's span keys dropped,
+ * its alignment kept: what the store settles a table to. A key holding no whole number from 1 stays
+ * as written and reads as 1.
+ */
+function settleSpans(rows, head = 1) {
+    const spans = spansOf(rows, head);
+    return rows.map((row, r) => row.map((cell, c) => {
+        const span = spans[r][c];
+        if (!span)
+            return withSpan(cell, { colspan: 1, rowspan: 1 });
+        const settled = { ...cell };
+        for (const key of SPAN_KEYS) {
+            if (spanKey(cell, key) === 1 && cell[key] !== 1)
+                continue;
+            if (span[key] > 1)
+                settled[key] = span[key];
+            else
+                delete settled[key];
+        }
+        return settled;
+    }));
+}
+/** Every span in the grid, by its drawn cell. */
+function spanList(props) {
+    return spanGrid(props).flatMap((row, r) => row.flatMap((span, c) => span && (span.colspan > 1 || span.rowspan > 1) ? [{ r, c, span }] : []));
+}
+/** `rows` with the span of the cell at `(r, c)` set to `span`. */
+function respan(rows, r, c, span) {
+    return rows.map((row, y) => y === r ? row.map((cell, x) => (x === c ? withSpan(cell, span) : cell)) : row);
+}
+/**
+ * The rows as one list, header first: the space a row op works in, so move and delete treat every
+ * row alike. `header` is a separate field because a table always has one; {@link fromRows} splits
+ * it back.
  */
 export function allRows(props) {
     return [props.header, ...props.rows];
 }
-/** A flat list back into the stored shape: whatever sits at index 0 is the header, by
- *  position rather than by having been one. No caller passes an empty list — every op
- *  that could reach one refuses the last row first. */
+/**
+ * A flat list back into the stored shape: whatever sits at index 0 is the header. No caller passes
+ * an empty list; every op that could reach one refuses the last row first.
+ */
 function fromRows(props, rows) {
     const [header = [], ...rest] = rows;
     return normalizeTable({ ...props, header, rows: rest });
 }
-/** A fresh table: a header plus `bodyRows` empty rows, every column unaligned.
- *  Growth is cheap (Tab at the last cell appends a row), so the default is small. */
+/** A fresh table: a header plus `bodyRows` empty rows, every column unaligned. */
 export function newTable(cols = 3, bodyRows = 2) {
     return normalizeTable({
         header: Array.from({ length: cols }, emptyCell),
@@ -93,28 +195,48 @@ export function withCell(props, r, c, cell) {
 export function insertRow(props, r) {
     const at = Math.max(0, Math.min(r, props.rows.length));
     const fresh = Array.from({ length: columnCount(props) }, emptyCell);
-    return normalizeTable({
-        ...props,
-        rows: [...props.rows.slice(0, at), fresh, ...props.rows.slice(at)]
-    });
+    let rows = allRows(props);
+    for (const { r: y, c, span } of spanList(props))
+        if (y <= at && y + span.rowspan - 1 > at)
+            rows = respan(rows, y, c, { ...span, rowspan: span.rowspan + 1 });
+    return fromRows(props, [...rows.slice(0, at + 1), fresh, ...rows.slice(at + 1)]);
 }
-/** Drop row `r`, the header included: the row left at index 0 is the header, which is
- *  how a table whose first row went still has one. A no-op at the last row, that being
- *  the removal of the table rather than of a row, and the island's own to answer. */
+/**
+ * Drop row `r`, the header included: the row left at index 0 becomes the header. A no-op at the
+ * last row, which is the removal of the table and the island's to answer.
+ */
 export function deleteRow(props, r) {
-    const rows = allRows(props);
+    let rows = allRows(props);
     if (rows.length <= 1 || r < 0 || r >= rows.length)
         return normalizeTable(props);
+    for (const { r: y, c, span } of spanList(props)) {
+        if (y > r || y + span.rowspan <= r)
+            continue;
+        const shorter = { ...span, rowspan: span.rowspan - 1 };
+        if (y < r)
+            rows = respan(rows, y, c, shorter);
+        else if (span.rowspan > 1) {
+            // The drawn cell goes with its row, so the one under it takes its text and the rest of
+            // the span.
+            const moved = withSpan(rows[y][c], shorter);
+            rows = rows.map((row, i) => i === y + 1 ? row.map((cell, x) => (x === c ? moved : cell)) : row);
+        }
+    }
     return fromRows(props, rows.filter((_, i) => i !== r));
 }
 /** A new empty column after column `c`. */
 export function insertColumn(props, c) {
     const at = Math.max(0, Math.min(c + 1, columnCount(props)));
     const splice = (xs, fresh) => [...xs.slice(0, at), fresh, ...xs.slice(at)];
+    let rows = allRows(props);
+    for (const { r, c: x, span } of spanList(props))
+        if (x < at && x + span.colspan > at)
+            rows = respan(rows, r, x, { ...span, colspan: span.colspan + 1 });
+    const [header = [], ...body] = rows;
     return normalizeTable({
         ...props,
-        header: splice(props.header, emptyCell()),
-        rows: props.rows.map((row) => splice(row, emptyCell())),
+        header: splice(header, emptyCell()),
+        rows: body.map((row) => splice(row, emptyCell())),
         aligns: splice(props.aligns, 'none'),
         widths: props.widths && splice(props.widths, null)
     });
@@ -124,57 +246,109 @@ export function deleteColumn(props, c) {
     if (columnCount(props) <= 1)
         return normalizeTable(props);
     const drop = (xs) => xs.filter((_, i) => i !== c);
+    let rows = allRows(props);
+    for (const { r, c: x, span } of spanList(props)) {
+        if (x > c || x + span.colspan <= c)
+            continue;
+        const narrower = { ...span, colspan: span.colspan - 1 };
+        if (x < c)
+            rows = respan(rows, r, x, narrower);
+        else if (span.colspan > 1) {
+            const moved = withSpan(rows[r][x], narrower);
+            rows = rows.map((row, i) => i === r ? row.map((cell, y) => (y === x + 1 ? moved : cell)) : row);
+        }
+    }
+    const [header = [], ...body] = rows;
     return normalizeTable({
         ...props,
-        header: drop(props.header),
-        rows: props.rows.map(drop),
+        header: drop(header),
+        rows: body.map(drop),
         aligns: drop(props.aligns),
         widths: props.widths && drop(props.widths)
     });
 }
-/** One element moved within an array, out of place. The whole of what both move ops
- *  do to their axis, which is why they can only disagree about the index. */
+/** `xs` read down its columns. */
+function transpose(xs) {
+    return Array.from({ length: xs[0]?.length ?? 0 }, (_, c) => xs.map((row) => row[c]));
+}
+/**
+ * `lines` with a span released wherever moving line `from` to `to` would leave the lines it covers
+ * out of order or apart. Each span names its drawn cell by `line` and its place `at` along it, and
+ * the `length` it runs across the lines under `key`; a span whose lines keep their order and stay
+ * together keeps it.
+ */
+function unspan(lines, spans, key, from, to) {
+    const order = move(lines.map((_, i) => i), from, to);
+    const place = (i) => order.indexOf(i);
+    let out = lines;
+    for (const { line, at, length } of spans) {
+        const together = Array.from({ length: length - 1 }, (_, k) => line + k).every((i) => place(i + 1) === place(i) + 1);
+        if (together)
+            continue;
+        out = out.map((cells, i) => i === line
+            ? cells.map((cell, x) => {
+                if (x !== at)
+                    return cell;
+                const { [key]: _span, ...rest } = cell;
+                return rest;
+            })
+            : cells);
+    }
+    return out;
+}
+/**
+ * One element moved within an array, out of place: the whole of what both move ops do to their
+ * axis.
+ */
 function move(xs, from, to) {
     const next = [...xs];
     const [moved] = next.splice(from, 1);
     next.splice(to, 0, moved);
     return next;
 }
-/** Row `r` moved by `by` places, clamped: a drag that leaves the rectangle is a no-op
- *  rather than an error, since the drop target is geometry and geometry runs past the
- *  last row. The header travels like any other row, and so does the row that displaces
- *  it: being the header is holding index 0, which a move is free to hand over. */
+/**
+ * Row `r` moved by `by` places, clamped: a drag past the rectangle is a no-op, not an error. The
+ * header travels like any other row; being the header is holding index 0.
+ */
 export function moveRow(props, r, by) {
     const rows = allRows(props);
     const to = Math.max(0, Math.min(r + by, rows.length - 1));
     if (r === to || r < 0 || r >= rows.length)
         return normalizeTable(props);
-    return fromRows(props, move(rows, r, to));
+    const spans = spanList(props).map(({ r: line, c: at, span }) => ({
+        line,
+        at,
+        length: span.rowspan
+    }));
+    return fromRows(props, move(unspan(rows, spans, 'rowspan', r, to), r, to));
 }
-/** Column `c` moved by `by` places, clamped. `aligns` and `widths` travel with the
- *  column: each is the column's property, so a move that left it behind would retint
- *  or resize the column that took the index. */
+/**
+ * Column `c` moved by `by` places, clamped. `aligns` and `widths` travel with the column, being its
+ * properties.
+ */
 export function moveColumn(props, c, by) {
     const to = Math.max(0, Math.min(c + by, columnCount(props) - 1));
     if (c === to || c < 0 || c >= columnCount(props))
         return normalizeTable(props);
     const shift = (xs) => move(xs, c, to);
+    const spans = spanList(props).map(({ r: at, c: line, span }) => ({
+        line,
+        at,
+        length: span.colspan
+    }));
+    const [header = [], ...body] = transpose(unspan(transpose(allRows(props)), spans, 'colspan', c, to));
     return normalizeTable({
         ...props,
-        header: shift(props.header),
-        rows: props.rows.map(shift),
+        header: shift(header),
+        rows: body.map(shift),
         aligns: shift(props.aligns),
         widths: props.widths && shift(props.widths)
     });
 }
 /**
- * Every cell in the inclusive rectangle emptied, alignment kept: what a delete gesture
- * means over a block of cells that covers no whole rank. A rectangle spanning one axis
- * covers ranks and deletes them, and one spanning both is the table itself, so what
- * reaches here is a proper sub-rectangle and the shape it leaves is the shape it found.
- *
- * A cell keeps its own alignment, and a column its alignment and width: what a clear
- * empties is text.
+ * Every cell in the inclusive rectangle emptied, alignment kept (a cell its own, a column its
+ * alignment and width): a delete over a block covering no whole rank. A rectangle spanning one axis
+ * deletes ranks and one spanning both is the table, so what reaches here is a proper sub-rectangle.
  */
 export function clearCells(props, r0, c0, r1, c1) {
     const blank = (cells, r) => cells.map((cell, c) => r >= r0 && r <= r1 && c >= c0 && c <= c1 ? { ...cell, text: '', marks: [] } : cell);
@@ -184,8 +358,10 @@ export function clearCells(props, r0, c0, r1, c1) {
         rows: props.rows.map((row, i) => blank(row, i + 1))
     });
 }
-/** Set column `c`'s alignment and clear its cells' own `align`, which would outrank it:
- *  what the held column's cluster and Shift+arrow write (`table-view.ts`). */
+/**
+ * Set column `c`'s alignment and clear its cells' own `align`, which would outrank it
+ * (`table-view.ts`).
+ */
 export function setAlign(props, c, align) {
     const release = (cells) => cells.map((cell, i) => {
         if (i !== c || cell.align === undefined)
@@ -200,21 +376,96 @@ export function setAlign(props, c, align) {
         aligns: props.aligns.map((a, i) => (i === c ? align : a))
     });
 }
-/** Draw the first row as a header or as a body row: what the header toggle writes
- *  (`table-view.ts`). */
-export function setHeadless(props, headless) {
-    return normalizeTable({ ...props, headless: headless || undefined });
+/** Draw the top `head` rows as header rows (`table-view.ts`). */
+export function setHead(props, head) {
+    return normalizeTable({ ...props, head });
 }
-/** Set or clear the column weights: what a border drag and its double-click write
- *  (`table-view.ts`). `undefined` returns every column to auto-fit. */
+/** `block` grown until every drawn cell it touches lies wholly inside it. */
+export function closeBlock(props, block) {
+    const grid = spanGrid(props);
+    let { r0, c0, r1, c1 } = block;
+    for (let grown = true; grown;) {
+        grown = false;
+        for (let r = r0; r <= r1; r++)
+            for (let c = c0; c <= c1; c++) {
+                const a = anchorAt(grid, r, c);
+                const next = {
+                    r0: Math.min(r0, a.r),
+                    c0: Math.min(c0, a.c),
+                    r1: Math.max(r1, a.r + a.span.rowspan - 1),
+                    c1: Math.max(c1, a.c + a.span.colspan - 1)
+                };
+                if (next.r0 !== r0 || next.c0 !== c0 || next.r1 !== r1 || next.c1 !== c1) {
+                    ({ r0, c0, r1, c1 } = next);
+                    grown = true;
+                }
+            }
+    }
+    return { r0, c0, r1, c1 };
+}
+/**
+ * Whether `block` can be one cell: more than one drawn cell, inside the header rows or the body.
+ */
+export function canMerge(props, block) {
+    const { r0, c0, r1, c1 } = closeBlock(props, block);
+    const head = headRows(props);
+    const across = r0 < head && r1 >= head;
+    const { span } = anchorAt(spanGrid(props), r0, c0);
+    return !across && span.colspan * span.rowspan < (r1 - r0 + 1) * (c1 - c0 + 1);
+}
+/**
+ * The block's cells as one, at its top-left: the text of each drawn cell holding any, in reading
+ * order, a line apiece, every other slot an empty one the span covers, alignment kept. The top-left
+ * cell's alignment is the merged cell's. A block {@link canMerge} refuses comes back as it was.
+ */
+export function mergeCells(props, block) {
+    if (!canMerge(props, block))
+        return normalizeTable(props);
+    const { r0, c0, r1, c1 } = closeBlock(props, block);
+    const grid = spanGrid(props);
+    const rows = allRows(props);
+    let text = '';
+    const marks = [];
+    for (let r = r0; r <= r1; r++)
+        for (let c = c0; c <= c1; c++) {
+            const cell = rows[r][c];
+            if (!grid[r][c] || cell.text === '')
+                continue;
+            if (text)
+                text += '\n';
+            const at = usvLength(text);
+            text += cell.text;
+            for (const m of cell.marks)
+                marks.push({ ...m, start: m.start + at, end: m.end + at });
+        }
+    const merged = rows.map((row, r) => row.map((cell, c) => {
+        if (r < r0 || r > r1 || c < c0 || c > c1)
+            return cell;
+        const layout = withSpan({ ...cell, text: '', marks: [] }, { colspan: 1, rowspan: 1 });
+        if (r !== r0 || c !== c0)
+            return layout;
+        return withSpan({ ...layout, text, marks }, { colspan: c1 - c0 + 1, rowspan: r1 - r0 + 1 });
+    }));
+    return fromRows(props, merged);
+}
+/**
+ * The merged cell covering `(r, c)` back to the cells under it: its text stays top-left, the rest
+ * are the empty cells it covered.
+ */
+export function splitCell(props, r, c) {
+    const a = anchorAt(spanGrid(props), r, c);
+    return fromRows(props, respan(allRows(props), a.r, a.c, { colspan: 1, rowspan: 1 }));
+}
+/**
+ * Set or clear the column weights (`table-view.ts`); `undefined` returns every column to auto-fit.
+ */
 export function setWidths(props, widths) {
     return normalizeTable({ ...props, widths });
 }
 /**
- * Each column's share of the table's width, summing to 1, or `undefined` for a table
- * that auto-fits throughout. An auto-fit column beside weighted ones takes the mean
- * weight: the page sizes it to its content, which the editor's grid, laid out fixed so
- * the weights hold, cannot ask.
+ * Each column's share of the table's width, summing to 1, or `undefined` for a table that auto-fits
+ * throughout. An auto-fit column beside weighted ones takes the mean weight, since the editor's
+ * fixed-layout grid cannot size it to content as the page does.
  */
 export function columnShares(props) {
     const set = props.widths?.filter((w) => w !== null);
@@ -227,10 +478,8 @@ export function columnShares(props) {
 }
 // ── The cell codec ──────────────────────────────────────────────────────────
 /**
- * A cell as a one-paragraph `Content`: what `decode` takes under `cellSchema`. Each
- * `\n` in the text opens a `continues` line, which is the hard break it decodes to and
- * the one USV `pmToContent` projects a break back to. The cell's marks are that
- * content's marks, both being offsets into the same text.
+ * A cell as a one-paragraph `Content` for `decode` under `cellSchema`: each `\n` opens a
+ * `continues` line, the hard break it decodes to. The cell's marks are that content's marks.
  */
 export function cellContent(cell) {
     const breaks = cell.text.split('\n').length - 1;
@@ -251,14 +500,11 @@ export function cellContent(cell) {
 /**
  * The cell a nested PM doc projects, carrying `prior`'s identity anchors through.
  *
- * Anchors inside a cell are **preserved verbatim, never minted**: they are not in
- * the field plugin's coordinate space (the field's position map holds one `atom`
- * run for the whole table), so nothing here can mint one and the popover withholds
- * its `anchor` button while the caret is in a cell. Preserving them still means
- * rebasing: a cell edit is a splice like any other, so `mapMarks` carries each held
- * anchor through the cell's own delta by the rule the store applies to a field's,
- * and a mark the splice deleted through lands where the splice left it rather than
- * pointing past the text.
+ * Anchors inside a cell are preserved verbatim, never minted: they are not in the field plugin's
+ * coordinate space (its position map holds one `atom` run for the whole table), so the popover
+ * withholds its `anchor` button in a cell. Preserving still means rebasing: `mapMarks` carries each
+ * held anchor through the cell's delta by the store's rule, and a mark the splice deleted through
+ * lands where the splice left it.
  */
 export function cellFromDoc(doc, prior) {
     const projected = pmToContent(doc);
@@ -283,9 +529,10 @@ function cellLayout(cell) {
     const { text: _text, marks: _marks, ...layout } = cell;
     return layout;
 }
-/** Whether two cells are the same value: what tells an own edit (the projection the
- *  view just produced) from an external one (an undo, a re-hydrate) without a flag.
- *  The marks structurally, for the reason `reconcile.ts` states. */
+/**
+ * Whether two cells are the same value, telling an own edit from an external one (an undo, a
+ * re-hydrate) without a flag. Marks compare structurally, as `reconcile.ts` states.
+ */
 export function cellEqual(a, b) {
     return a.text === b.text && valueEqual(a.marks, b.marks);
 }
@@ -295,6 +542,7 @@ export function shapeEqual(a, b) {
     return (a.rows.length === b.rows.length &&
         a.aligns.length === b.aligns.length &&
         a.aligns.every((x, i) => x === b.aligns[i]) &&
-        !a.headless === !b.headless &&
+        headRows(a) === headRows(b) &&
+        valueEqual(spanGrid(a), spanGrid(b)) &&
         valueEqual(a.widths, b.widths));
 }

package/dist/core/codec/tasks.d.ts

@@ -17,3 +17,9 @@ export declare function taskPlugin(): Plugin;
  * Shift-Tab lift keeps it.
  */
 export declare function splitTaskItem(itemType: NodeType): Command;
+/**
+ * `checked` flipped on the nearest task item around the caret, or on a selected task item,
+ * as one transaction. It declines outside a task item and inside a fence, where `baseKeymap`'s `exitCode` is the
+ * nearer answer to `Mod-Enter`.
+ */
+export declare function toggleTask(itemType: NodeType): Command;

package/dist/core/codec/tasks.js

@@ -1,10 +1,10 @@
 // A task item is a `list_item` whose `checked` is a boolean (CODEC §"Task items"). Its
 // `toDOM` draws a checkbox ahead of the item's blocks, disabled, which is the drawing a
 // held leaf, a copy and `renderContent` take; a leaf that edits mounts the item through
-// `taskItemView`, whose checkbox toggles. A task item is minted by source mode and by a
-// paste alone: no shorthand, command or key makes one.
+// `taskItemView`, whose checkbox toggles, as `Mod-Enter` does (`toggleTask`). A task item
+// is minted by source mode and by a paste alone: no shorthand, command or key makes one.
 import { DOMSerializer } from 'prosemirror-model';
-import { Plugin } from 'prosemirror-state';
+import { NodeSelection, Plugin } from 'prosemirror-state';
 import { splitListItem } from 'prosemirror-schema-list';
 const SVG = 'http://www.w3.org/2000/svg';
 /** The id the checkbox names its item's blocks by, fresh per drawing. */
@@ -138,3 +138,30 @@ export function splitTaskItem(itemType) {
         });
     };
 }
+/**
+ * `checked` flipped on the nearest task item around the caret, or on a selected task item,
+ * as one transaction. It declines outside a task item and inside a fence, where `baseKeymap`'s `exitCode` is the
+ * nearer answer to `Mod-Enter`.
+ */
+export function toggleTask(itemType) {
+    return (state, dispatch) => {
+        const { selection } = state;
+        const { $from } = selection;
+        if (selection instanceof NodeSelection &&
+            selection.node.type === itemType &&
+            isTask(selection.node)) {
+            dispatch?.(state.tr.setNodeAttribute(selection.from, 'checked', !selection.node.attrs.checked));
+            return true;
+        }
+        if ($from.parent.type.spec.code)
+            return false;
+        for (let d = $from.depth; d > 0; d--) {
+            const node = $from.node(d);
+            if (node.type !== itemType || !isTask(node))
+                continue;
+            dispatch?.(state.tr.setNodeAttribute($from.before(d), 'checked', !node.attrs.checked));
+            return true;
+        }
+        return false;
+    };
+}