phormat 0.0.5

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

@@ -0,0 +1,83 @@
+import { afterLineTerminator } from '../../model/line-utils';
+import { stableBlockId } from '../../model/types';
+import { parseCalloutBodyBlocks } from './parseBody';
+/** First line of an extended callout: `> [!type] Title`. */
+const CALLOUT_OPENER = /^\s*>\s*\[!([a-zA-Z][a-zA-Z0-9_-]*)\]\s*(.*)$/;
+/** Continuation line inside the same blockquote (not another callout opener). */
+const BLANK_QUOTE_LINE = /^\s*>\s*$/;
+const QUOTE_CONTINUATION = /^\s*>\s?(.*)$/;
+export function parseCallouts(source) {
+    const lines = source.split(/\r?\n/);
+    const out = [];
+    for (let i = 0; i < lines.length; i++) {
+        const opener = lines[i].match(CALLOUT_OPENER);
+        if (!opener)
+            continue;
+        const type = opener[1];
+        const title = opener[2].trim();
+        let j = i + 1;
+        while (j < lines.length) {
+            const line = lines[j];
+            if (CALLOUT_OPENER.test(line))
+                break;
+            if (BLANK_QUOTE_LINE.test(line)) {
+                j++;
+                continue;
+            }
+            const cont = line.match(QUOTE_CONTINUATION);
+            if (!cont)
+                break;
+            j++;
+        }
+        out.push({ type, title, lineIndex: i });
+        i = j - 1;
+    }
+    return out;
+}
+export function tryParseCalloutAt(i, rows, source, fenceAtOpenLine) {
+    const row = rows[i];
+    if (!row || fenceAtOpenLine.has(i))
+        return null;
+    const opener = row.line.match(/^\s*>\s*\[!([^\]]+)\]\s*(.*)$/);
+    if (!opener)
+        return null;
+    const type = opener[1];
+    const title = (opener[2] ?? '').trim();
+    let j = i + 1;
+    while (j < rows.length) {
+        const line = rows[j].line;
+        if (/^\s*>\s*\[!([^\]]+)\]\s*(.*)$/.test(line))
+            break;
+        if (/^\s*>\s*$/.test(line)) {
+            j++;
+            continue;
+        }
+        const cont = line.match(/^\s*>\s?(.*)$/);
+        if (!cont)
+            break;
+        j++;
+    }
+    const endLine = j - 1;
+    const sourceRange = {
+        start: row.start,
+        end: afterLineTerminator(source, rows[endLine]),
+        startLine: i,
+        endLine
+    };
+    const data = {
+        type,
+        title,
+        lineIndex: i
+    };
+    const children = j > i + 1 ? parseCalloutBodyBlocks(rows, i + 1, j, source, fenceAtOpenLine) : [];
+    return {
+        nextLine: j,
+        block: {
+            type: 'callout',
+            id: stableBlockId('callout', sourceRange),
+            sourceRange,
+            data,
+            children: children.length > 0 ? children : undefined
+        }
+    };
+}

package/dist/editor/block-specs/callout/parseBody.d.ts

@@ -0,0 +1,6 @@
+import { type LineRow } from '../../model/line-utils';
+import type { EditorBlock } from '../../model/types';
+import type { FenceAtOpenLine } from './parse';
+export declare function stripCalloutQuoteLine(line: string): string | null;
+/** Parse quoted callout continuation lines into nested blocks. */
+export declare function parseCalloutBodyBlocks(rows: LineRow[], start: number, end: number, source: string, fenceAtOpenLine: FenceAtOpenLine): EditorBlock[];

package/dist/editor/block-specs/callout/parseBody.js

