phormat 0.0.5

package/dist/editor/model/serializeMarkdownDocument.js

@@ -0,0 +1,150 @@
+import { serializeBlockquoteBlock } from '../block-specs/blockquote';
+import { serializeCalloutBlock } from '../block-specs/callout';
+import { serializeCodeFenceBlock } from '../block-specs/codeFence';
+import { serializeColumnsBlock } from '../block-specs/columns';
+import { serializeHeadingBlock } from '../block-specs/heading';
+import { serializeHorizontalRuleBlock } from '../block-specs/horizontalRule';
+import { serializeListItem, serializeListRegion } from '../block-specs/list';
+import { serializeParagraphBlock } from '../block-specs/paragraph';
+import { serializeTableBlock } from '../block-specs/table';
+import { serializeTocBlock } from '../block-specs/toc';
+import { serializeToggleBlock } from '../block-specs/toggle';
+/**
+ * Canonical Markdown emitted when a block is dirty or unknown (no faithful slice).
+ *
+ * - **Paragraph**: soft breaks as `  \\n`, hard breaks as `\\n`; see {@link serializeParagraphData}.
+ * - **Headings**: `#` × level + space + body; inline nodes preferred over plain `data.text`.
+ * - **Lists**: unordered `-`; ordered `n.`; tasks `- [x]` / `n. [x]` with marker chars from list-item
+ *   data when set; nested child blocks indented with four spaces per level.
+ * - **Blockquote**: every line prefixed with `> `, or bare `>` for blank inner lines.
+ * - **Tables**: `| a | b |` rows; delimiter cells `:---`, `:---:`, `---:`, or `---` per column alignment.
+ * - **Callouts**: `> [!type] title` then `> body` / `>` for blank body lines.
+ * - **Toggles**: `+++ title`, body, closing `+++`.
+ * - **Columns**: `||| column head`, column lines, closing `|||`.
+ * - **Horizontal rule**: `---`; **TOC**: `::toc`.
+ */
+export { serializeParagraphData } from '../block-specs/paragraph';
+/** Serialize a single block to Markdown (no surrounding blank lines). Unknown types fall back to the original source slice when provided. */
+export function serializeEditorBlock(block, source) {
+    switch (block.type) {
+        case 'codeFence':
+            return serializeCodeFenceBlock(block);
+        case 'heading':
+            return serializeHeadingBlock(block);
+        case 'horizontalRule':
+            return serializeHorizontalRuleBlock(block);
+        case 'blockquote':
+            return serializeBlockquoteBlock(block, (child) => serializeEditorBlock(child, source), source);
+        case 'listItem':
+            return serializeListItem(block, source);
+        case 'paragraph':
+            return serializeParagraphBlock(block);
+        case 'table':
+            return serializeTableBlock(block);
+        case 'callout':
+            return serializeCalloutBlock(block);
+        case 'toggle':
+            return serializeToggleBlock(block);
+        case 'columns':
+            return serializeColumnsBlock(block);
+        case 'toc':
+            return serializeTocBlock(block);
+        default:
+            if (source !== undefined && block.sourceRange.start >= 0 && !block.sourceRange.synthetic) {
+                return source.slice(block.sourceRange.start, block.sourceRange.end);
+            }
+            return '';
+    }
+}
+/** Serialize a contiguous slice of top-level blocks (list runs, paragraphs, etc.). */
+export function serializeTopLevelBlockSpan(blocks, start, end, source) {
+    const parts = [];
+    let i = start;
+    while (i < end) {
+        const block = blocks[i];
+        if (block.type === 'listItem') {
+            let j = i;
+            while (j < end && blocks[j].type === 'listItem')
+                j++;
+            parts.push(serializeListRegion(blocks.slice(i, j), source));
+            i = j;
+        }
+        else {
+            parts.push(serializeEditorBlock(block, source));
+            i++;
+        }
+    }
+    return parts.join('\n\n');
+}
+export function serializeMarkdownDocument(doc) {
+    if (doc.blocks.length === 0)
+        return '';
+    const parts = [];
+    let i = 0;
+    while (i < doc.blocks.length) {
+        const block = doc.blocks[i];
+        if (block.type === 'listItem') {
+            const end = i;
+            let j = i;
+            while (j < doc.blocks.length && doc.blocks[j].type === 'listItem')
+                j++;
+            parts.push(serializeListRegion(doc.blocks.slice(i, j), doc.source));
+            i = j;
+            continue;
+        }
+        parts.push(serializeEditorBlock(block, doc.source));
+        i++;
+    }
+    return parts.join('\n\n');
+}
+/** When joining blocks without concrete source offsets (e.g. synthetic rows). */
+const DEFAULT_GAP_NON_PRISTINE = '\n\n';
+function emitTopLevelFromSourceSlice(block, dirtyTopLevelIds) {
+    return (!dirtyTopLevelIds.has(block.id) && block.sourceRange.start >= 0 && !block.sourceRange.synthetic);
+}
+function topLevelSourceAnchored(block) {
+    return !block.sourceRange.synthetic && block.sourceRange.start >= 0;
+}
+/** Gap bytes between adjacent top-level blocks in {@link EditorDocument.source}. */
+function gapBetweenTopLevelBlocks(source, left, right, leftSerializedBody) {
+    if (topLevelSourceAnchored(left) &&
+        topLevelSourceAnchored(right) &&
+        left.sourceRange.end <= right.sourceRange.start) {
+        return source.slice(left.sourceRange.end, right.sourceRange.start);
+    }
+    return leftSerializedBody.endsWith('\n') ? '\n' : DEFAULT_GAP_NON_PRISTINE;
+}
+/**
+ * Serialize the document while preserving author bytes for unchanged top-level blocks.
+ * Unchanged blocks emit original source slices; prefix, suffix, and inter-block gaps copy
+ * `doc.source` whenever adjacent blocks have concrete UTF-16 ranges (including when only one
+ * side is pristine). Synthetic blocks or missing ranges fall back to {@link DEFAULT_GAP_NON_PRISTINE}.
+ *
+ * **Formatting policy** for dirty / non-slice blocks: see file-level doc comment above.
+ */
+export function serializeMarkdownDocumentPreserving(doc, dirtyTopLevelIds) {
+    const { source, blocks } = doc;
+    if (blocks.length === 0)
+        return source;
+    const bodies = blocks.map((b) => emitTopLevelFromSourceSlice(b, dirtyTopLevelIds)
+        ? source.slice(b.sourceRange.start, b.sourceRange.end)
+        : serializeEditorBlock(b, source));
+    let out = '';
+    const first = blocks[0];
+    if (topLevelSourceAnchored(first)) {
+        out += source.slice(0, first.sourceRange.start);
+    }
+    for (let i = 0; i < blocks.length; i++) {
+        out += bodies[i];
+        if (i < blocks.length - 1) {
+            const left = blocks[i];
+            const right = blocks[i + 1];
+            out += gapBetweenTopLevelBlocks(source, left, right, bodies[i]);
+        }
+    }
+    const last = blocks[blocks.length - 1];
+    if (topLevelSourceAnchored(last)) {
+        out += source.slice(last.sourceRange.end, source.length);
+    }
+    return out;
+}

