phormat 0.0.5

package/dist/editor/model/resolveEnterPlainSnapshot.js

@@ -0,0 +1,23 @@
+import { headingDisplayPlain } from '../block-specs/heading/edit';
+import { paragraphDisplayPlain } from '../block-specs/paragraph/edit';
+/** Map live DOM plain + caret into model display-plain coordinates for Enter. */
+export function resolveEnterPlainSnapshot(block, plainText, plainOffset, kind) {
+    const display = kind === 'paragraph' && block.type === 'paragraph'
+        ? paragraphDisplayPlain(block)
+        : kind === 'heading' && block.type === 'heading'
+            ? headingDisplayPlain(block)
+            : plainText;
+    if (plainOffset >= plainText.length || plainOffset >= display.length) {
+        return { plain: display, offset: display.length };
+    }
+    if (block.inlines?.length && plainText !== display) {
+        return {
+            plain: display,
+            offset: Math.max(0, Math.min(plainOffset, display.length))
+        };
+    }
+    return {
+        plain: plainText,
+        offset: Math.max(0, Math.min(plainOffset, plainText.length))
+    };
+}

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

@@ -0,0 +1,16 @@
+import { type LinkRefDefinition } from '../plugins/links-images/parse-links-images';
+import type { InlineNode } from './types';
+type ExcludedRange = {
+    start: number;
+    end: number;
+};
+export type RichInlineContext = {
+    source: string;
+    defs: Map<string, LinkRefDefinition>;
+    excluded: ExcludedRange[];
+};
+export declare function createRichInlineContext(source: string): RichInlineContext;
+export declare function buildRichInlinesForRange(source: string, absStart: number, absEnd: number, ctx: RichInlineContext, options?: {
+    allowLinksAndWiki?: boolean;
+}): InlineNode[];
+export {};

package/dist/editor/model/richInlines.js