@@ -0,0 +1,290 @@
+import { buildBlockquoteAtDepth, parseBlockquoteLine, parseBlockquoteLineInfo } from '../blockquote/parse';
+import { buildListItemForest, parseListLine } from '../list/parse';
+import { paragraphBlocksFromLines } from '../paragraph/parse';
+import { afterLineTerminator } from '../../model/line-utils';
+import { stableBlockId } from '../../model/types';
+const FENCE_OPEN = /^(\s*)(`{3,})(.*)$/;
+const INNER_CALLOUT_OPENER = /^\s*\[!([^\]]+)\]\s*(.*)$/;
+export function stripCalloutQuoteLine(line) {
+    if (/^\s*>\s*$/.test(line))
+        return '';
+    const cont = line.match(/^\s*>\s?(.*)$/);
+    return cont ? (cont[1] ?? '') : null;
+}
+function tryParseFenceInCalloutAt(i, rows, end, source) {
+    const row = rows[i];
+    if (!row)
+        return null;
+    const stripped = stripCalloutQuoteLine(row.line);
+    if (stripped === null)
+        return null;
+    const open = stripped.match(FENCE_OPEN);
+    if (!open)
+        return null;
+    const fenceLen = open[2].length;
+    const langMatch = open[3] ?? '';
+    const lang = langMatch.trim() === '' ? null : (langMatch.trim().split(/\s+/)[0] ?? null);
+    const bodyLines = [];
+    let j = i + 1;
+    while (j < end) {
+        const inner = stripCalloutQuoteLine(rows[j].line);
+        if (inner === null)
+            break;
+        const close = inner.match(/^(`{3,})\s*$/);
+        if (close && close[1].length >= fenceLen)
+            break;
+        bodyLines.push(inner);
+        j++;
+    }
+    if (j >= end)
+        return null;
+    const closeRow = rows[j];
+    const sourceRange = {
+        start: row.start,
+        end: afterLineTerminator(source, closeRow),
+        startLine: i,
+        endLine: j
+    };
+    const data = {
+        kind: 'fenced',
+        language: lang,
+        code: bodyLines.join('\n'),
+        startLine: i
+    };
+    return {
+        nextLine: j + 1,
+        block: {
+            type: 'codeFence',
+            id: stableBlockId('codeFence', sourceRange),
+            sourceRange,
+            data
+        }
+    };
+}
+function tryParseToggleInCalloutAt(i, rows, end, source) {
+    const row = rows[i];
+    if (!row)
+        return null;
+    const stripped = stripCalloutQuoteLine(row.line);
+    if (stripped === null)
+        return null;
+    const openMatch = stripped.match(/^\s*\+\+\+\s+(.+)$/);
+    if (!openMatch)
+        return null;
+    const title = (openMatch[1] ?? '').trim();
+    const bodyLines = [];
+    let j = i + 1;
+    while (j < end) {
+        const inner = stripCalloutQuoteLine(rows[j].line);
+        if (inner === null)
+            break;
+        if (/^\s*\+\+\+\s*$/.test(inner)) {
+            const endLine = j;
+            const sourceRange = {
+                start: row.start,
+                end: afterLineTerminator(source, rows[endLine]),
+                startLine: i,
+                endLine
+            };
+            return {
+                nextLine: j + 1,
+                block: {
+                    type: 'toggle',
+                    id: stableBlockId('toggle', sourceRange),
+                    sourceRange,
+                    data: {
+                        title,
+                        body: bodyLines.join('\n'),
+                        startLineIndex: i
+                    }
+                }
+            };
+        }
+        bodyLines.push(inner);
+        j++;
+    }
+    return null;
+}
+function tryParseInnerCalloutAt(i, rows, end, source, fenceAtOpenLine) {
+    const row = rows[i];
+    if (!row)
+        return null;
+    const stripped = stripCalloutQuoteLine(row.line);
+    if (stripped === null)
+        return null;
+    const opener = stripped.match(INNER_CALLOUT_OPENER);
+    if (!opener)
+        return null;
+    const type = opener[1];
+    const title = (opener[2] ?? '').trim();
+    let j = i + 1;
+    while (j < end) {
+        const line = rows[j].line;
+        if (/^\s*>\s*\[!([^\]]+)\]\s*(.*)$/.test(line))
+            break;
+        const inner = stripCalloutQuoteLine(line);
+        if (inner !== null && INNER_CALLOUT_OPENER.test(inner))
+            break;
+        if (/^\s*>\s*$/.test(line)) {
+            j++;
+            continue;
+        }
+        if (stripCalloutQuoteLine(line) === null)
+            break;
+        j++;
+    }
+    const children = j > i + 1 ? parseCalloutBodyBlocks(rows, i + 1, j, source, fenceAtOpenLine) : undefined;
+    const endLine = j - 1;
+    const sourceRange = {
+        start: row.start,
+        end: afterLineTerminator(source, rows[endLine] ?? row),
+        startLine: i,
+        endLine
+    };
+    const data = { type, title, lineIndex: i };
+    return {
+        nextLine: j,
+        block: {
+            type: 'callout',
+            id: stableBlockId('callout', sourceRange),
+            sourceRange,
+            data,
+            children: children?.length ? children : undefined
+        }
+    };
+}
+/** Parse quoted callout continuation lines into nested blocks. */
+export function parseCalloutBodyBlocks(rows, start, end, source, fenceAtOpenLine) {
+    const blocks = [];
+    let i = start;
+    while (i < end) {
+        const row = rows[i];
+        const stripped = stripCalloutQuoteLine(row.line);
+        if (stripped === null) {
+            i++;
+            continue;
+        }
+        if (stripped.trim() === '') {
+            i++;
+            continue;
+        }
+        const fenceHit = tryParseFenceInCalloutAt(i, rows, end, source);
+        if (fenceHit) {
+            blocks.push(fenceHit.block);
+            i = fenceHit.nextLine;
+            continue;
+        }
+        const innerCallout = tryParseInnerCalloutAt(i, rows, end, source, fenceAtOpenLine);
+        if (innerCallout) {
+            blocks.push(innerCallout.block);
+            i = innerCallout.nextLine;
+            continue;
+        }
+        const toggleHit = tryParseToggleInCalloutAt(i, rows, end, source);
+        if (toggleHit) {
+            blocks.push(toggleHit.block);
+            i = toggleHit.nextLine;
+            continue;
+        }
+        const bqProbe = parseBlockquoteLine(row.line);
+        if (bqProbe && bqProbe.depth > 1) {
+            const bqStart = i;
+            const lineInfos = [];
+            while (i < end) {
+                const info = parseBlockquoteLineInfo(rows[i], i, source);
+                if (!info)
+                    break;
+                lineInfos.push(info);
+                i++;
+            }
+            if (lineInfos.length > 0) {
+                const tree = buildBlockquoteAtDepth(lineInfos, 1, source);
+                const endLine = i - 1;
+                tree.sourceRange = {
+                    start: rows[bqStart].start,
+                    end: afterLineTerminator(source, rows[endLine]),
+                    startLine: bqStart,
+                    endLine
+                };
+                tree.id = stableBlockId('blockquote', tree.sourceRange);
+                blocks.push(tree);
+            }
+            continue;
+        }
+        const listHead = parseListLine(stripped, i);
+        if (listHead) {
+            const chunk = [listHead];
+            let j = i + 1;
+            while (j < end) {
+                const inner = stripCalloutQuoteLine(rows[j].line);
+                if (inner === null || inner.trim() === '')
+                    break;
+                const next = parseListLine(inner, j);
+                if (!next)
+                    break;
+                chunk.push(next);
+                j++;
+            }
+            const items = buildListItemForest(chunk, source, rows);
+            for (const item of items) {
+                item.id = stableBlockId('listItem', item.sourceRange);
+                blocks.push(item);
+            }
+            i = j;
+            continue;
+        }
+        const pStart = i;
+        const buf = [];
+        const bufRows = [];
+        while (i < end) {
+            if (fenceAtOpenLine.has(i))
+                break;
+            const r = rows[i];
+            const inner = stripCalloutQuoteLine(r.line);
+            if (inner === null)
+                break;
+            if (inner.trim() === '')
+                break;
+            if (INNER_CALLOUT_OPENER.test(inner))
+                break;
+            if (/^\s*\+\+\+\s+/.test(inner))
+                break;
+            const bqInner = parseBlockquoteLine(r.line);
+            if (bqInner && bqInner.depth > 1)
+                break;
+            if (parseListLine(inner, i))
+                break;
+            buf.push(inner);
+            bufRows.push(r);
+            i++;
+        }
+        if (buf.length === 0) {
+            i++;
+            continue;
+        }
+        const paras = paragraphBlocksFromLines(buf, pStart);
+        let lineOffset = 0;
+        for (const para of paras) {
+            const numLines = para.lines.length;
+            const firstRow = bufRows[lineOffset];
+            const lastRow = bufRows[lineOffset + numLines - 1];
+            const startLine = pStart + lineOffset;
+            const endLine = pStart + lineOffset + numLines - 1;
+            const range = {
+                start: firstRow.start,
+                end: afterLineTerminator(source, lastRow),
+                startLine,
+                endLine
+            };
+            blocks.push({
+                type: 'paragraph',
+                id: stableBlockId('paragraph', range),
+                sourceRange: range,
+                data: para,
+                inlines: []
+            });
+            lineOffset += numLines;
+        }
+    }
+    return blocks;
+}

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

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

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