package/dist/editor/model/structureParseWarnings.d.ts

@@ -0,0 +1,10 @@
+import type { LineRow } from './line-utils';
+/** Any map keyed by fence open line (value unused). */
+type FenceLineMap = Map<number, unknown>;
+/** Toggle opened with `+++ title` but no closing `+++`, or body interrupted by a fence. */
+export declare function collectToggleStructureWarnings(rows: LineRow[], fenceAtOpenLine: FenceLineMap): string[];
+/**
+ * When a line has GFM-table-like pipes but {@link tryParseTableAt} would fail, explain why.
+ */
+export declare function explainTableParseFailure(i: number, rows: LineRow[], _fenceAtOpenLine: FenceLineMap): string | null;
+export {};

package/dist/editor/model/structureParseWarnings.js

@@ -0,0 +1,60 @@
+import { parseDelimiterCell, splitTableRow } from '../block-specs/table/parse';
+const TOGGLE_OPEN = /^\s*\+\+\+\s+(.+)$/;
+const TOGGLE_CLOSE = /^\s*\+\+\+\s*$/;
+/** Toggle opened with `+++ title` but no closing `+++`, or body interrupted by a fence. */
+export function collectToggleStructureWarnings(rows, fenceAtOpenLine) {
+    const warns = [];
+    for (let i = 0; i < rows.length; i++) {
+        if (fenceAtOpenLine.has(i))
+            continue;
+        if (!TOGGLE_OPEN.test(rows[i].line))
+            continue;
+        let j = i + 1;
+        let closed = false;
+        while (j < rows.length) {
+            if (TOGGLE_CLOSE.test(rows[j].line)) {
+                closed = true;
+                break;
+            }
+            if (fenceAtOpenLine.has(j)) {
+                warns.push(`Line ${i + 1}: toggle body interrupted by a fenced code block before a closing +++ line.`);
+                break;
+            }
+            j++;
+        }
+        if (!closed && j >= rows.length) {
+            warns.push(`Line ${i + 1}: toggle opened with +++ but no closing +++ line before end of file.`);
+        }
+    }
+    return warns;
+}
+function pipeRowLooksLikeTableHeader(i, rows, fenceAtOpenLine) {
+    if (fenceAtOpenLine.has(i))
+        return false;
+    const line = rows[i]?.line ?? '';
+    if (!line.includes('|'))
+        return false;
+    return splitTableRow(line).length > 0;
+}
+/**
+ * When a line has GFM-table-like pipes but {@link tryParseTableAt} would fail, explain why.
+ */
+export function explainTableParseFailure(i, rows, _fenceAtOpenLine) {
+    if (!pipeRowLooksLikeTableHeader(i, rows, _fenceAtOpenLine))
+        return null;
+    const headerCells = splitTableRow(rows[i].line);
+    if (i + 1 >= rows.length) {
+        return `Line ${i + 1}: pipe row looks like a table header, but there is no following delimiter row.`;
+    }
+    const delimCells = splitTableRow(rows[i + 1].line);
+    if (delimCells.length !== headerCells.length) {
+        return `Line ${i + 1}: table header has ${headerCells.length} column(s) but line ${i + 2} has ${delimCells.length} cell(s); not parsed as a GFM table.`;
+    }
+    for (let k = 0; k < delimCells.length; k++) {
+        if (parseDelimiterCell(delimCells[k]) === undefined) {
+            const raw = delimCells[k]?.trim() ?? '';
+            return `Line ${i + 2}: column ${k + 1} delimiter "${raw}" is not valid GFM table syntax; table not recognized.`;
+        }
+    }
+    return `Line ${i + 1}: could not parse as a GFM table.`;
+}