@@ -0,0 +1,494 @@
+/**
+ * Rich inline parsing for Markdown bodies.
+ *
+ * Precedence inside a gap (outside inline code, highest wins on overlaps):
+ * inline code (`) → link / image → wiki link → autolink (`<http…>`) → mention →
+ * strikethrough (`~~`) → highlight (`==`) → emphasis (`*` / `**`).
+ */
+import { parseEmphasis } from '../plugins/emphasis/parse-emphasis';
+import { collectDefinitionsAndExcluded, tryParseLinkImageAt } from '../plugins/links-images/parse-links-images';
+import { parseImageLabelLayout, afterBracketLabelContent, sourceOffsetInBracketLabel } from '../plugins/links-images/parse-image-layout';
+export function createRichInlineContext(source) {
+    const { defs, excluded } = collectDefinitionsAndExcluded(source);
+    return { source, defs, excluded };
+}
+function offsetToLine(source, offset) {
+    let line = 0;
+    const upto = Math.min(Math.max(0, offset), source.length);
+    for (let k = 0; k < upto; k++) {
+        if (source[k] === '\n')
+            line++;
+    }
+    return line;
+}
+function sourceRangeForOffsets(source, start, end) {
+    const safeEnd = Math.max(start, end);
+    return {
+        start,
+        end: safeEnd,
+        startLine: offsetToLine(source, start),
+        endLine: offsetToLine(source, safeEnd > start ? safeEnd - 1 : start)
+    };
+}
+function intersects(a, b, c, d) {
+    return a < d && b > c;
+}
+function findInlineCodeSpans(source, lo, hi) {
+    const out = [];
+    let i = lo;
+    while (i < hi) {
+        if (source[i] === '\\') {
+            i += 2;
+            continue;
+        }
+        if (source[i] !== '`') {
+            i++;
+            continue;
+        }
+        const startOffset = i;
+        i++;
+        let text = '';
+        let closed = false;
+        while (i < hi) {
+            if (source[i] === '\n' || source[i] === '\r')
+                break;
+            if (source[i] === '\\' && i + 1 < hi) {
+                text += source[i + 1];
+                i += 2;
+                continue;
+            }
+            if (source[i] === '`') {
+                closed = true;
+                i++;
+                break;
+            }
+            text += source[i];
+            i++;
+        }
+        if (closed) {
+            out.push({ start: startOffset, end: i, text });
+        }
+        else {
+            i = startOffset + 1;
+        }
+    }
+    return out;
+}
+function inExcluded(i, ctx) {
+    return ctx.excluded.some((r) => i >= r.start && i < r.end);
+}
+function isInlineParenDestination(source, afterLabelBracket, blockEnd) {
+    let k = afterLabelBracket;
+    while (k < blockEnd && (source[k] === ' ' || source[k] === '\t' || source[k] === '\n' || source[k] === '\r')) {
+        k++;
+    }
+    return k < blockEnd && source[k] === '(';
+}
+function collectLinkSpans(ctx, lo, hi) {
+    const out = [];
+    for (let i = lo; i < hi; i++) {
+        if (inExcluded(i, ctx))
+            continue;
+        const ch = ctx.source[i];
+        if (ch !== '[' && !(ch === '!' && ctx.source[i + 1] === '['))
+            continue;
+        const b = tryParseLinkImageAt(ctx.source, i, ctx.defs, ctx.excluded);
+        if (b && b.start >= lo && b.end <= hi) {
+            out.push(b);
+            i = b.end - 1;
+        }
+    }
+    return out;
+}
+const WIKI_LINK = /\[\[([^[\]]+?)\]\]/g;
+function collectWikiSpans(source, lo, hi) {
+    const slice = source.slice(lo, hi);
+    const out = [];
+    let m;
+    const re = new RegExp(WIKI_LINK.source, WIKI_LINK.flags);
+    while ((m = re.exec(slice)) !== null) {
+        const absStart = lo + (m.index ?? 0);
+        const absEnd = absStart + m[0].length;
+        const rawInner = m[1]?.trim() ?? '';
+        if (!rawInner)
+            continue;
+        const pipe = rawInner.indexOf('|');
+        let target;
+        let label;
+        if (pipe === -1) {
+            target = rawInner;
+            label = rawInner;
+        }
+        else {
+            target = rawInner.slice(0, pipe).trim();
+            label = rawInner.slice(pipe + 1).trim();
+            if (!target)
+                continue;
+            if (!label)
+                label = target;
+        }
+        if (target.toLowerCase() === 'toc')
+            continue;
+        out.push({
+            type: 'wikiLink',
+            target,
+            label,
+            sourceRange: sourceRangeForOffsets(source, absStart, absEnd)
+        });
+    }
+    return out;
+}
+const ANGLE_AUTOLINK = /<((https?:\/\/[^>\s]+)|(mailto:[^>\s]+))>/gi;
+function collectAutolinkSpans(source, lo, hi) {
+    const slice = source.slice(lo, hi);
+    const out = [];
+    let m;
+    const re = new RegExp(ANGLE_AUTOLINK.source, ANGLE_AUTOLINK.flags);
+    while ((m = re.exec(slice)) !== null) {
+        const absStart = lo + (m.index ?? 0);
+        const absEnd = absStart + m[0].length;
+        const href = m[1] ?? '';
+        out.push({ start: absStart, end: absEnd, href });
+    }
+    return out;
+}
+/** `@[Page]` page mentions — conservative. */
+const MENTION_PAGE = /@\[([^\]\r\n]+)\]/g;
+function collectPageMentions(source, lo, hi) {
+    const slice = source.slice(lo, hi);
+    const out = [];
+    let m;
+    const re = new RegExp(MENTION_PAGE.source, MENTION_PAGE.flags);
+    while ((m = re.exec(slice)) !== null) {
+        const absStart = lo + (m.index ?? 0);
+        const absEnd = absStart + m[0].length;
+        const name = (m[1] ?? '').trim();
+        if (!name)
+            continue;
+        out.push({
+            type: 'mention',
+            kind: 'page',
+            name,
+            sourceRange: sourceRangeForOffsets(source, absStart, absEnd)
+        });
+    }
+    return out;
+}
+/** `@word` user mentions — not inside emails (no alphanumeric before `@`). */
+const MENTION_USER = /(^|[^a-zA-Z0-9])@([a-zA-Z][a-zA-Z0-9_-]{0,63})/g;
+function collectUserMentions(source, lo, hi) {
+    const slice = source.slice(lo, hi);
+    const out = [];
+    let m;
+    const re = new RegExp(MENTION_USER.source, MENTION_USER.flags);
+    while ((m = re.exec(slice)) !== null) {
+        const fullStartInSlice = m.index ?? 0;
+        const prefixLen = m[1]?.length ?? 0;
+        const absStart = lo + fullStartInSlice + prefixLen;
+        const absEnd = absStart + 1 + (m[2]?.length ?? 0);
+        const name = m[2] ?? '';
+        if (!name)
+            continue;
+        out.push({
+            type: 'mention',
+            kind: 'user',
+            name,
+            sourceRange: sourceRangeForOffsets(source, absStart, absEnd)
+        });
+    }
+    return out;
+}
+function findDoubleDelimiterSpans(source, lo, hi, delimiter, outside) {
+    const out = [];
+    const open = delimiter + delimiter;
+    const n = open.length;
+    let i = lo;
+    while (i <= hi - n) {
+        if (source[i] === '\\') {
+            i += 2;
+            continue;
+        }
+        if (source.slice(i, i + n) !== open) {
+            i++;
+            continue;
+        }
+        const start = i;
+        let j = i + n;
+        let closedAt = -1;
+        while (j <= hi - n) {
+            if (source[j] === '\\') {
+                j += 2;
+                continue;
+            }
+            if (source.slice(j, j + n) === open) {
+                closedAt = j + n;
+                break;
+            }
+            j++;
+        }
+        if (closedAt < 0) {
+            i++;
+            continue;
+        }
+        const end = closedAt;
+        if (!outside.some((c) => intersects(start, end, c.start, c.end))) {
+            out.push({ start, end });
+        }
+        i = end;
+    }
+    return out;
+}
+function parseHighlightInner(text) {
+    const m = text.match(/^([a-zA-Z][a-zA-Z0-9_-]*):(.*)$/s);
+    if (m) {
+        return { color: m[1] ?? null, body: m[2] ?? '' };
+    }
+    return { color: null, body: text };
+}
+function emphasisOutsideCode(emph, code) {
+    return emph.filter((e) => !code.some((c) => intersects(e.startOffset, e.endOffset, c.start, c.end)));
+}
+function mergeTagged(parts) {
+    const sorted = [...parts].sort((a, b) => {
+        if (a.start !== b.start)
+            return a.start - b.start;
+        const lenA = a.end - a.start;
+        const lenB = b.end - b.start;
+        if (lenA !== lenB)
+            return lenB - lenA;
+        return b.pri - a.pri;
+    });
+    const picked = [];
+    for (const p of sorted) {
+        if (picked.some((q) => intersects(p.start, p.end, q.start, q.end)))
+            continue;
+        picked.push(p);
+    }
+    picked.sort((a, b) => a.start - b.start);
+    return picked;
+}
+export function buildRichInlinesForRange(source, absStart, absEnd, ctx, options = {}) {
+    const allowLinksAndWiki = options.allowLinksAndWiki !== false;
+    if (absEnd <= absStart)
+        return [];
+    const codeSpans = findInlineCodeSpans(source, absStart, absEnd);
+    const parts = [
+        ...codeSpans.map((c) => ({
+            tag: 'code',
+            start: c.start,
+            end: c.end,
+            text: c.text,
+            pri: 1000
+        }))
+    ];
+    if (allowLinksAndWiki) {
+        for (const block of collectLinkSpans(ctx, absStart, absEnd)) {
+            parts.push({ tag: 'link', start: block.start, end: block.end, block, pri: 700 });
+        }
+        for (const node of collectWikiSpans(source, absStart, absEnd)) {
+            const { start, end } = node.sourceRange;
+            parts.push({ tag: 'wiki', start, end, node, pri: 650 });
+        }
+        for (const a of collectAutolinkSpans(source, absStart, absEnd)) {
+            parts.push({ tag: 'auto', start: a.start, end: a.end, href: a.href, pri: 600 });
+        }
+        for (const node of collectPageMentions(source, absStart, absEnd)) {
+            const { start, end } = node.sourceRange;
+            parts.push({ tag: 'mention', start, end, node, pri: 550 });
+        }
+        for (const node of collectUserMentions(source, absStart, absEnd)) {
+            const { start, end } = node.sourceRange;
+            parts.push({ tag: 'mention', start, end, node, pri: 540 });
+        }
+    }
+    const strikeSpans = findDoubleDelimiterSpans(source, absStart, absEnd, '~', codeSpans);
+    for (const s of strikeSpans) {
+        parts.push({ tag: 'strike', start: s.start, end: s.end, pri: 400 });
+    }
+    const hiSpans = findDoubleDelimiterSpans(source, absStart, absEnd, '=', codeSpans);
+    for (const s of hiSpans) {
+        parts.push({ tag: 'hi', start: s.start, end: s.end, pri: 390 });
+    }
+    const slice = source.slice(absStart, absEnd);
+    const emphRaw = parseEmphasis(slice);
+    const emphSpans = emphasisOutsideCode(emphRaw.map((e) => ({
+        ...e,
+        startOffset: e.startOffset + absStart,
+        endOffset: e.endOffset + absStart
+    })), codeSpans);
+    for (const e of emphSpans) {
+        parts.push({
+            tag: 'emph',
+            start: e.startOffset,
+            end: e.endOffset,
+            emphasisKind: e.kind,
+            text: e.text,
+            pri: e.kind === 'strong' ? 120 : 100
+        });
+    }
+    const merged = mergeTagged(parts);
+    const out = [];
+    let p = absStart;
+    for (const part of merged) {
+        if (part.end <= absStart || part.start >= absEnd)
+            continue;
+        const start = Math.max(part.start, absStart);
+        const end = Math.min(part.end, absEnd);
+        if (p < start) {
+            const t = source.slice(p, start);
+            if (t.length > 0) {
+                out.push({
+                    type: 'text',
+                    text: t,
+                    sourceRange: sourceRangeForOffsets(source, p, start)
+                });
+            }
+        }
+        if (part.tag === 'code') {
+            out.push({
+                type: 'code',
+                text: part.text,
+                sourceRange: sourceRangeForOffsets(source, start, end)
+            });
+        }
+        else if (part.tag === 'link') {
+            const b = part.block;
+            const labelStart = b.kind === 'image' ? b.start + 2 : b.start + 1;
+            const afterLabelBracket = afterBracketLabelContent(source, labelStart);
+            const innerEnd = afterLabelBracket === null ? labelStart + b.label.length : afterLabelBracket - 1;
+            let altEnd = innerEnd;
+            let displayWidth = null;
+            let floatAlign = null;
+            if (b.kind === 'image' &&
+                afterLabelBracket !== null &&
+                isInlineParenDestination(source, afterLabelBracket, b.end)) {
+                const layout = parseImageLabelLayout(b.label);
+                if (!layout.malformedSuffix && layout.suffixPipeIndex !== null) {
+                    altEnd = sourceOffsetInBracketLabel(source, labelStart, layout.suffixPipeIndex);
+                    displayWidth = layout.displayWidth;
+                    floatAlign = layout.floatAlign;
+                }
+            }
+            const labelNodes = buildRichInlinesForRange(source, labelStart, altEnd, ctx, {
+                allowLinksAndWiki: false
+            });
+            const outerRange = sourceRangeForOffsets(source, b.start, b.end);
+            if (b.kind === 'image') {
+                const node = {
+                    type: 'image',
+                    children: labelNodes,
+                    href: b.href,
+                    title: b.title ?? null,
+                    displayWidth,
+                    floatAlign,
+                    sourceRange: outerRange
+                };
+                out.push(node);
+            }
+            else {
+                const node = {
+                    type: 'link',
+                    children: labelNodes,
+                    href: b.href,
+                    title: b.title ?? null,
+                    sourceRange: outerRange
+                };
+                out.push(node);
+            }
+        }
+        else if (part.tag === 'wiki') {
+            out.push(part.node);
+        }
+        else if (part.tag === 'auto') {
+            out.push({
+                type: 'autolink',
+                href: part.href,
+                sourceRange: sourceRangeForOffsets(source, start, end)
+            });
+        }
+        else if (part.tag === 'mention') {
+            out.push(part.node);
+        }
+        else if (part.tag === 'strike') {
+            const innerStart = start + 2;
+            const innerEnd = end - 2;
+            const innerNodes = buildRichInlinesForRange(source, innerStart, innerEnd, ctx, {
+                allowLinksAndWiki: false
+            });
+            out.push({
+                type: 'strikethrough',
+                children: innerNodes,
+                sourceRange: sourceRangeForOffsets(source, start, end)
+            });
+        }
+        else if (part.tag === 'hi') {
+            const innerStart = start + 2;
+            const innerEnd = end - 2;
+            const rawInner = source.slice(innerStart, innerEnd);
+            const { color, body } = parseHighlightInner(rawInner);
+            let bodyStart = innerStart;
+            const bodyEnd = innerEnd;
+            if (color !== null) {
+                const prefix = `${color}:`;
+                if (rawInner.startsWith(prefix)) {
+                    bodyStart = innerStart + prefix.length;
+                }
+            }
+            const innerNodes = bodyStart < bodyEnd
+                ? buildRichInlinesForRange(source, bodyStart, bodyEnd, ctx, {
+                    allowLinksAndWiki: false
+                })
+                : [];
+            const node = {
+                type: 'highlight',
+                color,
+                children: innerNodes.length > 0
+                    ? innerNodes
+                    : [
+                        {
+                            type: 'text',
+                            text: body,
+                            sourceRange: sourceRangeForOffsets(source, bodyStart, bodyEnd)
+                        }
+                    ],
+                sourceRange: sourceRangeForOffsets(source, start, end)
+            };
+            out.push(node);
+        }
+        else if (part.tag === 'emph') {
+            const open = part.emphasisKind === 'strong' ? 2 : 1;
+            const innerStart = start + open;
+            const innerEnd = end - open;
+            const innerNodes = buildRichInlinesForRange(source, innerStart, innerEnd, ctx, {
+                allowLinksAndWiki: false
+            });
+            const outerRange = sourceRangeForOffsets(source, start, end);
+            if (part.emphasisKind === 'strong') {
+                out.push({
+                    type: 'strong',
+                    children: innerNodes,
+                    sourceRange: outerRange
+                });
+            }
+            else {
+                out.push({
+                    type: 'emphasis',
+                    children: innerNodes,
+                    sourceRange: outerRange
+                });
+            }
+        }
+        p = end;
+    }
+    if (p < absEnd) {
+        const t = source.slice(p, absEnd);
+        if (t.length > 0) {
+            out.push({
+                type: 'text',
+                text: t,
+                sourceRange: sourceRangeForOffsets(source, p, absEnd)
+            });
+        }
+    }
+    return out;
+}

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