@@ -0,0 +1,8 @@
+export function calloutReconcileFingerprint(block, childFingerprint) {
+    if (block.type !== 'callout')
+        return '';
+    const d = block.data;
+    const fp = childFingerprint ?? ((c) => `${c.type}:${c.id}`);
+    const childPart = (block.children ?? []).map((c) => fp(c)).join('|');
+    return `callout:${d.type}:${d.title}:${childPart}`;
+}

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

@@ -0,0 +1,5 @@
+import type { EditorBlock } from '../../model/types';
+import type { CalloutBlock } from './types';
+export declare function serializeCalloutOpener(d: CalloutBlock): string;
+export declare function serializeCalloutData(d: CalloutBlock, children?: EditorBlock[]): string;
+export declare function serializeCalloutBlock(block: EditorBlock): string;

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

@@ -0,0 +1,65 @@
+import { serializeBlockquoteBlock } from '../blockquote';
+import { serializeCodeFenceBlock } from '../codeFence';
+import { serializeListRegion } from '../list';
+import { serializeParagraphBlock } from '../paragraph';
+import { serializeToggleBlock } from '../toggle';
+function prefixQuotedLines(markdown) {
+    const lines = [];
+    for (const line of markdown.split('\n')) {
+        lines.push(line.length === 0 ? '>' : `> ${line}`);
+    }
+    return lines;
+}
+function serializeCalloutChild(block) {
+    switch (block.type) {
+        case 'paragraph':
+            return serializeParagraphBlock(block);
+        case 'blockquote':
+            return serializeBlockquoteBlock(block, serializeCalloutChild);
+        case 'codeFence':
+            return serializeCodeFenceBlock(block);
+        case 'toggle':
+            return serializeToggleBlock(block);
+        case 'callout':
+            return serializeCalloutBlock(block);
+        default:
+            return '';
+    }
+}
+function serializeCalloutChildren(children) {
+    const lines = [];
+    let i = 0;
+    while (i < children.length) {
+        if (i > 0)
+            lines.push('>');
+        const child = children[i];
+        if (child.type === 'listItem') {
+            let j = i;
+            while (j < children.length && children[j]?.type === 'listItem')
+                j++;
+            lines.push(...prefixQuotedLines(serializeListRegion(children.slice(i, j))));
+            i = j;
+            continue;
+        }
+        lines.push(...prefixQuotedLines(serializeCalloutChild(child)));
+        i++;
+    }
+    return lines;
+}
+export function serializeCalloutOpener(d) {
+    const base = `> [!${d.type}]`;
+    return d.title.trim().length > 0 ? `${base} ${d.title}` : base;
+}
+export function serializeCalloutData(d, children) {
+    const lines = [serializeCalloutOpener(d)];
+    if (children && children.length > 0) {
+        lines.push(...serializeCalloutChildren(children));
+    }
+    return lines.join('\n');
+}
+export function serializeCalloutBlock(block) {
+    if (block.type !== 'callout') {
+        throw new Error('serializeCalloutBlock expects a callout block');
+    }
+    return serializeCalloutData(block.data, block.children);
+}

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

