phormat 0.0.5

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

@@ -0,0 +1,188 @@
+import { afterLineTerminator } from '../../model/line-utils';
+import { paragraphBlocksFromLines } from '../paragraph/parse';
+import { stableBlockId } from '../../model/types';
+/** Optional leading whitespace, then one or more `>` each optionally followed by spaces/tabs. */
+const BLOCKQUOTE_PREFIX = /^\s*((?:>\s*)+)(.*)$/;
+/** `> ` markers prefix; captures leading whitespace, marker run, trailing payload. */
+const BLOCKQUOTE_LINE = /^(\s*)((?:>\s*)+)(.*)$/;
+export function parseBlockquoteLine(line) {
+    const match = line.match(BLOCKQUOTE_PREFIX);
+    if (!match)
+        return null;
+    const markers = match[1];
+    const depth = (markers.match(/>/g) ?? []).length;
+    let text = match[2];
+    if (text.startsWith(' '))
+        text = text.slice(1);
+    return { depth, text };
+}
+export function parseBlockquoteLineInfo(row, lineIndex, source) {
+    const m = row.line.match(BLOCKQUOTE_LINE);
+    if (!m)
+        return null;
+    const markers = m[2] ?? '';
+    const tail = m[3] ?? '';
+    const depth = (markers.match(/>/g) ?? []).length;
+    return {
+        depth,
+        contentText: tail.startsWith(' ') ? tail.slice(1) : tail,
+        rowStart: row.start,
+        rowEnd: afterLineTerminator(source, row),
+        lineIndex
+    };
+}
+/** `>` marker depth for a content-bearing blockquote from its source opener line. */
+export function quoteDepthFromBlock(block, source) {
+    if (!source || block.sourceRange.startLine < 0)
+        return 0;
+    const line = source.split(/\r?\n/)[block.sourceRange.startLine] ?? '';
+    return parseBlockquoteLine(line)?.depth ?? 0;
+}
+/** True when `child` is a deeper nested quote (`>>`), not a same-depth continuation. */
+export function isNestedQuoteChild(parent, child, source) {
+    if (parent.type !== 'blockquote' || child.type !== 'blockquote')
+        return false;
+    const parentDepth = quoteDepthFromBlock(parent, source);
+    const childDepth = quoteDepthFromBlock(child, source);
+    return parentDepth > 0 && childDepth > parentDepth;
+}
+function makeContentBlockquote(para, paraLines) {
+    const first = paraLines[0];
+    const last = paraLines[paraLines.length - 1];
+    const range = {
+        start: first.rowStart,
+        end: last.rowEnd,
+        startLine: first.lineIndex,
+        endLine: last.lineIndex
+    };
+    return {
+        type: 'blockquote',
+        id: stableBlockId('blockquote', range),
+        sourceRange: range,
+        data: {},
+        children: [],
+        inlines: []
+    };
+}
+function appendParagraphChildrenFromRun(children, paras, paraLines, startParaIndex) {
+    let lineOffset = 0;
+    for (let pi = 0; pi < startParaIndex; pi++) {
+        lineOffset += paras[pi].lines.length;
+    }
+    for (let pi = startParaIndex; pi < paras.length; pi++) {
+        const para = paras[pi];
+        const plines = paraLines.slice(lineOffset, lineOffset + para.lines.length);
+        children.push(makeContentBlockquote(para, plines));
+        lineOffset += para.lines.length;
+    }
+}
+/** Build content-bearing `blockquote` subtree from one nesting level. */
+export function buildBlockquoteAtDepth(lines, depth, source) {
+    const children = [];
+    let root = null;
+    let i = 0;
+    while (i < lines.length) {
+        const cur = lines[i];
+        if (cur.depth > depth) {
+            let j = i;
+            while (j < lines.length && lines[j].depth > depth)
+                j++;
+            children.push(buildBlockquoteAtDepth(lines.slice(i, j), depth + 1, source));
+            i = j;
+            continue;
+        }
+        if (cur.depth < depth)
+            break;
+        if (cur.contentText.trim() === '') {
+            i++;
+            continue;
+        }
+        let j = i;
+        while (j < lines.length && lines[j].depth === depth && lines[j].contentText.trim() !== '') {
+            j++;
+        }
+        const paraLines = lines.slice(i, j);
+        const contentLines = paraLines.map((l) => l.contentText);
+        const paras = paragraphBlocksFromLines(contentLines, paraLines[0].lineIndex);
+        if (!root) {
+            root = makeContentBlockquote(paras[0], paraLines.slice(0, paras[0].lines.length));
+            appendParagraphChildrenFromRun(children, paras, paraLines, 1);
+        }
+        else {
+            appendParagraphChildrenFromRun(children, paras, paraLines, 0);
+        }
+        i = j;
+    }
+    if (!root) {
+        const first = lines[0];
+        const last = lines[lines.length - 1];
+        const range = {
+            start: first.rowStart,
+            end: last.rowEnd,
+            startLine: first.lineIndex,
+            endLine: last.lineIndex
+        };
+        root = {
+            type: 'blockquote',
+            id: stableBlockId('blockquote', range),
+            sourceRange: range,
+            data: {},
+            children: [],
+            inlines: []
+        };
+    }
+    root.children = children.length > 0 ? children : undefined;
+    return root;
+}
+function appendText(children, text) {
+    const last = children[children.length - 1];
+    if (last?.kind === 'text') {
+        last.text += '\n' + text;
+    }
+    else {
+        children.push({ kind: 'text', text });
+    }
+}
+function buildLegacyTree(lines) {
+    const root = [];
+    const stack = [root];
+    for (const { depth, text } of lines) {
+        while (stack.length > depth) {
+            stack.pop();
+        }
+        while (stack.length < depth) {
+            const nested = { kind: 'quote', children: [] };
+            stack[stack.length - 1].push(nested);
+            stack.push(nested.children);
+        }
+        appendText(stack[stack.length - 1], text);
+    }
+    return root;
+}
+/** Legacy region parser retained for tooling; canonical upload parse uses `buildBlockquoteAtDepth`. */
+export function parseBlockquotes(source) {
+    const lines = source.split(/\r?\n/);
+    const out = [];
+    let i = 0;
+    while (i < lines.length) {
+        const firstParsed = parseBlockquoteLine(lines[i]);
+        if (!firstParsed) {
+            i++;
+            continue;
+        }
+        const start = i;
+        const regionLines = [];
+        while (i < lines.length) {
+            const line = lines[i];
+            const parsed = parseBlockquoteLine(line);
+            if (!parsed)
+                break;
+            regionLines.push(parsed);
+            i++;
+        }
+        if (regionLines.length > 0) {
+            out.push({ lineIndex: start, children: buildLegacyTree(regionLines) });
+        }
+    }
+    return out;
+}

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

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

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

