phormat 0.0.5

package/dist/editor/NestedRowChrome.svelte

@@ -0,0 +1,160 @@
+<script lang="ts">
+	import type { Snippet } from 'svelte';
+	import type { Attachment } from 'svelte/attachments';
+	import { dndTreeItem, useContextMenuAPI } from 'phoundry-ui';
+	import { editorCommands, type EditorCommandContext } from './commandRegistry.js';
+	import { openEditorCommandMenu } from './commandMenu.js';
+	import Icon from '@iconify/svelte';
+
+	const GRIP_DRAG_THRESHOLD = 10;
+
+	const noopDndAttach: Attachment = () => () => {};
+
+	let {
+		commandCtx,
+		rowId,
+		treeDepth = 0,
+		gripDisabled = false,
+		canMoveUp,
+		canMoveDown,
+		moveUpCommandId = 'moveBlockUp',
+		moveDownCommandId = 'moveBlockDown',
+		rowClass = '',
+		toolbarAriaLabel = 'Row controls',
+		gripAriaLabel = 'Row actions',
+		menuAriaLabel = 'Block actions',
+		children
+	}: {
+		commandCtx: EditorCommandContext;
+		rowId: string;
+		treeDepth?: number;
+		gripDisabled?: boolean;
+		canMoveUp: boolean;
+		canMoveDown: boolean;
+		moveUpCommandId?: string;
+		moveDownCommandId?: string;
+		rowClass?: string;
+		toolbarAriaLabel?: string;
+		gripAriaLabel?: string;
+		menuAriaLabel?: string;
+		children: Snippet;
+	} = $props();
+
+	const contextMenu = useContextMenuAPI();
+
+	let menuOpen = $state(false);
+	let chromeRoot = $state.raw<HTMLDivElement | null>(null);
+	let gripEl = $state.raw<HTMLButtonElement | null>(null);
+
+	const ctx = $derived({
+		...commandCtx,
+		canMoveUp,
+		canMoveDown
+	});
+
+	function closeBlockMenu({ commandSelected }: { commandSelected: boolean }) {
+		menuOpen = false;
+		if (!commandSelected) {
+			gripEl?.focus();
+		}
+	}
+
+	function openBlockMenu() {
+		if (!gripEl) return;
+		const rect = gripEl.getBoundingClientRect();
+		menuOpen = true;
+		openEditorCommandMenu(contextMenu, {
+			surface: 'blockMenu',
+			ctx,
+			x: rect.left,
+			y: rect.bottom + 4,
+			ariaLabel: menuAriaLabel,
+			onClose: closeBlockMenu
+		});
+	}
+
+	function toggleBlockMenu() {
+		if (menuOpen) {
+			contextMenu.close();
+			return;
+		}
+		openBlockMenu();
+	}
+
+	const rowDndAttach = $derived.by(() => {
+		if (gripDisabled) return undefined;
+		return dndTreeItem({
+			id: rowId,
+			depth: treeDepth,
+			disabled: gripDisabled,
+			dragHandle: '[data-block-grip]',
+			dragThreshold: GRIP_DRAG_THRESHOLD,
+			onClickWithoutDrag: toggleBlockMenu,
+			onDragStart: () => contextMenu.close()
+		});
+	});
+
+	function onGripKeydown(e: KeyboardEvent) {
+		if (e.key === 'Enter' || e.key === ' ') {
+			e.preventDefault();
+			toggleBlockMenu();
+		}
+	}
+
+	function isChromeFocused(): boolean {
+		const active = document.activeElement;
+		if (!active) return false;
+		return !!chromeRoot?.contains(active);
+	}
+
+	function onChromeWindowKeydown(e: KeyboardEvent) {
+		if (!isChromeFocused()) return;
+		if (!e.altKey || !e.shiftKey) return;
+		if (e.key !== 'ArrowUp' && e.key !== 'ArrowDown') return;
+		e.preventDefault();
+		if (e.key === 'ArrowUp') {
+			const cmd = editorCommands.find((c) => c.id === moveUpCommandId);
+			if (cmd?.isEnabled(ctx)) cmd.run(ctx);
+		} else {
+			const cmd = editorCommands.find((c) => c.id === moveDownCommandId);
+			if (cmd?.isEnabled(ctx)) cmd.run(ctx);
+		}
+	}
+</script>
+
+<svelte:window onkeydown={onChromeWindowKeydown} />
+
+<div
+	data-block-row
+	class="group relative flex gap-1 rounded-lg px-1 transition-colors has-[[data-block-row]:hover]:hover:bg-transparent {rowClass}"
+	role="group"
+	{@attach rowDndAttach ?? noopDndAttach}
+>
+	<div
+		bind:this={chromeRoot}
+		class="mt-0.5 relative mr-1 flex shrink-0 items-start opacity-0 transition-opacity group-hover:opacity-100 group-focus-within:opacity-100 group-has-[[data-block-row]:hover]:opacity-0 group-has-[[data-block-row]:focus-within]:opacity-0 has-[[data-block-grip][aria-expanded=true]]:opacity-100"
+		role="toolbar"
+		aria-label={toolbarAriaLabel}
+		aria-keyshortcuts="Alt+Shift+ArrowUp Alt+Shift+ArrowDown"
+	>
+		<button
+			bind:this={gripEl}
+			type="button"
+			data-block-grip
+			title="Drag to reorder · Click for actions"
+			aria-label={gripAriaLabel}
+			aria-haspopup="menu"
+			aria-expanded={menuOpen}
+			aria-keyshortcuts="Alt+Shift+ArrowUp Alt+Shift+ArrowDown"
+			class=" min-h-6 min-w-6 touch-none flex items-center justify-center rounded text-base leading-none text-txt-tertiary hover:bg-surface-raised hover:text-txt-primary {gripDisabled
+				? 'cursor-default'
+				: 'cursor-grab active:cursor-grabbing'} {menuOpen ? 'relative z-50' : ''}"
+			onkeydown={onGripKeydown}
+		>
+			<Icon icon="radix-icons:drag-handle-dots-2" class="w-4 h-4 pointer-events-none" />
+		</button>
+	</div>
+	<div class="min-w-0 flex-1">
+		{@render children()}
+	</div>
+</div>