@@ -0,0 +1,7 @@
+export type CalloutBlock = {
+    /** Alert variant id from `[!type]` (e.g. note, warning). */
+    type: string;
+    title: string;
+    /** Source line index of the opener (parse metadata). */
+    lineIndex: number;
+};

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

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

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

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

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

@@ -0,0 +1,23 @@
+import EditableCallout from '../blocks/EditableCallout.svelte';
+import { calloutCommands } from './callout/commands';
+import { parseCallouts, tryParseCalloutAt } from './callout/parse';
+import { calloutReconcileFingerprint } from './callout/reconcile';
+import { serializeCalloutBlock } from './callout/serialize';
+import { calloutRenderer } from './callout/CalloutRenderer.svelte';
+export const calloutSpec = {
+    type: 'callout',
+    id: 'callout',
+    render: calloutRenderer,
+    editComponent: EditableCallout,
+    parse: { parseCallouts, tryParseCalloutAt },
+    serialize: serializeCalloutBlock,
+    applyInlineSecondPass: (block, _source, _inside, _ctx) => block,
+    reconcileFingerprint: calloutReconcileFingerprint,
+    commands: calloutCommands,
+    toRenderBlock: (block) => ({
+        id: block.id,
+        pluginId: 'callout',
+        data: block,
+        render: calloutRenderer
+    })
+};

package/dist/editor/block-specs/codeFence/CodeFenceRenderer.svelte