@@ -0,0 +1,9 @@
+export function blockquoteReconcileFingerprint(block, childFingerprint) {
+    if (block.type !== 'blockquote')
+        return '';
+    if (block.inlines?.length) {
+        return childFingerprint({ ...block, type: 'paragraph' });
+    }
+    const first = block.children?.[0];
+    return first ? childFingerprint(first) : '';
+}

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

@@ -0,0 +1,6 @@
+import type { EditorBlock } from '../../model/types';
+declare function indentLines(text: string, prefix: string): string;
+/** Blockquote-prefix every line; blank lines collapse to bare `>` (not `> `). */
+declare function blockquotePrefix(text: string): string;
+export declare function serializeBlockquoteBlock(block: EditorBlock, serializeChild: (block: EditorBlock) => string, source?: string): string;
+export { indentLines, blockquotePrefix };

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

@@ -0,0 +1,55 @@
+import { serializeInlineNodes } from '../../model/serializeInlineNodes';
+import { parseBlockquoteLine, quoteDepthFromBlock } from './parse';
+function indentLines(text, prefix) {
+    return text
+        .split('\n')
+        .map((l) => prefix + l)
+        .join('\n');
+}
+/** Blockquote-prefix every line; blank lines collapse to bare `>` (not `> `). */
+function blockquotePrefix(text) {
+    return text
+        .split('\n')
+        .map((l) => (l.length === 0 ? '>' : `> ${l}`))
+        .join('\n');
+}
+function blockquoteBodyFromSource(block, source) {
+    if (block.inlines?.length)
+        return serializeInlineNodes(block.inlines);
+    if (!source || block.sourceRange.start < 0 || block.sourceRange.synthetic)
+        return '';
+    const slice = source.slice(block.sourceRange.start, block.sourceRange.end);
+    const firstLine = slice.split('\n')[0] ?? '';
+    const m = firstLine.match(/^\s*(?:>\s*)+(.*)$/);
+    return (m ? m[1] : firstLine).trimEnd();
+}
+export function serializeBlockquoteBlock(block, serializeChild, source) {
+    if (block.type !== 'blockquote') {
+        throw new Error('serializeBlockquoteBlock expects a blockquote block');
+    }
+    const parts = [];
+    const body = blockquoteBodyFromSource(block, source);
+    if (body.length > 0)
+        parts.push(body);
+    const parentDepth = quoteDepthFromBlock(block, source);
+    for (const child of block.children ?? []) {
+        if (child.type === 'blockquote' && parentDepth > 0) {
+            const childDepth = quoteDepthFromBlock(child, source);
+            if (childDepth === parentDepth) {
+                const childBody = blockquoteBodyFromSource(child, source);
+                if (childBody.length > 0)
+                    parts.push(childBody);
+                for (const sub of child.children ?? []) {
+                    parts.push('');
+                    parts.push(serializeChild(sub));
+                }
+                continue;
+            }
+        }
+        parts.push('');
+        parts.push(serializeChild(child));
+    }
+    const inner = parts.join('\n');
+    return blockquotePrefix(inner);
+}
+export { indentLines, blockquotePrefix };

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

