phormat 0.0.5

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

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

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

@@ -0,0 +1,16 @@
+<script lang="ts">
+	import type { BlockEditProps } from '../types';
+	import type { ColumnsBlock } from './types';
+	import { columnsRenderer } from './ColumnsRenderer.svelte';
+
+	let { block }: BlockEditProps = $props();
+</script>
+
+<div class="rounded-md border border-border-muted/80 bg-surface-base/20 p-2">
+	<p class="mb-1 text-xs text-txt-tertiary">Columns</p>
+	<p class="mb-2 text-xs text-txt-tertiary">
+		Parsed for preview; Markdown is kept verbatim on export. Structured column editing is not
+		implemented yet—duplicate the block and edit the raw segment if needed.
+	</p>
+	{@render columnsRenderer(block.data as ColumnsBlock)}
+</div>

package/dist/editor/block-specs/columns/EditableColumns.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { BlockEditProps } from '../types';
+declare const EditableColumns: import("svelte").Component<BlockEditProps, {}, "">;
+type EditableColumns = ReturnType<typeof EditableColumns>;
+export default EditableColumns;

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

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

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

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

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

@@ -0,0 +1,6 @@
+export { columnsCommands } from './commands';
+export { applyColumnsInlineSecondPass } from './inlineSecondPass';
+export { COLUMN_LINE_SCANNER, parseColumns, tryParseColumnsAt } from './parse';
+export { columnsReconcileFingerprint } from './reconcile';
+export { serializeColumnsBlock } from './serialize';
+export type { ColumnsBlock } from './types';

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

@@ -0,0 +1,5 @@
+export { columnsCommands } from './commands';
+export { applyColumnsInlineSecondPass } from './inlineSecondPass';
+export { COLUMN_LINE_SCANNER, parseColumns, tryParseColumnsAt } from './parse';
+export { columnsReconcileFingerprint } from './reconcile';
+export { serializeColumnsBlock } from './serialize';

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

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

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

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

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

@@ -0,0 +1,20 @@
+import { type LineRow } from '../../model/line-utils';
+import type { EditorBlock } from '../../model/types';
+import type { ColumnsBlock } from './types';
+/** Column segments per md-spec (`|||`). */
+export declare const COLUMN_LINE_SCANNER: RegExp;
+/**
+ * Column sections per docs/md-spec.md: lines starting with `|||`.
+ * A line that is only `|||` (optional whitespace after) closes the block.
+ * Without a closing line, the last column runs to EOF.
+ */
+export declare function parseColumns(source: string): ColumnsBlock[];
+type FencedScanResult = {
+    openLine: number;
+    closeLine: number;
+};
+export declare function tryParseColumnsAt(i: number, rows: LineRow[], source: string, fenceAtOpenLine: Map<number, FencedScanResult>): {
+    nextLine: number;
+    block: EditorBlock;
+} | null;
+export {};

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