package/dist/editor/NestedRowChrome.svelte.d.ts

@@ -0,0 +1,20 @@
+import type { Snippet } from 'svelte';
+import { type EditorCommandContext } from './commandRegistry.js';
+type $$ComponentProps = {
+    commandCtx: EditorCommandContext;
+    rowId: string;
+    treeDepth?: number;
+    gripDisabled?: boolean;
+    canMoveUp: boolean;
+    canMoveDown: boolean;
+    moveUpCommandId?: string;
+    moveDownCommandId?: string;
+    rowClass?: string;
+    toolbarAriaLabel?: string;
+    gripAriaLabel?: string;
+    menuAriaLabel?: string;
+    children: Snippet;
+};
+declare const NestedRowChrome: import("svelte").Component<$$ComponentProps, {}, "">;
+type NestedRowChrome = ReturnType<typeof NestedRowChrome>;
+export default NestedRowChrome;

package/dist/editor/PhormatEditor.svelte

@@ -0,0 +1,206 @@
+<!--
+	@component
+	Controlled block markdown editor for embedders. Owns a {@link MarkdownEditor} state instance
+	and syncs via `value` / `onchange`.
+-->
+<script lang="ts">
+	import { onMount } from 'svelte';
+	import { Button, CheckboxToggle, EmptyState } from 'phoundry-ui';
+	import { MarkdownEditor } from './MarkdownEditor.svelte.js';
+	import BlockEditor from './BlockEditor.svelte';
+	import RawMarkdownPanel from './RawMarkdownPanel.svelte';
+	import InlineChromeCoordinator from './inlineChrome/InlineChromeCoordinator.svelte';
+	import { normalizeEmptySource } from './model/emptyParagraph.js';
+	import { setAssetBaseUrlContext, type AssetBaseUrlContext } from './context/assetBaseUrl.js';
+	import {
+		createEditorHistoryHandle,
+		type EditorHistoryHandle
+	} from './editorHistoryHandle.js';
+
+	interface Props {
+		value?: string;
+		fileName?: string | null;
+		readonly?: boolean;
+		showToolbar?: boolean;
+		/** When false, hides the raw-markdown toggle (embedders may supply their own raw surface). */
+		showRawMarkdownToggle?: boolean;
+		showRawMarkdown?: boolean;
+		/** Directory URL (trailing `/`) for resolving relative image/link hrefs at render time. */
+		assetBaseUrl?: string;
+		/** In-session undo/redo for host toolbars (`bind:history`). */
+		history?: EditorHistoryHandle;
+		onchange?: (source: string) => void;
+		onsave?: () => void;
+		class?: string;
+		minHeight?: string;
+		maxHeight?: string;
+	}
+
+	let {
+		value = '',
+		fileName,
+		readonly = false,
+		showToolbar = true,
+		showRawMarkdownToggle = true,
+		showRawMarkdown = $bindable(false),
+		assetBaseUrl,
+		history = $bindable(undefined),
+		onchange,
+		onsave,
+		class: className = '',
+		minHeight = '120px',
+		maxHeight = '400px'
+	}: Props = $props();
+
+	const editor = new MarkdownEditor();
+	const historyHandle = $state(
+		createEditorHistoryHandle({
+			undo: () => editor.undo(),
+			redo: () => editor.redo(),
+			getCanUndo: () => editor.canUndo,
+			getCanRedo: () => editor.canRedo
+		})
+	);
+
+	$effect(() => {
+		history = historyHandle;
+	});
+
+	const assetBaseUrlContext = $state<AssetBaseUrlContext>({ current: undefined });
+	setAssetBaseUrlContext(assetBaseUrlContext);
+
+	$effect(() => {
+		assetBaseUrlContext.current = assetBaseUrl?.trim() || undefined;
+	});
+
+	let editorRoot = $state.raw<HTMLElement | null>(null);
+
+	function valueMatchesEditorSource(propValue: string): boolean {
+		return normalizeEmptySource(propValue) === editor.source;
+	}
+
+	onMount(() => {
+		if (!valueMatchesEditorSource(value)) {
+			editor.setSource(value, { fileName, syncBaseline: true, resetHistory: true });
+		}
+		historyHandle.sync();
+		return editor.onSourceChange(() => {
+			historyHandle.sync();
+			if (!readonly) onchange?.(editor.source);
+		});
+	});
+
+	$effect(() => {
+		editor.setReadonly(readonly);
+	});
+
+	$effect(() => {
+		if (fileName !== undefined && fileName !== editor.fileName) {
+			editor.fileName = fileName;
+		}
+	});
+
+	$effect(() => {
+		if (!valueMatchesEditorSource(value)) {
+			editor.setSource(value, { syncBaseline: true, resetHistory: true });
+			historyHandle.sync();
+		}
+	});
+
+	function handleEditorKeydown(e: KeyboardEvent) {
+		if (!onsave || readonly) return;
+		if ((e.metaKey || e.ctrlKey) && e.key === 's') {
+			e.preventDefault();
+			onsave();
+		}
+	}
+</script>
+
+<svelte:window onkeydown={handleEditorKeydown} />
+
+<section
+	class="flex min-h-0 flex-col overflow-hidden text-txt-primary {className}"
+	style:min-height={minHeight}
+	style:max-height={maxHeight}
+>
+	{#if showToolbar}
+		<div class="mb-4 flex shrink-0 flex-wrap items-center justify-end gap-2 border-b border-border-muted pb-4">
+			{#if showRawMarkdownToggle}
+				<CheckboxToggle
+					checked={showRawMarkdown}
+					onchange={() => (showRawMarkdown = !showRawMarkdown)}
+					label="Raw markdown"
+					size="sm"
+					data-testid="toggle-raw-markdown"
+				/>
+			{/if}
+			<Button
+				variant="secondary"
+				size="sm"
+				icon="carbon:undo"
+				disabled={readonly || !editor.canUndo}
+				aria-label="Undo last edit"
+				onclick={() => editor.undo()}
+			>
+				Undo
+			</Button>
+			<Button
+				variant="secondary"
+				size="sm"
+				icon="carbon:redo"
+				disabled={readonly || !editor.canRedo}
+				aria-label="Redo previously undone edit"
+				onclick={() => editor.redo()}
+			>
+				Redo
+			</Button>
+		</div>
+	{/if}
+
+	{#if editor.document.parseWarnings?.length}
+		<div
+			class="mb-4 shrink-0 rounded-lg border border-semantic-warning/50 bg-semantic-warning/10 px-3 py-2"
+			role="status"
+		>
+			<p class="text-sm font-medium text-txt-primary">Parse notes</p>
+			<ul class="mt-1 list-inside list-disc text-sm text-txt-secondary">
+				{#each editor.document.parseWarnings as w (w)}
+					<li>{w}</li>
+				{/each}
+			</ul>
+		</div>
+	{/if}
+
+	{#if editor.error}
+		<p
+			class="mb-4 shrink-0 rounded-lg border border-semantic-error/50 bg-semantic-error/10 px-3 py-2 text-sm text-semantic-error"
+			role="alert"
+		>
+			{editor.error}
+		</p>
+	{/if}
+
+	<div class="min-h-0 flex-1 overflow-y-auto">
+		{#if editor.blocks.length}
+			<div class={showRawMarkdown ? 'grid grid-cols-2 gap-4' : undefined}>
+				<article bind:this={editorRoot} class="relative">
+					<BlockEditor {editor} />
+					{#if editorRoot && !readonly}
+						<InlineChromeCoordinator {editor} root={editorRoot} />
+					{/if}
+				</article>
+				{#if showRawMarkdown}
+					<RawMarkdownPanel source={editor.source} />
+				{/if}
+			</div>
+		{:else}
+			<EmptyState
+				icon="carbon:document-blank"
+				title="No markdown loaded yet."
+				description="Provide markdown via the value prop to start editing."
+				size="sm"
+				class="rounded-lg border border-dashed border-border-default/60"
+			/>
+		{/if}
+	</div>
+</section>

package/dist/editor/PhormatEditor.svelte.d.ts

@@ -0,0 +1,26 @@
+import { type EditorHistoryHandle } from './editorHistoryHandle.js';
+interface Props {
+    value?: string;
+    fileName?: string | null;
+    readonly?: boolean;
+    showToolbar?: boolean;
+    /** When false, hides the raw-markdown toggle (embedders may supply their own raw surface). */
+    showRawMarkdownToggle?: boolean;
+    showRawMarkdown?: boolean;
+    /** Directory URL (trailing `/`) for resolving relative image/link hrefs at render time. */
+    assetBaseUrl?: string;
+    /** In-session undo/redo for host toolbars (`bind:history`). */
+    history?: EditorHistoryHandle;
+    onchange?: (source: string) => void;
+    onsave?: () => void;
+    class?: string;
+    minHeight?: string;
+    maxHeight?: string;
+}
+/**
+ * Controlled block markdown editor for embedders. Owns a {@link MarkdownEditor} state instance
+ * and syncs via `value` / `onchange`.
+ */
+declare const PhormatEditor: import("svelte").Component<Props, {}, "showRawMarkdown" | "history">;
+type PhormatEditor = ReturnType<typeof PhormatEditor>;
+export default PhormatEditor;

package/dist/editor/RawMarkdownPanel.svelte

@@ -0,0 +1,39 @@
+<script lang="ts">
+	let { source }: { source: string } = $props();
+
+	let preEl = $state<HTMLPreElement | undefined>();
+	let debounceTimer: ReturnType<typeof setTimeout> | undefined;
+	let lastFlushed = '';
+
+	$effect(() => {
+		if (!preEl) return;
+
+		const text = source;
+		if (text === lastFlushed) return;
+
+		if (debounceTimer) clearTimeout(debounceTimer);
+
+		const delay = lastFlushed === '' ? 0 : 120;
+		debounceTimer = setTimeout(() => {
+			preEl!.textContent = text;
+			lastFlushed = text;
+		}, delay);
+
+		return () => {
+			if (debounceTimer) clearTimeout(debounceTimer);
+		};
+	});
+</script>
+
+<div class="rounded-lg border border-border-muted bg-surface-base">
+	<div
+		class="border-b border-border-muted px-3 py-2 text-xs font-medium tracking-wide text-txt-tertiary uppercase"
+	>
+		Raw markdown
+	</div>
+	<pre
+		bind:this={preEl}
+		class="p-3 font-mono text-xs leading-relaxed whitespace-pre-wrap text-txt-secondary"
+		aria-label="Serialized markdown source"
+	></pre>
+</div>

package/dist/editor/RawMarkdownPanel.svelte.d.ts

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

package/dist/editor/block-specs/BlockSpecMissing.svelte

@@ -0,0 +1,12 @@
+<script lang="ts">
+	import type { EditorBlockType } from '../model/types';
+
+	let { blockType }: { blockType: EditorBlockType } = $props();
+</script>
+
+<div
+	class="rounded-md border border-semantic-error/80 bg-semantic-error/10 p-3 text-sm text-semantic-error"
+	role="alert"
+>
+	Missing BlockSpec registration for <code class="text-semantic-error">{blockType}</code>.
+</div>

package/dist/editor/block-specs/BlockSpecMissing.svelte.d.ts

@@ -0,0 +1,7 @@
+import type { EditorBlockType } from '../model/types';
+type $$ComponentProps = {
+    blockType: EditorBlockType;
+};
+declare const BlockSpecMissing: import("svelte").Component<$$ComponentProps, {}, "">;
+type BlockSpecMissing = ReturnType<typeof BlockSpecMissing>;
+export default BlockSpecMissing;

package/dist/editor/block-specs/blockquote/BlockquoteRenderer.svelte

@@ -0,0 +1,32 @@
+<script module lang="ts">
+	import type { EditorBlock } from '../../model/types';
+	import { serializeParagraphData } from '../paragraph/serialize';
+	import type { ParagraphBlock } from '../paragraph/types';
+	import { inlineNodesSnippet } from '../../plugins/shared/InlineNodes.svelte';
+
+	export { blockquoteRenderer };
+</script>
+
+{#snippet bqChildren(children: EditorBlock[])}
+	{#each children as child (child.id)}
+		{#if child.type === 'paragraph'}
+			<p class="mb-1 whitespace-pre-wrap last:mb-0">
+				{#if child.inlines && child.inlines.length > 0}
+					{@render inlineNodesSnippet(child.inlines)}
+				{:else}
+					{serializeParagraphData(child.data as ParagraphBlock)}
+				{/if}
+			</p>
+		{:else if child.type === 'blockquote'}
+			<blockquote class="mb-3 border-l border-border-emphasis pl-4 text-txt-secondary">
+				{@render bqChildren(child.children ?? [])}
+			</blockquote>
+		{/if}
+	{/each}
+{/snippet}
+
+{#snippet blockquoteRenderer(block: EditorBlock)}
+	<blockquote class="mb-4 border-l border-border-emphasis pl-4 text-txt-secondary">
+		{@render bqChildren(block.children ?? [])}
+	</blockquote>
+{/snippet}

package/dist/editor/block-specs/blockquote/BlockquoteRenderer.svelte.d.ts

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

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

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

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

@@ -0,0 +1,65 @@
+const moveShortcut = { ariaKeyShortcuts: 'Alt+Shift+ArrowUp' };
+const moveDownShortcut = { ariaKeyShortcuts: 'Alt+Shift+ArrowDown' };
+function isQuoteBlockRow(ctx) {
+    return ctx.nestedRowBlockId !== undefined && ctx.nestedRowBlockType === 'blockquote';
+}
+export const blockquoteCommands = [
+    {
+        id: 'duplicateQuoteParagraph',
+        label: 'Duplicate',
+        group: 'structure',
+        surfaces: ['blockMenu'],
+        blockTypes: ['blockquote'],
+        nestedRowOnly: true,
+        isEnabled: (ctx) => isQuoteBlockRow(ctx),
+        run: (ctx) => {
+            if (!ctx.nestedRowBlockId)
+                return;
+            ctx.editor.duplicateQuoteParagraphAt(ctx.blockIndex, ctx.nestedRowBlockId);
+        }
+    },
+    {
+        id: 'deleteQuoteParagraph',
+        label: 'Delete',
+        group: 'structure',
+        surfaces: ['blockMenu'],
+        blockTypes: ['blockquote'],
+        nestedRowOnly: true,
+        isEnabled: (ctx) => isQuoteBlockRow(ctx),
+        run: (ctx) => {
+            if (!ctx.nestedRowBlockId)
+                return;
+            ctx.editor.deleteQuoteParagraphAt(ctx.blockIndex, ctx.nestedRowBlockId);
+        }
+    },
+    {
+        id: 'moveQuoteParagraphUp',
+        label: 'Move up',
+        group: 'structure',
+        surfaces: ['blockMenu'],
+        blockTypes: ['blockquote'],
+        nestedRowOnly: true,
+        isEnabled: (ctx) => isQuoteBlockRow(ctx) && ctx.canMoveUp,
+        run: (ctx) => {
+            if (!ctx.nestedRowBlockId)
+                return;
+            ctx.editor.moveQuoteParagraphSiblingAt(ctx.blockIndex, ctx.nestedRowBlockId, 'up');
+        },
+        shortcut: moveShortcut
+    },
+    {
+        id: 'moveQuoteParagraphDown',
+        label: 'Move down',
+        group: 'structure',
+        surfaces: ['blockMenu'],
+        blockTypes: ['blockquote'],
+        nestedRowOnly: true,
+        isEnabled: (ctx) => isQuoteBlockRow(ctx) && ctx.canMoveDown,
+        run: (ctx) => {
+            if (!ctx.nestedRowBlockId)
+                return;
+            ctx.editor.moveQuoteParagraphSiblingAt(ctx.blockIndex, ctx.nestedRowBlockId, 'down');
+        },
+        shortcut: moveDownShortcut
+    }
+];

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

@@ -0,0 +1,6 @@
+export { blockquoteCommands } from './commands';
+export { applyBlockquoteInlineSecondPass } from './inlineSecondPass';
+export { buildBlockquoteAtDepth, isNestedQuoteChild, parseBlockquoteLine, parseBlockquoteLineInfo, parseBlockquotes, quoteDepthFromBlock } from './parse';
+export { blockquoteReconcileFingerprint } from './reconcile';
+export { blockquotePrefix, indentLines, serializeBlockquoteBlock } from './serialize';
+export type { BlockquoteBlock, BlockquoteChild, BlockquoteLineInfo, BlockquoteQuote, BlockquoteText } from './types';

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

@@ -0,0 +1,5 @@
+export { blockquoteCommands } from './commands';
+export { applyBlockquoteInlineSecondPass } from './inlineSecondPass';
+export { buildBlockquoteAtDepth, isNestedQuoteChild, parseBlockquoteLine, parseBlockquoteLineInfo, parseBlockquotes, quoteDepthFromBlock } from './parse';
+export { blockquoteReconcileFingerprint } from './reconcile';
+export { blockquotePrefix, indentLines, serializeBlockquoteBlock } from './serialize';

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

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

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

@@ -0,0 +1,35 @@
+import { buildRichInlinesForRange } from '../../model/richInlines';
+function blockquoteBodyRange(row, startLine) {
+    const m = row.line.match(/^\s*((?:>\s*)+)(.*)$/);
+    if (!m)
+        return null;
+    let payload = m[2] ?? '';
+    if (payload.startsWith(' '))
+        payload = payload.slice(1);
+    const markerLen = row.line.length - payload.length;
+    const textStart = row.start + markerLen;
+    const text = payload.trimEnd();
+    const textEnd = textStart + text.length;
+    return {
+        start: textStart,
+        end: textEnd,
+        startLine,
+        endLine: startLine
+    };
+}
+export function applyBlockquoteInlineSecondPass(block, source, rows, ctx, annotateBlock) {
+    if (block.type !== 'blockquote')
+        return block;
+    const row = rows[block.sourceRange.startLine];
+    const inlines = row
+        ? (() => {
+            const tr = blockquoteBodyRange(row, block.sourceRange.startLine);
+            return tr ? buildRichInlinesForRange(source, tr.start, tr.end, ctx) : [];
+        })()
+        : [];
+    const out = { ...block, inlines };
+    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/blockquote/parse.d.ts

@@ -0,0 +1,16 @@
+import { type LineRow } from '../../model/line-utils';
+import type { EditorBlock } from '../../model/types';
+import type { BlockquoteBlock, BlockquoteLineInfo } from './types';
+export declare function parseBlockquoteLine(line: string): {
+    depth: number;
+    text: string;
+} | null;
+export declare function parseBlockquoteLineInfo(row: LineRow, lineIndex: number, source: string): BlockquoteLineInfo | null;
+/** `>` marker depth for a content-bearing blockquote from its source opener line. */
+export declare function quoteDepthFromBlock(block: EditorBlock, source?: string): number;
+/** True when `child` is a deeper nested quote (`>>`), not a same-depth continuation. */
+export declare function isNestedQuoteChild(parent: EditorBlock, child: EditorBlock, source?: string): boolean;
+/** Build content-bearing `blockquote` subtree from one nesting level. */
+export declare function buildBlockquoteAtDepth(lines: BlockquoteLineInfo[], depth: number, source: string): EditorBlock;
+/** Legacy region parser retained for tooling; canonical upload parse uses `buildBlockquoteAtDepth`. */
+export declare function parseBlockquotes(source: string): BlockquoteBlock[];