@@ -0,0 +1,20 @@
+export type BlockquoteLineInfo = {
+    depth: number;
+    contentText: string;
+    rowStart: number;
+    rowEnd: number;
+    lineIndex: number;
+};
+export type BlockquoteText = {
+    kind: 'text';
+    text: string;
+};
+export type BlockquoteQuote = {
+    kind: 'quote';
+    children: BlockquoteChild[];
+};
+export type BlockquoteChild = BlockquoteText | BlockquoteQuote;
+export type BlockquoteBlock = {
+    lineIndex: number;
+    children: BlockquoteChild[];
+};

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

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

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

@@ -0,0 +1,4 @@
+import type { BlockSpec } from './types';
+import { blockquoteReconcileFingerprint } from './blockquote/reconcile';
+export declare const blockquoteSpec: BlockSpec;
+export { blockquoteReconcileFingerprint };

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

@@ -0,0 +1,37 @@
+import EditableBlockquote from '../blocks/EditableBlockquote.svelte';
+import { listItemReconcileFingerprint } from './list/reconcile';
+import { paragraphReconcileFingerprint } from './paragraph/reconcile';
+import { blockquoteCommands } from './blockquote/commands';
+import { blockquoteRenderer } from './blockquote/BlockquoteRenderer.svelte';
+import { serializeEditorBlock } from '../model/serializeMarkdownDocument';
+import { buildBlockquoteAtDepth, parseBlockquoteLine, parseBlockquoteLineInfo } from './blockquote/parse';
+import { blockquoteReconcileFingerprint } from './blockquote/reconcile';
+import { serializeBlockquoteBlock } from './blockquote/serialize';
+function blockquoteChildFingerprint(block) {
+    if (block.type === 'listItem')
+        return listItemReconcileFingerprint(block);
+    if (block.type === 'paragraph')
+        return paragraphReconcileFingerprint(block);
+    if (block.type === 'blockquote') {
+        return blockquoteReconcileFingerprint(block, blockquoteChildFingerprint);
+    }
+    return '';
+}
+export const blockquoteSpec = {
+    type: 'blockquote',
+    id: 'blockquotes',
+    render: blockquoteRenderer,
+    editComponent: EditableBlockquote,
+    parse: { parseBlockquoteLine, parseBlockquoteLineInfo, buildBlockquoteAtDepth },
+    serialize: (block, source) => serializeBlockquoteBlock(block, (child) => serializeEditorBlock(child, source), source),
+    applyInlineSecondPass: (block) => block,
+    reconcileFingerprint: (block) => blockquoteReconcileFingerprint(block, blockquoteChildFingerprint),
+    commands: blockquoteCommands,
+    toRenderBlock: (block) => ({
+        id: block.id,
+        pluginId: 'blockquotes',
+        data: block,
+        render: blockquoteRenderer
+    })
+};
+export { blockquoteReconcileFingerprint };