package/dist/editor/model/syntheticInlineRanges.d.ts

@@ -0,0 +1,3 @@
+import type { InlineNode } from './types';
+/** Blockquote bodies use a detached substring context; ranges are not absolute document offsets. */
+export declare function withSyntheticRanges(nodes: InlineNode[]): InlineNode[];

package/dist/editor/model/syntheticInlineRanges.js

@@ -0,0 +1,36 @@
+function syntheticInlineRange() {
+    return { start: -1, end: -1, startLine: -1, endLine: -1, synthetic: true };
+}
+/** Blockquote bodies use a detached substring context; ranges are not absolute document offsets. */
+export function withSyntheticRanges(nodes) {
+    function walk(n) {
+        const sr = syntheticInlineRange();
+        switch (n.type) {
+            case 'text':
+            case 'code':
+            case 'autolink':
+            case 'wikiLink':
+            case 'mention':
+                return { ...n, sourceRange: sr };
+            case 'link':
+            case 'image':
+                return {
+                    ...n,
+                    sourceRange: sr,
+                    children: n.children.map(walk)
+                };
+            case 'emphasis':
+            case 'strong':
+            case 'strikethrough':
+            case 'highlight':
+                return {
+                    ...n,
+                    sourceRange: sr,
+                    children: n.children.map(walk)
+                };
+            default:
+                return n;
+        }
+    }
+    return nodes.map(walk);
+}

package/dist/editor/model/types.d.ts