@@ -0,0 +1,18 @@
+<script module lang="ts">
+	import type { CodeFencedData } from './types';
+
+	export { codeFenceRenderer };
+</script>
+
+{#snippet codeFenceRenderer(block: CodeFencedData)}
+	<div
+		class="mb-4 overflow-x-auto border-l-2 border-border-emphasis py-2 pl-4 font-mono text-sm text-txt-primary"
+	>
+		{#if block.language}
+			<p class="mb-2 text-xs font-medium tracking-wide text-txt-tertiary">
+				{block.language}
+			</p>
+		{/if}
+		<pre class="break-words whitespace-pre-wrap">{block.code}</pre>
+	</div>
+{/snippet}

package/dist/editor/block-specs/codeFence/CodeFenceRenderer.svelte.d.ts

@@ -0,0 +1,21 @@
+import type { CodeFencedData } from './types';
+declare const codeFenceRenderer: (block: CodeFencedData) => ReturnType<import("svelte").Snippet>;
+export { codeFenceRenderer };
+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 CodeFenceRenderer: $$__sveltets_2_IsomorphicComponent<Record<string, never>, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type CodeFenceRenderer = InstanceType<typeof CodeFenceRenderer>;
+export default CodeFenceRenderer;

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

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

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

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

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

@@ -0,0 +1,5 @@
+export { codeFenceCommands } from './commands';
+export { applyCodeFenceInlineSecondPass } from './inlineSecondPass';
+export { codeFenceReconcileFingerprint } from './reconcile';
+export { serializeCodeFenceBlock } from './serialize';
+export type { CodeFencedData } from './types';

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

@@ -0,0 +1,4 @@
+export { codeFenceCommands } from './commands';
+export { applyCodeFenceInlineSecondPass } from './inlineSecondPass';
+export { codeFenceReconcileFingerprint } from './reconcile';
+export { serializeCodeFenceBlock } from './serialize';

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

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

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

@@ -0,0 +1,5 @@
+export function applyCodeFenceInlineSecondPass(block, _source, _insideBlockquote, _ctx) {
+    if (block.type !== 'codeFence')
+        return block;
+    return block;
+}

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

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

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

@@ -0,0 +1,5 @@
+export function codeFenceReconcileFingerprint(block) {
+    if (block.type !== 'codeFence')
+        return '';
+    return `codeFence:${block.sourceRange.startLine}:${block.sourceRange.endLine}`;
+}

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

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

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

@@ -0,0 +1,8 @@
+export function serializeCodeFenceBlock(block) {
+    if (block.type !== 'codeFence') {
+        throw new Error('serializeCodeFenceBlock expects a codeFence block');
+    }
+    const d = block.data;
+    const lang = d.language ?? '';
+    return `\`\`\`${lang}\n${d.code}\n\`\`\``;
+}

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

@@ -0,0 +1,6 @@
+export type CodeFencedData = {
+    kind: 'fenced';
+    language: string | null;
+    code: string;
+    startLine: number;
+};

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

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

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

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

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

@@ -0,0 +1,23 @@
+import EditableCodeBlock from '../blocks/EditableCodeBlock.svelte';
+import { codeFenceCommands } from './codeFence/commands';
+import { applyCodeFenceInlineSecondPass } from './codeFence/inlineSecondPass';
+import { codeFenceReconcileFingerprint } from './codeFence/reconcile';
+import { serializeCodeFenceBlock } from './codeFence/serialize';
+import { codeFenceRenderer } from './codeFence/CodeFenceRenderer.svelte';
+export const codeFenceSpec = {
+    type: 'codeFence',
+    id: 'code',
+    render: codeFenceRenderer,
+    editComponent: EditableCodeBlock,
+    parse: {},
+    serialize: serializeCodeFenceBlock,
+    applyInlineSecondPass: applyCodeFenceInlineSecondPass,
+    reconcileFingerprint: codeFenceReconcileFingerprint,
+    commands: codeFenceCommands,
+    toRenderBlock: (block) => ({
+        id: block.id,
+        pluginId: 'code',
+        data: block.data,
+        render: codeFenceRenderer
+    })
+};

package/dist/editor/block-specs/columns/ColumnsRenderer.svelte

@@ -0,0 +1,18 @@
+<script module lang="ts">
+	import type { ColumnsBlock } from './types';
+
+	export { columnsRenderer };
+</script>
+
+{#snippet columnsRenderer(block: ColumnsBlock)}
+	<div
+		class="mb-4 grid gap-6 text-txt-primary"
+		style={`grid-template-columns: repeat(${block.columns.length}, minmax(0, 1fr));`}
+	>
+		{#each block.columns as cell, index (index)}
+			<div class="min-w-0 text-sm leading-6 whitespace-pre-wrap text-txt-primary">
+				{cell}
+			</div>
+		{/each}
+	</div>
+{/snippet}