phormat 0.0.5

package/dist/editor/block-specs/table/TableRenderer.svelte

@@ -0,0 +1,53 @@
+<script module lang="ts">
+	import { inlineNodesSnippet } from '../../plugins/shared/InlineNodes.svelte';
+	import type { TableBlock, TableCellAlign } from './types';
+
+	const alignClass: Record<NonNullable<TableCellAlign>, string> = {
+		left: 'text-left',
+		center: 'text-center',
+		right: 'text-right'
+	};
+
+	function cellAlignClass(a: TableCellAlign): string {
+		return a ? alignClass[a] : 'text-left';
+	}
+
+	export { tableRenderer };
+</script>
+
+{#snippet tableRenderer(block: TableBlock)}
+	<div class="mb-4 overflow-x-auto">
+		<table
+			class="w-full min-w-[16rem] border-collapse border-b border-border-emphasis text-sm text-txt-primary"
+		>
+			<thead>
+				<tr class="border-b border-border-emphasis">
+					{#each block.headers as header, hIdx (hIdx)}
+						<th class="px-3 py-2 font-semibold {cellAlignClass(block.aligns[hIdx] ?? null)}">
+							{#if block.headerInlines?.[hIdx]?.length}
+								{@render inlineNodesSnippet(block.headerInlines[hIdx])}
+							{:else}
+								{header}
+							{/if}
+						</th>
+					{/each}
+				</tr>
+			</thead>
+			<tbody>
+				{#each block.rows as row, rIdx (rIdx)}
+					<tr class="border-t border-border-default/60">
+						{#each row as cell, cIdx (cIdx)}
+							<td class="px-3 py-2 {cellAlignClass(block.aligns[cIdx] ?? null)}">
+								{#if block.rowInlines?.[rIdx]?.[cIdx]?.length}
+									{@render inlineNodesSnippet(block.rowInlines[rIdx][cIdx])}
+								{:else}
+									{cell}
+								{/if}
+							</td>
+						{/each}
+					</tr>
+				{/each}
+			</tbody>
+		</table>
+	</div>
+{/snippet}

package/dist/editor/block-specs/table/TableRenderer.svelte.d.ts

@@ -0,0 +1,21 @@
+import type { TableBlock } from './types';
+declare const tableRenderer: (block: TableBlock) => ReturnType<import("svelte").Snippet>;
+export { tableRenderer };
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const TableRenderer: $$__sveltets_2_IsomorphicComponent<Record<string, never>, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type TableRenderer = InstanceType<typeof TableRenderer>;
+export default TableRenderer;

package/dist/editor/block-specs/table/commands.d.ts

@@ -0,0 +1,2 @@
+import type { EditorCommand } from '../../commandRegistry';
+export declare const tableCommands: EditorCommand[];

package/dist/editor/block-specs/table/commands.js

@@ -0,0 +1 @@
+export const tableCommands = [];

package/dist/editor/block-specs/table/edit.d.ts

@@ -0,0 +1,10 @@
+import type { InlineNode, TableBlockData, TableCellAddress } from '../../model/types';
+import type { TableBlock } from './types';
+export declare function tableBlockDataToRenderModel(d: TableBlockData): TableBlock;
+export declare function defaultTableBlockData(): TableBlockData;
+export declare function tableCellDisplayPlain(data: TableBlockData, row: number, col: number): string;
+export declare function tableCellModelInlines(data: TableBlockData, row: number, col: number): InlineNode[] | undefined;
+export declare function setTableCellInlines(data: TableBlockData, row: number, col: number, inlines: InlineNode[]): TableBlockData;
+export declare function appendTableRow(data: TableBlockData): TableBlockData;
+export declare function appendTableColumn(data: TableBlockData): TableBlockData;
+export declare function navigateTableCell(data: TableBlockData, row: number, col: number, direction: 'next' | 'prev' | 'down' | 'up'): TableCellAddress | null;

package/dist/editor/block-specs/table/edit.js

@@ -0,0 +1,127 @@
+import { cloneInlineNodeDeep } from '../../model/inlineEditCommands';
+import { inlineNodesToPlainText } from '../../model/inlinePlain';
+export function tableBlockDataToRenderModel(d) {
+    return {
+        lineIndex: d.startLineIndex ?? 0,
+        headers: d.headers,
+        aligns: d.aligns,
+        rows: d.rows,
+        headerInlines: d.headerInlines,
+        rowInlines: d.rowInlines
+    };
+}
+export function defaultTableBlockData() {
+    return {
+        headers: ['', ''],
+        aligns: [null, null],
+        rows: []
+    };
+}
+export function tableCellDisplayPlain(data, row, col) {
+    if (row === -1) {
+        const inlines = data.headerInlines?.[col];
+        if (inlines?.length)
+            return inlineNodesToPlainText(inlines);
+        return data.headers[col] ?? '';
+    }
+    const inlines = data.rowInlines?.[row]?.[col];
+    if (inlines?.length)
+        return inlineNodesToPlainText(inlines);
+    return data.rows[row]?.[col] ?? '';
+}
+export function tableCellModelInlines(data, row, col) {
+    if (row === -1)
+        return data.headerInlines?.[col];
+    return data.rowInlines?.[row]?.[col];
+}
+export function setTableCellInlines(data, row, col, inlines) {
+    const plain = inlineNodesToPlainText(inlines);
+    const cloned = inlines.map(cloneInlineNodeDeep);
+    const next = {
+        ...data,
+        headers: [...data.headers],
+        aligns: [...data.aligns],
+        rows: data.rows.map((r) => [...r]),
+        headerInlines: data.headerInlines?.map((rowInlines) => rowInlines.map(cloneInlineNodeDeep)),
+        rowInlines: data.rowInlines?.map((bodyRow) => bodyRow.map((cellInlines) => cellInlines.map(cloneInlineNodeDeep)))
+    };
+    if (row === -1) {
+        next.headers[col] = plain;
+        const headerInlines = [...(next.headerInlines ?? [])];
+        while (headerInlines.length < next.headers.length)
+            headerInlines.push([]);
+        headerInlines[col] = cloned;
+        next.headerInlines = headerInlines;
+        return next;
+    }
+    while (next.rows.length <= row) {
+        next.rows.push(new Array(next.headers.length).fill(''));
+    }
+    next.rows[row][col] = plain;
+    const rowInlines = [...(next.rowInlines ?? [])];
+    while (rowInlines.length <= row) {
+        rowInlines.push([]);
+    }
+    const cellRow = [...(rowInlines[row] ?? new Array(next.headers.length).fill(undefined))];
+    while (cellRow.length < next.headers.length)
+        cellRow.push([]);
+    cellRow[col] = cloned;
+    rowInlines[row] = cellRow;
+    next.rowInlines = rowInlines;
+    return next;
+}
+export function appendTableRow(data) {
+    const cols = data.headers.length;
+    return {
+        ...data,
+        rows: [...data.rows, new Array(cols).fill('')]
+    };
+}
+export function appendTableColumn(data) {
+    return {
+        ...data,
+        headers: [...data.headers, ''],
+        aligns: [...data.aligns, null],
+        rows: data.rows.map((row) => [...row, ''])
+    };
+}
+export function navigateTableCell(data, row, col, direction) {
+    const cols = data.headers.length;
+    const bodyRows = data.rows.length;
+    if (direction === 'next') {
+        if (col + 1 < cols)
+            return { row, col: col + 1 };
+        if (row === -1) {
+            if (bodyRows > 0)
+                return { row: 0, col: 0 };
+            return null;
+        }
+        if (row + 1 < bodyRows)
+            return { row: row + 1, col: 0 };
+        return null;
+    }
+    if (direction === 'prev') {
+        if (col > 0)
+            return { row, col: col - 1 };
+        if (row === 0)
+            return { row: -1, col: cols - 1 };
+        if (row > 0)
+            return { row: row - 1, col: cols - 1 };
+        return null;
+    }
+    if (direction === 'down') {
+        if (row === -1) {
+            if (bodyRows > 0)
+                return { row: 0, col };
+            return null;
+        }
+        if (row + 1 < bodyRows)
+            return { row: row + 1, col };
+        return null;
+    }
+    if (row === 0)
+        return { row: -1, col };
+    if (row > 0)
+        return { row: row - 1, col };
+    return null;
+}

package/dist/editor/block-specs/table/editCommands.d.ts

@@ -0,0 +1,18 @@
+import { type SourceEditOk, type SourceEditResult } from '../../model/blockEditCommands';
+import type { EditorDocument, InlineNode, TableCellAddress } from '../../model/types';
+import { navigateTableCell } from './edit';
+/** Persist one cell's draft inlines to Markdown source (whole-table reserialize). */
+export declare function commitTableCellInlineDraft(source: string, doc: EditorDocument, blockIndex: number, row: number, col: number, inlines: InlineNode[], _plainCaret: number): SourceEditResult;
+export declare function appendTableRowInDocument(source: string, doc: EditorDocument, blockIndex: number): SourceEditResult | (SourceEditOk & {
+    focusCell: TableCellAddress;
+});
+export declare function appendTableColumnInDocument(source: string, doc: EditorDocument, blockIndex: number): SourceEditResult | (SourceEditOk & {
+    focusCell: TableCellAddress;
+});
+export declare function navigateTableCellInDocument(source: string, doc: EditorDocument, blockIndex: number, from: TableCellAddress, to: TableCellAddress, inlines: InlineNode[], plainCaret: number): SourceEditResult | (SourceEditOk & {
+    focusCell: TableCellAddress;
+    focusPlain: number;
+});
+export { navigateTableCell };
+export declare function convertBlockToTable(source: string, doc: EditorDocument, blockIndex: number): SourceEditResult;
+export declare function cloneTableCellInlines(inlines: InlineNode[]): InlineNode[];

package/dist/editor/block-specs/table/editCommands.js

@@ -0,0 +1,87 @@
+import { replaceBlockSourceRange } from '../../model/blockEditCommands';
+import { cloneInlineNodeDeep } from '../../model/inlineEditCommands';
+import { inlineNodesToPlainText } from '../../model/inlinePlain';
+import { clampSelection } from '../../model/types';
+import { appendTableColumn, appendTableRow, defaultTableBlockData, navigateTableCell, setTableCellInlines, tableCellDisplayPlain } from './edit';
+import { serializeTableData } from './serialize';
+function replaceTableBlock(source, blockIndex, doc, data) {
+    const block = doc.blocks[blockIndex];
+    if (!block || block.type !== 'table')
+        return { ok: false, error: 'Invalid table block.' };
+    if (block.sourceRange.synthetic || block.sourceRange.start < 0) {
+        return { ok: false, error: 'Block is not editable.' };
+    }
+    const replacement = serializeTableData(data);
+    const newSource = replaceBlockSourceRange(source, block.sourceRange.start, block.sourceRange.end, replacement);
+    const anchor = block.sourceRange.start;
+    return {
+        ok: true,
+        source: newSource,
+        selection: clampSelection({ anchor, focus: anchor }, newSource.length)
+    };
+}
+/** Persist one cell's draft inlines to Markdown source (whole-table reserialize). */
+export function commitTableCellInlineDraft(source, doc, blockIndex, row, col, inlines, _plainCaret) {
+    void _plainCaret;
+    const block = doc.blocks[blockIndex];
+    if (!block || block.type !== 'table')
+        return { ok: false, error: 'Invalid table block.' };
+    const data = setTableCellInlines(block.data, row, col, inlines);
+    return replaceTableBlock(source, blockIndex, doc, data);
+}
+export function appendTableRowInDocument(source, doc, blockIndex) {
+    const block = doc.blocks[blockIndex];
+    if (!block || block.type !== 'table')
+        return { ok: false, error: 'Invalid table block.' };
+    const data = appendTableRow(block.data);
+    const result = replaceTableBlock(source, blockIndex, doc, data);
+    if (!result.ok)
+        return result;
+    const lastRow = data.rows.length - 1;
+    return { ...result, focusCell: { row: lastRow, col: 0 } };
+}
+export function appendTableColumnInDocument(source, doc, blockIndex) {
+    const block = doc.blocks[blockIndex];
+    if (!block || block.type !== 'table')
+        return { ok: false, error: 'Invalid table block.' };
+    const data = appendTableColumn(block.data);
+    const result = replaceTableBlock(source, blockIndex, doc, data);
+    if (!result.ok)
+        return result;
+    return { ...result, focusCell: { row: -1, col: data.headers.length - 1 } };
+}
+export function navigateTableCellInDocument(source, doc, blockIndex, from, to, inlines, plainCaret) {
+    const block = doc.blocks[blockIndex];
+    if (!block || block.type !== 'table')
+        return { ok: false, error: 'Invalid table block.' };
+    const data = block.data;
+    const targetPlain = tableCellDisplayPlain(data, to.row, to.col);
+    const focusPlain = Math.min(plainCaret, targetPlain.length);
+    const commit = commitTableCellInlineDraft(source, doc, blockIndex, from.row, from.col, inlines, plainCaret);
+    if (!commit.ok)
+        return commit;
+    return { ...commit, focusCell: to, focusPlain };
+}
+export { navigateTableCell };
+export function convertBlockToTable(source, doc, blockIndex) {
+    const block = doc.blocks[blockIndex];
+    if (!block)
+        return { ok: false, error: 'Block not found.' };
+    if (block.type !== 'paragraph' && block.type !== 'heading') {
+        return { ok: false, error: 'Block type cannot convert to table.' };
+    }
+    if (block.sourceRange.synthetic || block.sourceRange.start < 0) {
+        return { ok: false, error: 'Block is not editable.' };
+    }
+    const replacement = serializeTableData(defaultTableBlockData());
+    const newSource = replaceBlockSourceRange(source, block.sourceRange.start, block.sourceRange.end, replacement);
+    const anchor = block.sourceRange.start;
+    return {
+        ok: true,
+        source: newSource,
+        selection: clampSelection({ anchor, focus: anchor }, newSource.length)
+    };
+}
+export function cloneTableCellInlines(inlines) {
+    return inlines.map(cloneInlineNodeDeep);
+}

package/dist/editor/block-specs/table/index.d.ts

@@ -0,0 +1,8 @@
+export { tableCommands } from './commands';
+export { tableBlockDataToRenderModel } from './edit';
+export { applyTableInlineSecondPass } from './inlineSecondPass';
+export { couldContinueTableRow, couldStartTableAt, parseDelimiterCell, parseTables, padRow, splitTableRow, tryParseTableAt } from './parse';
+export type { FenceAtOpenLine } from './parse';
+export { tableReconcileFingerprint } from './reconcile';
+export { serializeTableBlock, serializeTableData } from './serialize';
+export type { TableBlock, TableCellAlign } from './types';

package/dist/editor/block-specs/table/index.js

@@ -0,0 +1,6 @@
+export { tableCommands } from './commands';
+export { tableBlockDataToRenderModel } from './edit';
+export { applyTableInlineSecondPass } from './inlineSecondPass';
+export { couldContinueTableRow, couldStartTableAt, parseDelimiterCell, parseTables, padRow, splitTableRow, tryParseTableAt } from './parse';
+export { tableReconcileFingerprint } from './reconcile';
+export { serializeTableBlock, serializeTableData } from './serialize';

package/dist/editor/block-specs/table/inlineSecondPass.d.ts

@@ -0,0 +1,3 @@
+import { type RichInlineContext } from '../../model/richInlines';
+import type { EditorBlock } from '../../model/types';
+export declare function applyTableInlineSecondPass(block: EditorBlock, _source: string, _insideBlockquote: boolean, _ctx: RichInlineContext): EditorBlock;

package/dist/editor/block-specs/table/inlineSecondPass.js

@@ -0,0 +1,22 @@
+import { buildRichInlinesForRange, createRichInlineContext } from '../../model/richInlines';
+function parseCellInlines(text) {
+    const ctx = createRichInlineContext(text);
+    return buildRichInlinesForRange(text, 0, text.length, ctx);
+}
+export function applyTableInlineSecondPass(block, _source, _insideBlockquote, _ctx) {
+    void _insideBlockquote;
+    void _ctx;
+    if (block.type !== 'table')
+        return block;
+    const data = block.data;
+    const headerInlines = data.headers.map((header) => parseCellInlines(header));
+    const rowInlines = data.rows.map((row) => row.map((cell) => parseCellInlines(cell)));
+    return {
+        ...block,
+        data: {
+            ...data,
+            headerInlines,
+            rowInlines
+        }
+    };
+}

package/dist/editor/block-specs/table/parse.d.ts

@@ -0,0 +1,17 @@
+import { type LineRow } from '../../model/line-utils';
+import type { EditorBlock } from '../../model/types';
+import type { TableCellAlign } from './types';
+export declare function splitTableRow(line: string): string[];
+/** Escape literal `|` for GFM table cell source (table-only v1). */
+export declare function escapeTableCellPipes(cell: string): string;
+/** Returns `undefined` if the cell is not a valid GFM delimiter cell. */
+export declare function parseDelimiterCell(cell: string): TableCellAlign | undefined;
+export declare function padRow(cells: string[], columnCount: number): string[];
+export declare function couldContinueTableRow(line: string): boolean;
+export declare function parseTables(source: string): import('./types').TableBlock[];
+export type FenceAtOpenLine = ReadonlyMap<number, unknown>;
+export declare function couldStartTableAt(i: number, rows: LineRow[], fenceAtOpenLine: FenceAtOpenLine): boolean;
+export declare function tryParseTableAt(i: number, rows: LineRow[], source: string, fenceAtOpenLine: FenceAtOpenLine): {
+    nextLine: number;
+    block: EditorBlock;
+} | null;

package/dist/editor/block-specs/table/parse.js

@@ -0,0 +1,181 @@
+import { afterLineTerminator } from '../../model/line-utils';
+import { stableBlockId } from '../../model/types';
+export function splitTableRow(line) {
+    const t = line.trim();
+    if (!t.includes('|'))
+        return [];
+    const parts = [];
+    let cur = '';
+    for (let i = 0; i < t.length; i++) {
+        const c = t[i];
+        if (c === '\\' && i + 1 < t.length) {
+            cur += c + t[i + 1];
+            i++;
+            continue;
+        }
+        if (c === '|') {
+            parts.push(cur);
+            cur = '';
+            continue;
+        }
+        cur += c;
+    }
+    parts.push(cur);
+    let start = 0;
+    let end = parts.length;
+    if (t.startsWith('|'))
+        start = 1;
+    if (t.endsWith('|'))
+        end = parts.length - 1;
+    if (start >= end)
+        return [];
+    return parts.slice(start, end).map((c) => c.trim());
+}
+/** Escape literal `|` for GFM table cell source (table-only v1). */
+export function escapeTableCellPipes(cell) {
+    let out = '';
+    for (let i = 0; i < cell.length; i++) {
+        const c = cell[i];
+        if (c === '|' && (i === 0 || cell[i - 1] !== '\\')) {
+            out += '\\|';
+        }
+        else {
+            out += c;
+        }
+    }
+    return out;
+}
+/** Returns `undefined` if the cell is not a valid GFM delimiter cell. */
+export function parseDelimiterCell(cell) {
+    const s = cell.trim();
+    if (/^:-{3,}:$/.test(s))
+        return 'center';
+    if (/^:-{3,}$/.test(s))
+        return 'left';
+    if (/^-{3,}:$/.test(s))
+        return 'right';
+    if (/^-{3,}$/.test(s))
+        return null;
+    return undefined;
+}
+export function padRow(cells, columnCount) {
+    const row = cells.slice(0, columnCount);
+    while (row.length < columnCount)
+        row.push('');
+    return row;
+}
+export function couldContinueTableRow(line) {
+    const t = line.trim();
+    if (t.length === 0)
+        return false;
+    return t.includes('|');
+}
+export function parseTables(source) {
+    const lines = source.split(/\r?\n/);
+    const out = [];
+    let i = 0;
+    while (i < lines.length) {
+        const headerCells = splitTableRow(lines[i]);
+        if (headerCells.length === 0 ||
+            i + 1 >= lines.length ||
+            splitTableRow(lines[i + 1]).length !== headerCells.length) {
+            i++;
+            continue;
+        }
+        const delimCells = splitTableRow(lines[i + 1]);
+        const aligns = [];
+        let delimOk = true;
+        for (const c of delimCells) {
+            const a = parseDelimiterCell(c);
+            if (a === undefined) {
+                delimOk = false;
+                break;
+            }
+            aligns.push(a);
+        }
+        if (!delimOk || aligns.length !== headerCells.length) {
+            i++;
+            continue;
+        }
+        const columnCount = headerCells.length;
+        const rows = [];
+        let j = i + 2;
+        while (j < lines.length && couldContinueTableRow(lines[j])) {
+            rows.push(padRow(splitTableRow(lines[j]), columnCount));
+            j++;
+        }
+        out.push({
+            lineIndex: i,
+            headers: headerCells,
+            aligns,
+            rows
+        });
+        i = j;
+    }
+    return out;
+}
+export function couldStartTableAt(i, rows, fenceAtOpenLine) {
+    if (fenceAtOpenLine.has(i))
+        return false;
+    const headerCells = splitTableRow(rows[i].line);
+    if (headerCells.length === 0 || i + 1 >= rows.length)
+        return false;
+    if (splitTableRow(rows[i + 1].line).length !== headerCells.length)
+        return false;
+    const delimCells = splitTableRow(rows[i + 1].line);
+    for (const c of delimCells) {
+        if (parseDelimiterCell(c) === undefined)
+            return false;
+    }
+    return delimCells.length === headerCells.length;
+}
+export function tryParseTableAt(i, rows, source, fenceAtOpenLine) {
+    if (fenceAtOpenLine.has(i))
+        return null;
+    const headerCells = splitTableRow(rows[i].line);
+    if (headerCells.length === 0 || i + 1 >= rows.length)
+        return null;
+    if (splitTableRow(rows[i + 1].line).length !== headerCells.length)
+        return null;
+    const delimCells = splitTableRow(rows[i + 1].line);
+    const aligns = [];
+    for (const c of delimCells) {
+        const a = parseDelimiterCell(c);
+        if (a === undefined)
+            return null;
+        aligns.push(a);
+    }
+    if (aligns.length !== headerCells.length)
+        return null;
+    const columnCount = headerCells.length;
+    let j = i + 2;
+    const bodyRows = [];
+    while (j < rows.length && couldContinueTableRow(rows[j].line)) {
+        if (fenceAtOpenLine.has(j))
+            break;
+        bodyRows.push(padRow(splitTableRow(rows[j].line), columnCount));
+        j++;
+    }
+    const endLine = j - 1;
+    const sourceRange = {
+        start: rows[i].start,
+        end: afterLineTerminator(source, rows[endLine]),
+        startLine: i,
+        endLine
+    };
+    const data = {
+        headers: headerCells,
+        aligns,
+        rows: bodyRows,
+        startLineIndex: i
+    };
+    return {
+        nextLine: j,
+        block: {
+            type: 'table',
+            id: stableBlockId('table', sourceRange),
+            sourceRange,
+            data
+        }
+    };
+}

package/dist/editor/block-specs/table/reconcile.d.ts

@@ -0,0 +1,2 @@
+import type { EditorBlock } from '../../model/types';
+export declare function tableReconcileFingerprint(block: EditorBlock): string;

package/dist/editor/block-specs/table/reconcile.js

@@ -0,0 +1,6 @@
+export function tableReconcileFingerprint(block) {
+    if (block.type !== 'table')
+        return '';
+    const d = block.data;
+    return `table:${d.headers.join('|')}:${d.rows.map((r) => r.join('|')).join(';')}`;
+}

package/dist/editor/block-specs/table/serialize.d.ts

@@ -0,0 +1,3 @@
+import type { EditorBlock, TableBlockData } from '../../model/types';
+export declare function serializeTableData(d: TableBlockData): string;
+export declare function serializeTableBlock(block: EditorBlock): string;

package/dist/editor/block-specs/table/serialize.js

@@ -0,0 +1,32 @@
+import { serializeInlineNodes } from '../../model/serializeInlineNodes';
+import { escapeTableCellPipes } from './parse';
+function serializeTableCellText(text) {
+    return escapeTableCellPipes(text);
+}
+function delimCell(a) {
+    if (a === 'center')
+        return ':---:';
+    if (a === 'right')
+        return '---:';
+    if (a === 'left')
+        return ':---';
+    return '---';
+}
+function serializeTableRow(cells) {
+    return '| ' + cells.join(' | ') + ' |';
+}
+export function serializeTableData(d) {
+    const headers = d.headers.map((h, i) => serializeTableCellText(d.headerInlines?.[i]?.length ? serializeInlineNodes(d.headerInlines[i]) : h));
+    const rows = d.rows.map((row, ri) => row.map((cell, ci) => serializeTableCellText(d.rowInlines?.[ri]?.[ci]?.length ? serializeInlineNodes(d.rowInlines[ri][ci]) : cell)));
+    const lines = [serializeTableRow(headers), '| ' + d.aligns.map(delimCell).join(' | ') + ' |'];
+    for (const row of rows) {
+        lines.push(serializeTableRow(row));
+    }
+    return lines.join('\n');
+}
+export function serializeTableBlock(block) {
+    if (block.type !== 'table') {
+        throw new Error('serializeTableBlock expects a table block');
+    }
+    return serializeTableData(block.data);
+}

package/dist/editor/block-specs/table/types.d.ts

@@ -0,0 +1,11 @@
+import type { InlineNode } from '../../model/types';
+/** `null` means default (no explicit alignment). */
+export type TableCellAlign = 'left' | 'center' | 'right' | null;
+export type TableBlock = {
+    lineIndex: number;
+    headers: string[];
+    aligns: TableCellAlign[];
+    rows: string[][];
+    headerInlines?: InlineNode[][];
+    rowInlines?: InlineNode[][][];
+};

package/dist/editor/block-specs/table/types.js

@@ -0,0 +1 @@
+export {};

package/dist/editor/block-specs/tableSpec.d.ts

@@ -0,0 +1,2 @@
+import type { BlockSpec } from './types';
+export declare const tableSpec: BlockSpec;

package/dist/editor/block-specs/tableSpec.js

@@ -0,0 +1,25 @@
+import EditableTable from '../blocks/EditableTable.svelte';
+import { tableCommands } from './table/commands';
+import { tableBlockDataToRenderModel } from './table/edit';
+import { applyTableInlineSecondPass } from './table/inlineSecondPass';
+import { couldContinueTableRow, couldStartTableAt, parseTables, tryParseTableAt } from './table/parse';
+import { tableReconcileFingerprint } from './table/reconcile';
+import { serializeTableBlock } from './table/serialize';
+import { tableRenderer } from './table/TableRenderer.svelte';
+export const tableSpec = {
+    type: 'table',
+    id: 'tables',
+    render: tableRenderer,
+    editComponent: EditableTable,
+    parse: { couldContinueTableRow, couldStartTableAt, parseTables, tryParseTableAt },
+    serialize: serializeTableBlock,
+    applyInlineSecondPass: applyTableInlineSecondPass,
+    reconcileFingerprint: tableReconcileFingerprint,
+    commands: tableCommands,
+    toRenderBlock: (block) => ({
+        id: block.id,
+        pluginId: 'tables',
+        data: tableBlockDataToRenderModel(block.data),
+        render: tableRenderer
+    })
+};