@@ -0,0 +1,185 @@
+import type { TableCellAlign } from '../block-specs/table/types';
+/**
+ * Character offsets into `EditorDocument.source` (0-based, end exclusive).
+ */
+export type SourceRange = {
+    start: number;
+    end: number;
+    startLine: number;
+    endLine: number;
+    /**
+     * Generated blocks (TOC, etc.) do not map to one contiguous author slice.
+     * Convention: `start === end === -1` with line metadata (see ADR).
+     */
+    synthetic?: boolean;
+};
+export type InlineTextNode = {
+    type: 'text';
+    text: string;
+    sourceRange: SourceRange;
+};
+export type InlineEmphasisNode = {
+    type: 'emphasis';
+    children: InlineNode[];
+    sourceRange: SourceRange;
+};
+export type InlineStrongNode = {
+    type: 'strong';
+    children: InlineNode[];
+    sourceRange: SourceRange;
+};
+export type InlineCodeNode = {
+    type: 'code';
+    text: string;
+    sourceRange: SourceRange;
+};
+/** Checkbox semantics on unordered task list items (`- [ ]`, `- [x]`, `- [/]`, `- [>]`, …). */
+export type TaskCheckboxState = 'todo' | 'done' | 'in_progress' | 'deferred' | 'other';
+export type InlineLinkNode = {
+    type: 'link';
+    children: InlineNode[];
+    href: string | null;
+    title: string | null;
+    sourceRange: SourceRange;
+};
+export type ImageFloatAlign = 'left' | 'center' | 'right';
+export type InlineImageNode = {
+    type: 'image';
+    children: InlineNode[];
+    href: string | null;
+    title: string | null;
+    /** Pixel width, `'full'` for `|-1`, or `null` for unsuffixed default thumbnail. */
+    displayWidth?: number | 'full' | null;
+    /** Block-on-own-line alignment when width is less than container; `null` for width-only inline default. */
+    floatAlign?: ImageFloatAlign | null;
+    sourceRange: SourceRange;
+};
+export type InlineStrikethroughNode = {
+    type: 'strikethrough';
+    children: InlineNode[];
+    sourceRange: SourceRange;
+};
+export type InlineHighlightNode = {
+    type: 'highlight';
+    /** When using `==color:text==`; otherwise null for plain `==text==`. */
+    color: string | null;
+    children: InlineNode[];
+    sourceRange: SourceRange;
+};
+export type InlineAutolinkNode = {
+    type: 'autolink';
+    href: string;
+    sourceRange: SourceRange;
+};
+export type InlineWikiLinkNode = {
+    type: 'wikiLink';
+    target: string;
+    label: string;
+    sourceRange: SourceRange;
+};
+export type InlineMentionNode = {
+    type: 'mention';
+    kind: 'user' | 'page';
+    name: string;
+    sourceRange: SourceRange;
+};
+export type InlineNode = InlineTextNode | InlineEmphasisNode | InlineStrongNode | InlineCodeNode | InlineLinkNode | InlineImageNode | InlineStrikethroughNode | InlineHighlightNode | InlineAutolinkNode | InlineWikiLinkNode | InlineMentionNode;
+export type EditorBlockType = 'heading' | 'paragraph' | 'codeFence' | 'listItem' | 'blockquote' | 'horizontalRule' | 'table' | 'callout' | 'toggle' | 'columns' | 'toc';
+/** Populated by `applyInlineSecondPass` for table cells. */
+export type TableBlockData = {
+    headers: string[];
+    aligns: TableCellAlign[];
+    rows: string[][];
+    /** Source line of the header row (metadata for reconciliation / render). */
+    startLineIndex?: number;
+    headerInlines?: InlineNode[][];
+    rowInlines?: InlineNode[][][];
+};
+/** Canonical `data` for `listItem` blocks; nested items and loose content live under {@link EditorBlock.children}. */
+export type ListItemBlockData = {
+    ordered: boolean;
+    ordinalValue?: number;
+    /** Marker indent in tab-stop columns (matches `parseListLine` output). */
+    indentColumns: number;
+    /** Set for unordered task items (`- [ ] item`, …). */
+    task?: TaskCheckboxState;
+    /** Raw marker when `task === 'other'` (single character inside brackets). */
+    taskMarkerChar?: string;
+};
+/** Canonical `data` for `blockquote` blocks; first-line body uses {@link EditorBlock.inlines}. */
+export type BlockquoteBlockData = Record<string, never>;
+export type EditorBlock = {
+    id: string;
+    type: EditorBlockType;
+    sourceRange: SourceRange;
+    data: unknown;
+    inlines?: InlineNode[];
+    /** Canonical nested model: list items, blockquote contents, etc. */
+    children?: EditorBlock[];
+};
+export type EditorDocument = {
+    source: string;
+    fileName: string | null;
+    blocks: EditorBlock[];
+    /** Recoverable parse issues (does not block editing). */
+    parseWarnings?: string[];
+};
+/** Character slice in **Markdown source** (UTF-16 code units, end exclusive). */
+export type SourceSliceRange = {
+    start: number;
+    end: number;
+};
+/** Indices into nested {@link EditorBlock.children} from a top-level block downward. */
+export type BlockPath = readonly number[];
+/** Plain-text offsets within an editable surface (paragraph body, heading body, list item row). */
+export type PlainTextRange = {
+    start: number;
+    end: number;
+};
+/** Focused cell within a {@link TableBlockData} grid (`row === -1` → header). */
+export type TableCellAddress = {
+    row: number;
+    col: number;
+};
+/**
+ * Caret/selection addressed by the leaf editable block's stable id — survives reparse when ids reconcile.
+ * When `plain` is set, offsets are within that block's editable plain surface.
+ * For `table` blocks, {@link tableCell} identifies the active cell.
+ */
+export type DocumentSelection = {
+    blockId: string;
+    plain?: PlainTextRange;
+    tableCell?: TableCellAddress;
+};
+/** One source mutation step inside an {@link EditorTransaction}. */
+export type EditorOperation = {
+    type: 'replaceSlice';
+    range: SourceSliceRange;
+    text: string;
+};
+/** One user-visible edit: ordered source-slice ops plus post-apply caret. Undo/redo still snapshots source. */
+export type EditorTransaction = {
+    id: string;
+    operations: EditorOperation[];
+    /** Source-offset caret after apply; UI will adopt {@link DocumentSelection} incrementally. */
+    selection: EditorSelection;
+};
+/** Character offsets into `EditorDocument.source` (UTF-16 indices, matching DOM Selection). */
+export type EditorSelection = {
+    anchor: number;
+    focus: number;
+};
+/** One undo/redo snapshot: canonical source + caret after the edit that created this snapshot’s successor. */
+export type EditorHistorySnapshot = {
+    source: string;
+    selection: EditorSelection;
+    /** Leaf-block caret at push time; null when only source-offset caret was known. */
+    documentSelection: DocumentSelection | null;
+};
+export declare function stableBlockId(type: string, range: SourceRange): string;
+export declare function normalizeSelectionRange(sel: EditorSelection): {
+    start: number;
+    end: number;
+};
+export declare function clampSelection(sel: EditorSelection, sourceLength: number): EditorSelection;
+export declare function syntheticRange(startLine: number, endLine: number): SourceRange;