@@ -0,0 +1,111 @@
+import { afterLineTerminator } from '../../model/line-utils';
+import { stableBlockId } from '../../model/types';
+/** Line starts a column segment: `|||` plus optional rest (same-line content). */
+const COLUMN_LINE = /^\|\|\|(.*)$/;
+/** Column segments per md-spec (`|||`). */
+export const COLUMN_LINE_SCANNER = /^\s*\|\|\|\s*(.*)$/;
+function trimColumn(text) {
+    return text.trimEnd();
+}
+/**
+ * Column sections per docs/md-spec.md: lines starting with `|||`.
+ * A line that is only `|||` (optional whitespace after) closes the block.
+ * Without a closing line, the last column runs to EOF.
+ */
+export function parseColumns(source) {
+    const lines = source.split(/\r?\n/);
+    const out = [];
+    let i = 0;
+    while (i < lines.length) {
+        const startMatch = lines[i].match(COLUMN_LINE);
+        if (!startMatch) {
+            i++;
+            continue;
+        }
+        const startLineIndex = i;
+        let current = (startMatch[1] ?? '').replace(/^\s+/, '');
+        i++;
+        const columns = [];
+        let closedWithBare = false;
+        while (i < lines.length) {
+            const line = lines[i];
+            const delim = line.match(COLUMN_LINE);
+            if (delim) {
+                const rest = delim[1] ?? '';
+                if (/^\s*$/.test(rest)) {
+                    columns.push(trimColumn(current));
+                    closedWithBare = true;
+                    i++;
+                    break;
+                }
+                columns.push(trimColumn(current));
+                current = rest.replace(/^\s+/, '');
+                i++;
+                continue;
+            }
+            current = current.length ? `${current}\n${line}` : line;
+            i++;
+        }
+        if (!closedWithBare) {
+            columns.push(trimColumn(current));
+        }
+        out.push({ columns, startLineIndex });
+    }
+    return out;
+}
+export function tryParseColumnsAt(i, rows, source, fenceAtOpenLine) {
+    const row = rows[i];
+    if (!row || fenceAtOpenLine.has(i))
+        return null;
+    const startMatch = row.line.match(COLUMN_LINE_SCANNER);
+    if (!startMatch)
+        return null;
+    let current = (startMatch[1] ?? '').replace(/^\s+/, '');
+    let j = i + 1;
+    const columns = [];
+    let closedWithBare = false;
+    while (j < rows.length) {
+        if (fenceAtOpenLine.has(j))
+            break;
+        const line = rows[j].line;
+        const delim = line.match(COLUMN_LINE_SCANNER);
+        if (delim) {
+            const rest = delim[1] ?? '';
+            if (/^\s*$/.test(rest)) {
+                columns.push(trimColumn(current));
+                closedWithBare = true;
+                j++;
+                break;
+            }
+            columns.push(trimColumn(current));
+            current = rest.replace(/^\s+/, '');
+            j++;
+            continue;
+        }
+        current = current.length ? `${current}\n${line}` : line;
+        j++;
+    }
+    if (!closedWithBare) {
+        columns.push(trimColumn(current));
+    }
+    const endLine = j - 1;
+    const sourceRange = {
+        start: row.start,
+        end: afterLineTerminator(source, rows[endLine]),
+        startLine: i,
+        endLine
+    };
+    const data = {
+        columns,
+        startLineIndex: i
+    };
+    return {
+        nextLine: j,
+        block: {
+            type: 'columns',
+            id: stableBlockId('columns', sourceRange),
+            sourceRange,
+            data
+        }
+    };
+}

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

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

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

@@ -0,0 +1,6 @@
+export function columnsReconcileFingerprint(block) {
+    if (block.type !== 'columns')
+        return '';
+    const d = block.data;
+    return `columns:${d.columns.length}:${d.columns[0]?.slice(0, 24) ?? ''}`;
+}

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

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

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

@@ -0,0 +1,16 @@
+export function serializeColumnsBlock(block) {
+    if (block.type !== 'columns') {
+        throw new Error('serializeColumnsBlock expects a columns block');
+    }
+    const d = block.data;
+    const out = [];
+    for (const col of d.columns) {
+        const ls = col.split('\n');
+        out.push(`||| ${ls[0] ?? ''}`.trimEnd());
+        for (let i = 1; i < ls.length; i++) {
+            out.push(ls[i]);
+        }
+    }
+    out.push('|||');
+    return out.join('\n');
+}

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

@@ -0,0 +1,4 @@
+export type ColumnsBlock = {
+    columns: string[];
+    startLineIndex: number;
+};

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

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

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

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

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

@@ -0,0 +1,24 @@
+import EditableColumns from './columns/EditableColumns.svelte';
+import { columnsCommands } from './columns/commands';
+import { applyColumnsInlineSecondPass } from './columns/inlineSecondPass';
+import { parseColumns, tryParseColumnsAt } from './columns/parse';
+import { columnsReconcileFingerprint } from './columns/reconcile';
+import { serializeColumnsBlock } from './columns/serialize';
+import { columnsRenderer } from './columns/ColumnsRenderer.svelte';
+export const columnsSpec = {
+    type: 'columns',
+    id: 'columns',
+    render: columnsRenderer,
+    editComponent: EditableColumns,
+    parse: { parseColumns, tryParseColumnsAt },
+    serialize: serializeColumnsBlock,
+    applyInlineSecondPass: applyColumnsInlineSecondPass,
+    reconcileFingerprint: columnsReconcileFingerprint,
+    commands: columnsCommands,
+    toRenderBlock: (block) => ({
+        id: block.id,
+        pluginId: 'columns',
+        data: block.data,
+        render: columnsRenderer
+    })
+};