package/dist/editor/block-specs/callout/CalloutRenderer.svelte

@@ -0,0 +1,38 @@
+<script module lang="ts">
+	import { getBlockSpec } from '../../block-specs/registry';
+	import type { EditorBlock } from '../../model/types';
+	import { calloutAccentFor } from './icons';
+	import type { CalloutBlock } from './types';
+	import CalloutTypeIcon from './CalloutTypeIcon.svelte';
+
+	export { calloutRenderer };
+</script>
+
+{#snippet calloutChildBody(child: EditorBlock)}
+	{@const spec = getBlockSpec(child.type)}
+	{#if spec}
+		{@render spec.render(child)}
+	{:else}
+		<p class="text-sm text-txt-tertiary">Unsupported block in callout: {child.type}</p>
+	{/if}
+{/snippet}
+
+{#snippet calloutRenderer(block: EditorBlock)}
+	{@const data = block.data as CalloutBlock}
+	{@const accent = calloutAccentFor(data.type)}
+	<aside class="mb-4 border-l-4 py-1 pl-4 {accent.bar}">
+		<div class="mb-2 flex items-start gap-2">
+			<CalloutTypeIcon type={data.type} class="mt-0.5 h-5 w-5 shrink-0 {accent.title}" />
+			{#if data.title}
+				<h3 class="min-w-0 flex-1 text-base font-semibold {accent.title}">{data.title}</h3>
+			{/if}
+		</div>
+		{#if block.children && block.children.length > 0}
+			<div class="callout-body space-y-1 text-sm leading-relaxed text-txt-secondary">
+				{#each block.children as child (child.id)}
+					{@render calloutChildBody(child)}
+				{/each}
+			</div>
+		{/if}
+	</aside>
+{/snippet}

package/dist/editor/block-specs/callout/CalloutRenderer.svelte.d.ts

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

package/dist/editor/block-specs/callout/CalloutTypeIcon.svelte

@@ -0,0 +1,14 @@
+<script lang="ts">
+    import Icon from '@iconify/svelte'
+	import { calloutIconFor } from './icons';
+
+	let {
+		type,
+		class: className = ''
+	}: {
+		type: string;
+		class?: string;
+	} = $props();
+</script>
+
+<Icon icon={calloutIconFor(type)} class={className} aria-hidden="true" />

package/dist/editor/block-specs/callout/CalloutTypeIcon.svelte.d.ts

@@ -0,0 +1,7 @@
+type $$ComponentProps = {
+    type: string;
+    class?: string;
+};
+declare const CalloutTypeIcon: import("svelte").Component<$$ComponentProps, {}, "">;
+type CalloutTypeIcon = ReturnType<typeof CalloutTypeIcon>;
+export default CalloutTypeIcon;

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

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

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

@@ -0,0 +1,65 @@
+const moveShortcut = { ariaKeyShortcuts: 'Alt+Shift+ArrowUp' };
+const moveDownShortcut = { ariaKeyShortcuts: 'Alt+Shift+ArrowDown' };
+function isCalloutBodyRow(ctx) {
+    return ctx.nestedRowBlockId !== undefined && ctx.blockType === 'callout';
+}
+export const calloutCommands = [
+    {
+        id: 'duplicateCalloutChild',
+        label: 'Duplicate',
+        group: 'structure',
+        surfaces: ['blockMenu'],
+        blockTypes: ['callout'],
+        nestedRowOnly: true,
+        isEnabled: (ctx) => isCalloutBodyRow(ctx),
+        run: (ctx) => {
+            if (!ctx.nestedRowBlockId)
+                return;
+            ctx.editor.duplicateCalloutChildAt(ctx.blockIndex, ctx.nestedRowBlockId);
+        }
+    },
+    {
+        id: 'deleteCalloutChild',
+        label: 'Delete',
+        group: 'structure',
+        surfaces: ['blockMenu'],
+        blockTypes: ['callout'],
+        nestedRowOnly: true,
+        isEnabled: (ctx) => isCalloutBodyRow(ctx),
+        run: (ctx) => {
+            if (!ctx.nestedRowBlockId)
+                return;
+            ctx.editor.deleteCalloutChildAt(ctx.blockIndex, ctx.nestedRowBlockId);
+        }
+    },
+    {
+        id: 'moveCalloutChildUp',
+        label: 'Move up',
+        group: 'structure',
+        surfaces: ['blockMenu'],
+        blockTypes: ['callout'],
+        nestedRowOnly: true,
+        isEnabled: (ctx) => isCalloutBodyRow(ctx) && ctx.canMoveUp,
+        run: (ctx) => {
+            if (!ctx.nestedRowBlockId)
+                return;
+            ctx.editor.moveCalloutChildSiblingAt(ctx.blockIndex, ctx.nestedRowBlockId, 'up');
+        },
+        shortcut: moveShortcut
+    },
+    {
+        id: 'moveCalloutChildDown',
+        label: 'Move down',
+        group: 'structure',
+        surfaces: ['blockMenu'],
+        blockTypes: ['callout'],
+        nestedRowOnly: true,
+        isEnabled: (ctx) => isCalloutBodyRow(ctx) && ctx.canMoveDown,
+        run: (ctx) => {
+            if (!ctx.nestedRowBlockId)
+                return;
+            ctx.editor.moveCalloutChildSiblingAt(ctx.blockIndex, ctx.nestedRowBlockId, 'down');
+        },
+        shortcut: moveDownShortcut
+    }
+];

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

@@ -0,0 +1,10 @@
+/** Curated callout variants shown in the type popover. */
+export declare const CURATED_CALLOUT_TYPES: readonly ["note", "tip", "important", "warning", "caution", "success", "error"];
+export type CuratedCalloutType = (typeof CURATED_CALLOUT_TYPES)[number];
+export declare function normalizeCalloutType(type: string): string;
+export declare function calloutIconFor(type: string): string;
+export declare function calloutAccentFor(type: string): {
+    bar: string;
+    title: string;
+};
+export declare function calloutTypeLabel(type: CuratedCalloutType): string;

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

@@ -0,0 +1,52 @@
+/** Curated callout variants shown in the type popover. */
+export const CURATED_CALLOUT_TYPES = [
+    'note',
+    'tip',
+    'important',
+    'warning',
+    'caution',
+    'success',
+    'error'
+];
+const TYPE_ICONS = {
+    note: 'carbon:information',
+    tip: 'carbon:idea',
+    important: 'carbon:star-filled',
+    warning: 'carbon:warning-alt',
+    caution: 'carbon:warning',
+    success: 'carbon:checkmark-filled',
+    error: 'carbon:error'
+};
+const TYPE_ALIASES = {
+    info: 'note',
+    danger: 'error'
+};
+const TYPE_ACCENTS = {
+    note: { bar: 'border-l-option-blue', title: 'text-option-blue' },
+    tip: { bar: 'border-l-semantic-success', title: 'text-semantic-success' },
+    important: { bar: 'border-l-option-purple', title: 'text-option-purple' },
+    warning: { bar: 'border-l-semantic-warning', title: 'text-semantic-warning' },
+    caution: { bar: 'border-l-semantic-warning', title: 'text-semantic-warning' },
+    success: { bar: 'border-l-semantic-success', title: 'text-semantic-success' },
+    error: { bar: 'border-l-semantic-error', title: 'text-semantic-error' }
+};
+const FALLBACK_ACCENT = { bar: 'border-l-border-emphasis', title: 'text-txt-primary' };
+export function normalizeCalloutType(type) {
+    const key = type.toLowerCase();
+    return TYPE_ALIASES[key] ?? key;
+}
+export function calloutIconFor(type) {
+    const key = normalizeCalloutType(type);
+    if (key in TYPE_ICONS)
+        return TYPE_ICONS[key];
+    return 'carbon:help';
+}
+export function calloutAccentFor(type) {
+    const key = normalizeCalloutType(type);
+    if (key in TYPE_ACCENTS)
+        return TYPE_ACCENTS[key];
+    return FALLBACK_ACCENT;
+}
+export function calloutTypeLabel(type) {
+    return type.charAt(0).toUpperCase() + type.slice(1);
+}

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

@@ -0,0 +1,9 @@
+export { calloutCommands } from './commands';
+export { applyCalloutInlineSecondPass } from './inlineSecondPass';
+export { parseCallouts, tryParseCalloutAt } from './parse';
+export { parseCalloutBodyBlocks, stripCalloutQuoteLine } from './parseBody';
+export { CURATED_CALLOUT_TYPES, calloutAccentFor, calloutIconFor, normalizeCalloutType } from './icons';
+export type { FenceAtOpenLine } from './parse';
+export { calloutReconcileFingerprint } from './reconcile';
+export { serializeCalloutBlock, serializeCalloutData } from './serialize';
+export type { CalloutBlock } from './types';

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

@@ -0,0 +1,7 @@
+export { calloutCommands } from './commands';
+export { applyCalloutInlineSecondPass } from './inlineSecondPass';
+export { parseCallouts, tryParseCalloutAt } from './parse';
+export { parseCalloutBodyBlocks, stripCalloutQuoteLine } from './parseBody';
+export { CURATED_CALLOUT_TYPES, calloutAccentFor, calloutIconFor, normalizeCalloutType } from './icons';
+export { calloutReconcileFingerprint } from './reconcile';
+export { serializeCalloutBlock, serializeCalloutData } from './serialize';

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

@@ -0,0 +1,6 @@
+import type { RichInlineContext } from '../../model/richInlines';
+import type { EditorBlock } from '../../model/types';
+import type { LineRow } from '../../model/line-utils';
+type AnnotateBlockFn = (block: EditorBlock, source: string, rows: LineRow[], ctx: RichInlineContext, insideBlockquote: boolean) => EditorBlock;
+export declare function applyCalloutInlineSecondPass(block: EditorBlock, source: string, rows: LineRow[], ctx: RichInlineContext, annotateBlock: AnnotateBlockFn): EditorBlock;
+export {};

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

@@ -0,0 +1,9 @@
+export function applyCalloutInlineSecondPass(block, source, rows, ctx, annotateBlock) {
+    if (block.type !== 'callout')
+        return block;
+    const out = { ...block };
+    if (block.children && block.children.length > 0) {
+        out.children = block.children.map((c) => annotateBlock(c, source, rows, ctx, true));
+    }
+    return out;
+}

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

@@ -0,0 +1,9 @@
+import { type LineRow } from '../../model/line-utils';
+import type { EditorBlock } from '../../model/types';
+import type { CalloutBlock } from './types';
+export declare function parseCallouts(source: string): CalloutBlock[];
+export type FenceAtOpenLine = ReadonlyMap<number, unknown>;
+export declare function tryParseCalloutAt(i: number, rows: LineRow[], source: string, fenceAtOpenLine: FenceAtOpenLine): {
+    nextLine: number;
+    block: EditorBlock;
+} | null;