package/dist/editor/model/types.js

@@ -0,0 +1,26 @@
+export function stableBlockId(type, range) {
+    if (range.synthetic) {
+        return `${type}:syn:${range.startLine}:${range.endLine}`;
+    }
+    return `${type}:${range.start}:${range.end}`;
+}
+export function normalizeSelectionRange(sel) {
+    const a = sel.anchor;
+    const f = sel.focus;
+    return a <= f ? { start: a, end: f } : { start: f, end: a };
+}
+export function clampSelection(sel, sourceLength) {
+    const lo = 0;
+    const hi = Math.max(0, sourceLength);
+    const clamp = (n) => Math.min(Math.max(n, lo), hi);
+    return { anchor: clamp(sel.anchor), focus: clamp(sel.focus) };
+}
+export function syntheticRange(startLine, endLine) {
+    return {
+        start: -1,
+        end: -1,
+        startLine,
+        endLine,
+        synthetic: true
+    };
+}

package/dist/editor/plugins/autolinks/AutolinkRenderer.svelte

@@ -0,0 +1,20 @@
+<script module lang="ts">
+	import type { AutolinkBlock } from './types';
+
+	export { autolinkRenderer };
+</script>
+
+<!-- eslint-disable svelte/no-navigation-without-resolve -- MD autolinks are arbitrary URLs, not app routes -->
+
+{#snippet autolinkRenderer(block: AutolinkBlock)}
+	<p class="mb-4 text-sm text-txt-primary">
+		<a
+			href={block.url}
+			class="font-medium break-all text-accent-primary underline decoration-accent-primary/50 underline-offset-2 hover:text-accent-secondary"
+			target="_blank"
+			rel="noopener noreferrer"
+		>
+			{block.url}
+		</a>
+	</p>
+{/snippet}

package/dist/editor/plugins/autolinks/AutolinkRenderer.svelte.d.ts

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

package/dist/editor/plugins/autolinks/index.d.ts

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

package/dist/editor/plugins/autolinks/index.js

@@ -0,0 +1,4 @@
+export const autolinksPlugin = {
+    id: 'autolinks',
+    name: 'Autolinks (GFM)'
+};

package/dist/editor/plugins/autolinks/parse-autolinks.d.ts

@@ -0,0 +1,2 @@
+import type { AutolinkBlock } from './types';
+export declare function parseAutolinks(source: string): AutolinkBlock[];

package/dist/editor/plugins/autolinks/parse-autolinks.js

@@ -0,0 +1,68 @@
+/** Angle-bracket GFM autolinks: `<https://…>` (http/https, case-insensitive scheme). */
+const ANGLE_AUTOLINK = /<(https?:\/\/[^>\s]+)>/gi;
+/** Bare `http://` / `https://` token; trim trailing punctuation per GFM-style heuristics. */
+const BARE_AUTOLINK = /\bhttps?:\/\/[^\s<]+/gi;
+function spansOverlap(a, b) {
+    return !(a.end <= b.start || a.start >= b.end);
+}
+/** Strip trailing `.,;:!?` and unmatched closing parens from a bare URL match. */
+function trimBareAutolinkSuffix(raw) {
+    let u = raw;
+    while (u.length > 0) {
+        const last = u[u.length - 1];
+        if ('.,;:!?'.includes(last)) {
+            u = u.slice(0, -1);
+            continue;
+        }
+        if (last === ')') {
+            const opens = (u.match(/\(/g) ?? []).length;
+            const closes = (u.match(/\)/g) ?? []).length;
+            if (closes > opens) {
+                u = u.slice(0, -1);
+                continue;
+            }
+        }
+        break;
+    }
+    return u;
+}
+export function parseAutolinks(source) {
+    const lines = source.split(/\r?\n/);
+    const out = [];
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+        const line = lines[lineIndex];
+        const angleSpans = [];
+        let m;
+        ANGLE_AUTOLINK.lastIndex = 0;
+        while ((m = ANGLE_AUTOLINK.exec(line)) !== null) {
+            const start = m.index;
+            const end = start + m[0].length;
+            angleSpans.push({ start, end });
+            out.push({
+                kind: 'angle',
+                url: m[1],
+                lineIndex,
+                column: start
+            });
+        }
+        BARE_AUTOLINK.lastIndex = 0;
+        while ((m = BARE_AUTOLINK.exec(line)) !== null) {
+            const start = m.index;
+            const end = start + m[0].length;
+            const rawSpan = { start, end };
+            if (angleSpans.some((s) => spansOverlap(rawSpan, s)))
+                continue;
+            const trimmed = trimBareAutolinkSuffix(m[0]);
+            if (trimmed.length === 0)
+                continue;
+            out.push({
+                kind: 'bare',
+                url: trimmed,
+                lineIndex,
+                column: start
+            });
+        }
+    }
+    out.sort((a, b) => a.lineIndex - b.lineIndex || a.column - b.column);
+    return out;
+}