package/dist/editor/block-specs/heading/HeaderRenderer.svelte

@@ -0,0 +1,30 @@
+<script module lang="ts">
+	import type { EditorBlock } from '../../model/types';
+	import { inlineNodesSnippet } from '../../plugins/shared/InlineNodes.svelte';
+	import type { HeaderBlock } from './types';
+
+	const levelClass: Record<HeaderBlock['level'], string> = {
+		1: 'mb-4 text-2xl font-semibold tracking-tight text-txt-primary',
+		2: 'mb-3 text-xl font-semibold tracking-tight text-txt-primary',
+		3: 'mb-3 text-lg font-semibold text-txt-primary',
+		4: 'mb-2 text-base font-semibold text-txt-primary',
+		5: 'mb-2 text-sm font-semibold text-txt-secondary',
+		6: 'mb-2 text-xs font-semibold text-txt-tertiary'
+	};
+
+	export { headerRenderer };
+</script>
+
+{#snippet headerRenderer(block: EditorBlock)}
+	{@const hb = block.data as HeaderBlock}
+	<svelte:element
+		this={`h${hb.level}` as 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6'}
+		class={levelClass[hb.level]}
+	>
+		{#if block.inlines && block.inlines.length > 0}
+			{@render inlineNodesSnippet(block.inlines)}
+		{:else}
+			{hb.text}
+		{/if}
+	</svelte:element>
+{/snippet}

package/dist/editor/block-specs/heading/HeaderRenderer.svelte.d.ts

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

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

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

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

@@ -0,0 +1,41 @@
+function headingLevels() {
+    return [1, 2, 3];
+}
+export const headingCommands = [
+    {
+        id: 'convertHeadingToParagraph',
+        label: 'Paragraph',
+        group: 'turnInto',
+        surfaces: ['slash', 'blockMenu'],
+        blockTypes: ['heading'],
+        slashKinds: ['heading'],
+        isEnabled: () => true,
+        run: (ctx) => {
+            ctx.editor.convertHeadingToParagraphAt(ctx.blockIndex);
+        }
+    },
+    ...headingLevels().map((level) => ({
+        id: `convertHeadingLevel${level}`,
+        label: `Heading ${level}`,
+        group: 'turnInto',
+        surfaces: ['slash', 'blockMenu'],
+        blockTypes: ['heading'],
+        slashKinds: ['heading'],
+        isEnabled: () => true,
+        run: (ctx) => {
+            ctx.editor.convertHeadingLevelAt(ctx.blockIndex, level);
+        }
+    })),
+    {
+        id: 'turnIntoTableFromHeading',
+        label: 'Table',
+        group: 'turnInto',
+        surfaces: ['slash', 'blockMenu'],
+        blockTypes: ['heading'],
+        slashKinds: ['heading'],
+        isEnabled: () => true,
+        run: (ctx) => {
+            ctx.editor.convertBlockToTableAt(ctx.blockIndex);
+        }
+    }
+];

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

@@ -0,0 +1,10 @@
+import type { EditorBlock } from '../../model/types';
+/** Plain heading body for editing (prefers inline AST). */
+export declare function headingDisplayPlain(block: EditorBlock): string;
+export declare function headingMarkdown(level: number, text: string): string;
+/** Absolute source offsets of the heading body (after `#… ` prefix). */
+export declare function headingBodySourceRange(block: EditorBlock, source: string): {
+    start: number;
+    end: number;
+};
+export declare function headingPlainOffsetToSourceOffset(block: EditorBlock, source: string, plainOffset: number): number;

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

@@ -0,0 +1,33 @@
+import { inlineNodesToPlainText } from '../../model/inlinePlain';
+/** Plain heading body for editing (prefers inline AST). */
+export function headingDisplayPlain(block) {
+    if (block.type !== 'heading')
+        return '';
+    if (block.inlines?.length)
+        return inlineNodesToPlainText(block.inlines);
+    return block.data.text;
+}
+export function headingMarkdown(level, text) {
+    return `${'#'.repeat(level)} ${text}`;
+}
+/** Absolute source offsets of the heading body (after `#… ` prefix). */
+export function headingBodySourceRange(block, source) {
+    const slice = source.slice(block.sourceRange.start, block.sourceRange.end);
+    const m = slice.match(/^(\s*)(#{1,6})([ \t]+)([\s\S]*)$/);
+    const hb = block.data;
+    if (!m) {
+        const fallbackLen = hb.text.length;
+        return {
+            start: block.sourceRange.end - fallbackLen,
+            end: block.sourceRange.end
+        };
+    }
+    const openLen = m[1].length + m[2].length + m[3].length;
+    const absStart = block.sourceRange.start + openLen;
+    const absEnd = absStart + hb.text.length;
+    return { start: absStart, end: absEnd };
+}
+export function headingPlainOffsetToSourceOffset(block, source, plainOffset) {
+    const { start } = headingBodySourceRange(block, source);
+    return start + plainOffset;
+}

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

@@ -0,0 +1,7 @@
+export { headingCommands } from './commands';
+export { headingBodySourceRange, headingDisplayPlain, headingMarkdown, headingPlainOffsetToSourceOffset } from './edit';
+export { applyHeadingInlineSecondPass } from './inlineSecondPass';
+export { ATX_HEADING, parseHeadings, stripClosingHashes } from './parse';
+export { headingReconcileFingerprint } from './reconcile';
+export { serializeHeadingBlock } from './serialize';
+export type { HeaderBlock } from './types';

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

@@ -0,0 +1,6 @@
+export { headingCommands } from './commands';
+export { headingBodySourceRange, headingDisplayPlain, headingMarkdown, headingPlainOffsetToSourceOffset } from './edit';
+export { applyHeadingInlineSecondPass } from './inlineSecondPass';
+export { ATX_HEADING, parseHeadings, stripClosingHashes } from './parse';
+export { headingReconcileFingerprint } from './reconcile';
+export { serializeHeadingBlock } from './serialize';

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

@@ -0,0 +1,4 @@
+import type { EditorBlock } from '../../model/types';
+import { type RichInlineContext } from '../../model/richInlines';
+import type { LineRow } from '../../model/line-utils';
+export declare function applyHeadingInlineSecondPass(block: EditorBlock, source: string, rows: LineRow[], ctx: RichInlineContext): EditorBlock;

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

@@ -0,0 +1,20 @@
+import { buildRichInlinesForRange } from '../../model/richInlines';
+import { ATX_HEADING } from './parse';
+export function applyHeadingInlineSecondPass(block, source, rows, ctx) {
+    if (block.type !== 'heading')
+        return block;
+    const hb = block.data;
+    const row = rows[hb.lineIndex];
+    if (!row)
+        return { ...block };
+    const m = row.line.match(ATX_HEADING);
+    if (!m)
+        return { ...block };
+    const open = m[1].length + m[2].length + m[3].length;
+    const absStart = row.start + open;
+    const absEnd = absStart + hb.text.length;
+    return {
+        ...block,
+        inlines: buildRichInlinesForRange(source, absStart, absEnd, ctx)
+    };
+}

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

@@ -0,0 +1,5 @@
+import type { HeaderBlock } from './types';
+/** ATX heading: optional leading whitespace, 1–6 `#`, space/tab, rest of line. */
+export declare const ATX_HEADING: RegExp;
+export declare function stripClosingHashes(content: string): string;
+export declare function parseHeadings(source: string): HeaderBlock[];

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

@@ -0,0 +1,18 @@
+/** ATX heading: optional leading whitespace, 1–6 `#`, space/tab, rest of line. */
+export const ATX_HEADING = /^(\s*)(#{1,6})([ \t]+)(.*)$/;
+export function stripClosingHashes(content) {
+    return content.replace(/\s+(?:#)+\s*$/, '').trimEnd();
+}
+export function parseHeadings(source) {
+    const lines = source.split(/\r?\n/);
+    const out = [];
+    for (let i = 0; i < lines.length; i++) {
+        const match = lines[i].match(ATX_HEADING);
+        if (!match)
+            continue;
+        const level = match[2].length;
+        const text = stripClosingHashes(match[4]).trim();
+        out.push({ level, text, lineIndex: i });
+    }
+    return out;
+}

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

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

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

@@ -0,0 +1,8 @@
+import { inlineNodesToPlainText } from '../../model/inlinePlain';
+export function headingReconcileFingerprint(block) {
+    if (block.type !== 'heading')
+        return '';
+    if (block.inlines?.length)
+        return inlineNodesToPlainText(block.inlines);
+    return block.data.text;
+}

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

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

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

@@ -0,0 +1,9 @@
+import { serializeInlineNodes } from '../../model/serializeInlineNodes';
+export function serializeHeadingBlock(block) {
+    if (block.type !== 'heading') {
+        throw new Error('serializeHeadingBlock expects a heading block');
+    }
+    const d = block.data;
+    const body = block.inlines && block.inlines.length > 0 ? serializeInlineNodes(block.inlines) : d.text;
+    return `${'#'.repeat(d.level)} ${body}`;
+}

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

@@ -0,0 +1,5 @@
+export type HeaderBlock = {
+    level: 1 | 2 | 3 | 4 | 5 | 6;
+    text: string;
+    lineIndex: number;
+};

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

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

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

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

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

@@ -0,0 +1,28 @@
+import EditableHeading from '../blocks/EditableHeading.svelte';
+import { splitLinesWithOffsets } from '../model/line-utils';
+import { headingCommands } from './heading/commands';
+import { applyHeadingInlineSecondPass } from './heading/inlineSecondPass';
+import { ATX_HEADING, parseHeadings, stripClosingHashes } from './heading/parse';
+import { headingReconcileFingerprint } from './heading/reconcile';
+import { serializeHeadingBlock } from './heading/serialize';
+import { headerRenderer } from './heading/HeaderRenderer.svelte';
+export const headingSpec = {
+    type: 'heading',
+    id: 'header',
+    render: headerRenderer,
+    editComponent: EditableHeading,
+    parse: { ATX_HEADING, parseHeadings, stripClosingHashes },
+    serialize: serializeHeadingBlock,
+    applyInlineSecondPass: (block, source, _insideBlockquote, ctx) => {
+        void _insideBlockquote;
+        return applyHeadingInlineSecondPass(block, source, splitLinesWithOffsets(source), ctx);
+    },
+    reconcileFingerprint: headingReconcileFingerprint,
+    commands: headingCommands,
+    toRenderBlock: (block) => ({
+        id: block.id,
+        pluginId: 'header',
+        data: block,
+        render: headerRenderer
+    })
+};

package/dist/editor/block-specs/horizontalRule/HorizontalRuleRenderer.svelte

@@ -0,0 +1,15 @@
+<script module lang="ts">
+	export { horizontalRuleRenderer };
+</script>
+
+<script lang="ts">
+	import type { HorizontalRuleBlock } from './types';
+</script>
+
+{#snippet horizontalRuleRenderer(block: HorizontalRuleBlock)}
+	<hr
+		class="my-4 border-0 border-t border-border-emphasis"
+		aria-hidden="true"
+		data-source-line={block.lineIndex}
+	/>
+{/snippet}

package/dist/editor/block-specs/horizontalRule/HorizontalRuleRenderer.svelte.d.ts

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

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

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

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

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

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

@@ -0,0 +1,6 @@
+export { horizontalRuleCommands } from './commands';
+export { applyHorizontalRuleInlineSecondPass } from './inlineSecondPass';
+export { isHorizontalRuleLine, parseHorizontalRules } from './parse';
+export { horizontalRuleReconcileFingerprint } from './reconcile';
+export { serializeHorizontalRuleBlock } from './serialize';
+export type { HorizontalRuleBlock } from './types';

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

@@ -0,0 +1,5 @@
+export { horizontalRuleCommands } from './commands';
+export { applyHorizontalRuleInlineSecondPass } from './inlineSecondPass';
+export { isHorizontalRuleLine, parseHorizontalRules } from './parse';
+export { horizontalRuleReconcileFingerprint } from './reconcile';
+export { serializeHorizontalRuleBlock } from './serialize';

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

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