@@ -0,0 +1,3 @@
+import type { InlineNode } from './types';
+/** Emits Markdown inline spans for heading body / list items / serialized blocks. */
+export declare function serializeInlineNodes(nodes: InlineNode[]): string;

package/dist/editor/model/serializeInlineNodes.js

@@ -0,0 +1,45 @@
+import { serializeImageLayoutSuffix } from '../plugins/links-images/parse-image-layout';
+function escapeTitle(title) {
+    return title.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+function serializeInlineNode(node) {
+    switch (node.type) {
+        case 'text':
+            return node.text;
+        case 'code':
+            return '`' + node.text + '`';
+        case 'emphasis':
+            return '*' + node.children.map(serializeInlineNode).join('') + '*';
+        case 'strong':
+            return '**' + node.children.map(serializeInlineNode).join('') + '**';
+        case 'strikethrough':
+            return '~~' + node.children.map(serializeInlineNode).join('') + '~~';
+        case 'highlight': {
+            const inner = node.children.map(serializeInlineNode).join('');
+            return node.color ? `==${node.color}:${inner}==` : `==${inner}==`;
+        }
+        case 'autolink':
+            return `<${node.href}>`;
+        case 'wikiLink':
+            return node.label === node.target ? `[[${node.target}]]` : `[[${node.target}|${node.label}]]`;
+        case 'mention':
+            return node.kind === 'page' ? `@[${node.name}]` : `@${node.name}`;
+        case 'link': {
+            const label = node.children.map(serializeInlineNode).join('');
+            const title = node.title && node.title.length > 0 ? ` "${escapeTitle(node.title)}"` : '';
+            return node.href ? `[${label}](${node.href}${title})` : label;
+        }
+        case 'image': {
+            const alt = node.children.map(serializeInlineNode).join('');
+            const suffix = serializeImageLayoutSuffix(node.displayWidth, node.floatAlign);
+            const title = node.title && node.title.length > 0 ? ` "${escapeTitle(node.title)}"` : '';
+            return node.href ? `![${alt}${suffix}](${node.href}${title})` : alt;
+        }
+        default:
+            return '';
+    }
+}
+/** Emits Markdown inline spans for heading body / list items / serialized blocks. */
+export function serializeInlineNodes(nodes) {
+    return nodes.map(serializeInlineNode).join('');
+}

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

@@ -0,0 +1,30 @@
+import type { EditorBlock, EditorDocument } from './types';
+/**
+ * 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 declare function serializeEditorBlock(block: EditorBlock, source?: string): string;
+/** Serialize a contiguous slice of top-level blocks (list runs, paragraphs, etc.). */
+export declare function serializeTopLevelBlockSpan(blocks: EditorBlock[], start: number, end: number, source?: string): string;
+export declare function serializeMarkdownDocument(doc: EditorDocument): string;
+/**
+ * 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 declare function serializeMarkdownDocumentPreserving(doc: EditorDocument, dirtyTopLevelIds: ReadonlySet<string>): string;