package/dist/editor/plugins/autolinks/types.d.ts

@@ -0,0 +1,6 @@
+export type AutolinkBlock = {
+    url: string;
+    lineIndex: number;
+    column: number;
+    kind: 'angle' | 'bare';
+};

package/dist/editor/plugins/autolinks/types.js

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

package/dist/editor/plugins/emphasis/EmphasisRenderer.svelte

@@ -0,0 +1,15 @@
+<script module lang="ts">
+	import type { EmphasisBlock } from './types';
+
+	export { emphasisRenderer };
+</script>
+
+{#snippet emphasisRenderer(block: EmphasisBlock)}
+	<p class="mb-4 text-sm text-txt-primary" data-kind={block.kind} data-offset={block.startOffset}>
+		{#if block.kind === 'emphasis'}
+			<em class="text-txt-primary italic">{block.text}</em>
+		{:else}
+			<strong class="font-semibold text-txt-primary">{block.text}</strong>
+		{/if}
+	</p>
+{/snippet}

package/dist/editor/plugins/emphasis/EmphasisRenderer.svelte.d.ts

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

package/dist/editor/plugins/emphasis/index.d.ts

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

package/dist/editor/plugins/emphasis/index.js

@@ -0,0 +1,4 @@
+export const emphasisPlugin = {
+    id: 'emphasis',
+    name: 'Emphasis'
+};

package/dist/editor/plugins/emphasis/parse-emphasis.d.ts

@@ -0,0 +1,2 @@
+import type { EmphasisBlock } from './types';
+export declare function parseEmphasis(source: string): EmphasisBlock[];