@aicayzer/inkkit 0.0.3 → 0.0.5

package/README.md

@@ -33,10 +33,12 @@ editor.loadDocument({
 const snapshot = editor.snapshot(1)
 ```
 
-Markdown includes CommonMark, task lists, strikethrough, autolinks, GFM tables, editable footnotes and reference-style links, bounded callouts, highlights and author comments. Unsupported constructs remain literal Markdown. TXT mode treats all text literally. Images require a host adapter. RTF files remain outside the package scope.
+Markdown includes CommonMark, task lists, strikethrough, autolinks, GFM tables, editable footnotes and reference-style links, bounded callouts, highlights, author comments and offline Mermaid diagrams. Unsupported constructs remain literal Markdown. TXT mode treats all text literally. Images require a host adapter. RTF files remain outside the package scope.
+
+`await editor.printableSnapshot(1)` returns a complete printable HTML document, print styles and portable image bytes. It excludes author comments, includes folded content and reports unavailable assets or a changed document. Client apps own Print/PDF commands, dialogs and file generation.
 
 See [supported syntax](docs/supported-syntax.md), [the host API](docs/api.md), [preservation and clipboard behavior](docs/preservation.md), [development](docs/development.md), and [releases](docs/releasing.md).
 
-Planned work and release scope are tracked in the [InkKit Project](https://github.com/users/aicayzer/projects/3) and [milestones](https://github.com/aicayzer/inkkit/milestones). Release 0.0.2 is published and verified; 0.0.3 delivery is authorised. Targets from 0.0.4 remain provisional.
+Delivery scope and release status are tracked in the [InkKit Project](https://github.com/users/aicayzer/projects/3) and [milestones](https://github.com/aicayzer/inkkit/milestones).
 
 MIT licensed. InkKit builds on the public PadPad and Memos editors; see [NOTICE](NOTICE).

package/dist/clipboard.d.ts

@@ -8,4 +8,4 @@ export declare function clipboardText(content: Fragment, missingImages?: Readonl
 export declare function clipboardContent(content: Fragment, schema: Schema): ClipboardContent;
 export declare const visibleClipboard: import("@milkdown/kit/utils").$Prose;
 /** Export a frozen document fragment; presentation URLs never enter the clipboard. */
-export declare function portableClipboard(content: Fragment, schema: Schema, markdown: string, adapter: ImageAdapter | undefined, context: DocumentContext): Promise<ClipboardOutput>;
+export declare function portableClipboard(content: Fragment, schema: Schema, markdown: string, adapter: ImageAdapter | undefined, context: DocumentContext, completeDiagrams?: ReadonlySet<string>): Promise<ClipboardOutput>;

package/dist/clipboard.js

@@ -2,6 +2,7 @@ import { DOMSerializer, } from '@milkdown/kit/prose/model';
 import { Plugin, PluginKey } from '@milkdown/kit/prose/state';
 import { $prose } from '@milkdown/kit/utils';
 import { shareableFragment } from './comments.js';
+import { diagramImage } from './mermaid.js';
 // Clipboard text is the visible document, not Markdown serialization: escaping
 // punctuation or trailing spaces here leaks source syntax into other apps.
 export function clipboardText(content, missingImages = new Set()) {
@@ -110,7 +111,7 @@ export const visibleClipboard = $prose(() => new Plugin({
     },
 }));
 /** Export a frozen document fragment; presentation URLs never enter the clipboard. */
-export async function portableClipboard(content, schema, markdown, adapter, context) {
+export async function portableClipboard(content, schema, markdown, adapter, context, completeDiagrams) {
     content = shareableFragment(content);
     const base = clipboardContent(content, schema);
     const container = document.createElement('div');
@@ -130,6 +131,7 @@ export async function portableClipboard(content, schema, markdown, adapter, cont
     });
     await Promise.all(captured.map(async ({ element, reference, alt }, index) => {
         element.setAttribute('data-inkkit-image-slot', String(index));
+        element.setAttribute('data-inkkit-authored-image-slot', String(index));
         try {
             if (!adapter)
                 throw new Error('The image is unavailable.');
@@ -152,6 +154,55 @@ export async function portableClipboard(content, schema, markdown, adapter, cont
             images[index] = { reference, alt, error: message };
         }
     }));
+    const diagrams = [];
+    for (const code of container.querySelectorAll('pre[data-language="mermaid"] > code')) {
+        const source = code.textContent ?? '';
+        if (completeDiagrams && !completeDiagrams.has(source))
+            continue;
+        const result = { source };
+        diagrams.push(result);
+        try {
+            const image = await diagramImage(source);
+            let binary = '';
+            for (const byte of image.bytes)
+                binary += String.fromCharCode(byte);
+            const figure = document.createElement('figure');
+            figure.setAttribute('data-inkkit-mermaid', source);
+            const fence = code.parentElement.getAttribute('data-inkkit-fence');
+            if (fence)
+                figure.setAttribute('data-inkkit-fence', fence);
+            const element = document.createElement('img');
+            element.src = `data:image/png;base64,${btoa(binary)}`;
+            element.alt = `Mermaid diagram: ${source}`;
+            figure.append(element);
+            code.parentElement.replaceWith(figure);
+            result.image = image;
+        }
+        catch (error) {
+            result.error =
+                error instanceof Error
+                    ? error.message
+                    : 'The diagram could not be exported.';
+            const warning = document.createElement('p');
+            warning.setAttribute('data-inkkit-diagram-error', '');
+            warning.textContent = `Diagram unavailable: ${result.error}`;
+            code.parentElement.before(warning);
+        }
+    }
+    // Native attachment slots follow DOM order, including generated diagrams.
+    const orderedImages = [];
+    for (const element of container.querySelectorAll('img')) {
+        const diagram = element.closest('[data-inkkit-mermaid]');
+        const item = diagram
+            ? {
+                reference: '',
+                alt: element.alt,
+                image: diagrams.find((entry) => entry.source === diagram.getAttribute('data-inkkit-mermaid')).image,
+            }
+            : images[Number(element.getAttribute('data-inkkit-image-slot'))];
+        element.setAttribute('data-inkkit-image-slot', String(orderedImages.length));
+        orderedImages.push(item);
+    }
     // Scriptable links and event attributes are not part of semantic rich text.
     for (const element of container.querySelectorAll('*')) {
         for (const attribute of [...element.attributes])
@@ -165,6 +216,7 @@ export async function portableClipboard(content, schema, markdown, adapter, cont
         text: clipboardText(content, missing),
         html: container.innerHTML,
         markdown,
-        images,
+        images: [...orderedImages, ...images.filter((image) => image.error)],
+        diagrams,
     };
 }

package/dist/code-fences.d.ts

@@ -0,0 +1,8 @@
+import { type Options } from 'mdast-util-to-markdown';
+import type { Ctx } from '@milkdown/kit/ctx';
+import type { Node as ProseNode } from '@milkdown/kit/prose/model';
+export declare const remarkCodeFences: import("@milkdown/kit/utils").$Remark<"codeFences", unknown>;
+export declare const preservingCodeBlocks: import("@milkdown/kit/utils").$NodeSchema<"code_block">;
+export declare const fencedCodeHandler: NonNullable<Options['handlers']>['code'];
+export declare function restoreCodeEndings(ctx: Ctx, doc: ProseNode, markdown: string): string;
+export declare function finalCodeEnding(doc: ProseNode): string | undefined;

package/dist/code-fences.js

@@ -0,0 +1,166 @@
+import { codeBlockSchema } from '@milkdown/kit/preset/commonmark';
+import { $remark } from '@milkdown/kit/utils';
+import { defaultHandlers } from 'mdast-util-to-markdown';
+import { remarkCtx } from '@milkdown/kit/core';
+function readFence(value) {
+    if (typeof value !== 'object' || value == null)
+        return null;
+    const fence = value;
+    return typeof fence.marker === 'string' &&
+        /^(?:`{3,}|~{3,})$/.test(fence.marker) &&
+        fence.marker.length <= 30000 &&
+        typeof fence.info === 'string' &&
+        !/[\r\n]/.test(fence.info) &&
+        typeof fence.close === 'string' &&
+        (!fence.close ||
+            new RegExp(`^${fence.marker[0]}{${fence.marker.length},}$`).test(fence.close)) &&
+        typeof fence.trailing === 'string' &&
+        /^[ \t]*$/.test(fence.trailing) &&
+        ['\n', '\r\n'].includes(fence.ending)
+        ? fence
+        : null;
+}
+export const remarkCodeFences = $remark('codeFences', () => () => (tree, file) => {
+    const source = String(file.value).replace(/^\uFEFF/, '');
+    const visit = (node) => {
+        if (node.type === 'code') {
+            const raw = source.slice(node.position?.start.offset, node.position?.end.offset);
+            const opening = /^(`{3,}|~{3,})([^\r\n]*)(\r?\n)/.exec(raw);
+            if (opening) {
+                const close = /(?:^|\n)[ \t>]*(`{3,}|~{3,})([ \t]*)\r?$/.exec(raw);
+                const matching = close &&
+                    close[1][0] === opening[1][0] &&
+                    close[1].length >= opening[1].length;
+                node.data = {
+                    ...node.data,
+                    inkkitFence: {
+                        marker: opening[1],
+                        info: opening[2],
+                        close: matching ? close[1] : '',
+                        trailing: matching ? close[2] : '',
+                        ending: opening[3],
+                    },
+                };
+            }
+        }
+        if ('children' in node)
+            node.children.forEach(visit);
+    };
+    visit(tree);
+});
+export const preservingCodeBlocks = codeBlockSchema.extendSchema((base) => (ctx) => {
+    const schema = base(ctx);
+    return {
+        ...schema,
+        attrs: { ...schema.attrs, authoredFence: { default: null } },
+        parseDOM: [
+            {
+                tag: 'pre',
+                preserveWhitespace: 'full',
+                getAttrs: (dom) => {
+                    let authoredFence = null;
+                    try {
+                        authoredFence = readFence(JSON.parse(dom.getAttribute('data-inkkit-fence') ?? 'null'));
+                    }
+                    catch {
+                        /* Ordinary code stays usable without provenance. */
+                    }
+                    return { language: dom.dataset.language ?? '', authoredFence };
+                },
+            },
+        ],
+        toDOM: (node) => [
+            'pre',
+            {
+                'data-language': node.attrs.language,
+                ...(node.attrs.authoredFence
+                    ? { 'data-inkkit-fence': JSON.stringify(node.attrs.authoredFence) }
+                    : {}),
+            },
+            ['code', 0],
+        ],
+        parseMarkdown: {
+            match: (node) => node.type === 'code',
+            runner: (state, node, type) => {
+                state.openNode(type, {
+                    language: node.lang ?? '',
+                    authoredFence: readFence(node.data?.inkkitFence),
+                });
+                if (node.value)
+                    state.addText(String(node.value).replace(/\r\n?/g, '\n'));
+                state.closeNode();
+            },
+        },
+        toMarkdown: {
+            match: (node) => node.type.name === 'code_block',
+            runner: (state, node) => {
+                state.addNode('code', undefined, node.textContent, {
+                    lang: node.attrs.language,
+                    data: { inkkitFence: node.attrs.authoredFence },
+                });
+            },
+        },
+    };
+});
+export const fencedCodeHandler = (node, parent, state, info) => {
+    const fence = readFence(node.data?.inkkitFence);
+    if (!fence)
+        return defaultHandlers.code(node, parent, state, info);
+    const character = fence.marker[0];
+    let length = fence.marker.length;
+    const body = node.value.replace(/\r\n?/g, '\n');
+    for (const line of body.split('\n')) {
+        const run = new RegExp(`^ {0,3}(${character}+)[ \\t]*$`).exec(line);
+        if (run)
+            length = Math.max(length, run[1].length + 1);
+    }
+    const close = fence.close
+        ? character.repeat(Math.max(length, fence.close.length)) + fence.trailing
+        : '';
+    return (character.repeat(length) +
+        fence.info +
+        fence.ending +
+        body.replaceAll('\n', fence.ending) +
+        (close ? (body ? fence.ending : '') + close : ''));
+};
+export function restoreCodeEndings(ctx, doc, markdown) {
+    const endings = [];
+    doc.descendants((node) => {
+        if (node.type.name === 'code_block')
+            endings.push(readFence(node.attrs.authoredFence)?.ending ?? '\n');
+    });
+    const patches = [];
+    let index = 0;
+    const visit = (node) => {
+        if (node.type === 'code') {
+            const ending = endings[index++];
+            const from = node.position?.start.offset, to = node.position?.end.offset;
+            if (ending === '\r\n' && from != null && to != null)
+                patches.push({
+                    from,
+                    to,
+                    text: markdown
+                        .slice(from, to)
+                        .replace(/\r\n?/g, '\n')
+                        .replaceAll('\n', ending),
+                });
+        }
+        if ('children' in node)
+            node.children.forEach(visit);
+    };
+    const processor = ctx.get(remarkCtx);
+    visit(processor.runSync(processor.parse(markdown), { value: markdown }));
+    for (const patch of patches.reverse())
+        markdown =
+            markdown.slice(0, patch.from) + patch.text + markdown.slice(patch.to);
+    return markdown;
+}
+export function finalCodeEnding(doc) {
+    let last = doc.lastChild;
+    while (last) {
+        if (last.type.name === 'code_block')
+            return readFence(last.attrs.authoredFence)?.ending;
+        last = last.lastChild;
+    }
+    return undefined;
+}

package/dist/dialect.js

@@ -3,6 +3,7 @@ import { commonmark, hardbreakSchema, imageSchema, paragraphSchema, remarkInline
 import { extendListItemSchemaForTask, strikethroughAttr, strikethroughInputRule, strikethroughKeymap, strikethroughSchema, toggleStrikethroughCommand, wrapInTaskListInputRule, tableSchema, tableHeaderRowSchema, tableHeaderSchema, tableRowSchema, tableCellSchema, tableEditingPlugin, tableKeymap, goToNextTableCellCommand, goToPrevTableCellCommand, insertTableCommand, addRowBeforeCommand, addRowAfterCommand, addColBeforeCommand, addColAfterCommand, selectRowCommand, selectColCommand, deleteSelectedCellsCommand, setAlignCommand, exitTable, } from '@milkdown/kit/preset/gfm';
 import { $remark } from '@milkdown/kit/utils';
 import { autolinkInputRule } from './autolink.js';
+import { preservingCodeBlocks, remarkCodeFences, fencedCodeHandler, } from './code-fences.js';
 import { literalBlock, createLiteralPreservation } from './literals.js';
 import { references, remarkReferencesPlugin } from './references.js';
 import { callouts, remarkCalloutsPlugin } from './callouts.js';
@@ -85,7 +86,7 @@ function remarkDialect() {
     add('toMarkdownExtensions', gfmTaskListItemToMarkdown());
     add('toMarkdownExtensions', gfmAutolinkLiteralToMarkdown());
     add('toMarkdownExtensions', gfmTableToMarkdown());
-    add('toMarkdownExtensions', { handlers: { link } });
+    add('toMarkdownExtensions', { handlers: { link, code: fencedCodeHandler } });
 }
 export const remarkDialectPlugin = $remark('remarkDialect', () => remarkDialect);
 // Reference links retain their authored form instead of expanding to inline links.
@@ -254,6 +255,7 @@ export const tables = [
 ].flat();
 export function createDialect(images) {
     return [
+        remarkCodeFences,
         remarkReferencesPlugin,
         remarkCalloutsPlugin,
         remarkCommentsPlugin,
@@ -264,6 +266,7 @@ export function createDialect(images) {
         callouts,
         comments,
         inlineHighlight,
+        preservingCodeBlocks,
         preserveSpacerParagraphs,
         visibleSoftbreaks,
         normalizedImages,

package/dist/editor.d.ts

@@ -1,5 +1,5 @@
 import { type TableCommand } from './tables.js';
-import { type DocumentInput, type DocumentSnapshot, type ImageAdapter, type ClipboardInput, type ClipboardOutput } from './types.js';
+import { type DocumentInput, type DocumentSnapshot, type ImageAdapter, type ClipboardInput, type ClipboardOutput, type PrintableDocument } from './types.js';
 export type Mark = 'bold' | 'italic' | 'strikethrough' | 'highlight' | 'code' | 'link';
 export type Block = {
     type: 'paragraph';
@@ -65,6 +65,7 @@ export declare class InkKitEditor {
     private assertCurrent;
     private plainSource;
     snapshot(expectedGeneration?: number): DocumentSnapshot;
+    printableSnapshot(expectedGeneration?: number): Promise<PrintableDocument>;
     clipboardSnapshot(all?: boolean): Promise<ClipboardOutput>;
     paste(input: ClipboardInput): Promise<void>;
     setCommentsVisible(visible: boolean): void;

package/dist/editor.js

@@ -1,4 +1,4 @@
-import { Editor, defaultValueCtx, editorViewCtx, editorViewOptionsCtx, remarkStringifyOptionsCtx, rootCtx, } from '@milkdown/kit/core';
+import { Editor, defaultValueCtx, editorViewCtx, editorViewOptionsCtx, remarkCtx, remarkStringifyOptionsCtx, rootCtx, } from '@milkdown/kit/core';
 import { visibleClipboard, portableClipboard, clipboardText, clipboardContent, } from './clipboard.js';
 import { clipboard } from '@milkdown/kit/plugin/clipboard';
 import { history } from '@milkdown/kit/plugin/history';
@@ -26,6 +26,8 @@ import { PasteController } from './paste.js';
 import { selectionPlugin } from './selection.js';
 import { search, SearchQuery, getSearchState, setSearchState, } from 'prosemirror-search';
 import { taskListPlugin, toggleTaskList } from './tasks.js';
+import { isMermaid, mermaidPreview } from './mermaid.js';
+import { hasAuthoredImagesInLiterals, printableMarkdown, printableText, } from './print.js';
 const shortcutCommands = {
     heading1: ['heading', 1],
     heading2: ['heading', 2],
@@ -333,6 +335,42 @@ export class InkKitEditor {
             dirty: text !== this.originalSource,
         };
     }
+    async printableSnapshot(expectedGeneration) {
+        const snapshot = this.snapshot(expectedGeneration);
+        const epoch = this.documentEpoch;
+        const state = this.editor.ctx.get(editorViewCtx).state;
+        let output;
+        try {
+            if (snapshot.format === 'md' &&
+                !this.options.images &&
+                hasAuthoredImagesInLiterals(state.doc.content, (source) => this.editor.ctx.get(remarkCtx).parse(source)))
+                throw new InkKitError('image-unavailable', 'No image adapter is configured for the authored images.');
+            output =
+                snapshot.format === 'txt'
+                    ? printableText(snapshot.text)
+                    : await printableMarkdown(state.doc.content, state.schema, this.options.images, this.context());
+        }
+        finally {
+            this.assertCurrent(snapshot.generation);
+            if (snapshot.documentId !== this.documentId ||
+                epoch !== this.documentEpoch ||
+                snapshot.revision !== this.revision)
+                throw new InkKitError('stale-document', 'Document changed while preparing printable content');
+        }
+        return Object.freeze({
+            documentId: snapshot.documentId,
+            generation: snapshot.generation,
+            revision: snapshot.revision,
+            format: snapshot.format,
+            html: output.html,
+            styles: output.styles,
+            assets: Object.freeze(output.assets.map((asset) => Object.freeze({
+                ...asset,
+                bytes: new Uint8Array(asset.bytes),
+            }))),
+            warnings: Object.freeze(output.warnings.map((warning) => Object.freeze({ ...warning }))),
+        });
+    }
     async clipboardSnapshot(all = true) {
         const snapshot = this.snapshot();
         const epoch = this.documentEpoch;
@@ -342,9 +380,24 @@ export class InkKitEditor {
                 : this.plain.value.slice(this.plain.selectionStart, this.plain.selectionEnd);
             const pre = document.createElement('pre');
             pre.textContent = text;
-            return { text, html: pre.outerHTML, markdown: text, images: [] };
+            return {
+                text,
+                html: pre.outerHTML,
+                markdown: text,
+                images: [],
+                diagrams: [],
+            };
         }
         const { doc, schema, selection } = this.editor.ctx.get(editorViewCtx).state;
+        const completeDiagrams = new Set();
+        doc.descendants((node, pos) => {
+            if (isMermaid(node) &&
+                (all ||
+                    (selection.from <= pos + 1 &&
+                        selection.to >= pos + node.nodeSize - 1))) {
+                completeDiagrams.add(node.textContent.replace(/\r\n?/g, '\n'));
+            }
+        });
         const content = all
             ? doc.content
             : commentSelectionContent(doc, selection.from, selection.to, selection.content().content);
@@ -355,14 +408,16 @@ export class InkKitEditor {
         try {
             markdown = all
                 ? snapshot.text
-                : selectionMarkdown(this.editor.ctx, doc, valid);
+                : completeDiagrams.size
+                    ? new Preservation(this.editor.ctx, snapshot.text).serialize(doc.type.create(null, selectionContent(doc, valid)))
+                    : selectionMarkdown(this.editor.ctx, doc, valid);
         }
         catch (error) {
             throw new InkKitError('preservation', error instanceof Error
                 ? error.message
                 : 'Cannot copy the selected Markdown');
         }
-        const result = await portableClipboard(all ? content : selectionContent(doc, content), schema, markdown, this.options.images, this.context());
+        const result = await portableClipboard(all ? content : selectionContent(doc, content), schema, markdown, this.options.images, this.context(), completeDiagrams);
         const metadata = referenceMetadata(this.editor.ctx, doc, content);
         if (metadata != null)
             result.html = withReferenceMetadata(result.html, metadata);
@@ -371,6 +426,8 @@ export class InkKitEditor {
             throw new InkKitError('stale-document', 'Document changed');
         if (result.images.some((image) => image.error))
             this.events.error?.(new InkKitError('image-unavailable', 'Some copied images were unavailable; their descriptions were retained'));
+        if (result.diagrams?.some((diagram) => diagram.error))
+            this.events.error?.(new InkKitError('diagram-unavailable', 'Some diagrams could not be exported; their source was retained'));
         return result;
     }
     async paste(input) {
@@ -527,6 +584,7 @@ export class InkKitEditor {
             .use(codeCopyPlugin((text) => events.copy(text)))
             .use(placeholderPlugin)
             .use(highlightPlugin)
+            .use(mermaidPreview((error) => events.error?.(error)))
             .use(selectionPlugin)
             .use($prose(() => search()))
             .use(options.images ? imageView(options.images) : [])
@@ -595,7 +653,7 @@ export class InkKitEditor {
             const expanded = selectionContent(view.state.doc, fragment);
             let hasImages = false;
             expanded.descendants((node) => {
-                if (node.type.name === 'image')
+                if (node.type.name === 'image' || isMermaid(node))
                     hasImages = true;
             });
             if (!hasImages) {
@@ -633,8 +691,10 @@ export class InkKitEditor {
                 void instance
                     .clipboardSnapshot(false)
                     .then(async (content) => {
-                    if (cut && content.images.some((image) => image.error))
-                        throw new InkKitError('image-unavailable', 'The selected images could not be cut safely');
+                    if (cut &&
+                        (content.images.some((image) => image.error) ||
+                            content.diagrams?.some((diagram) => diagram.error)))
+                        throw new InkKitError('image-unavailable', 'The selected content could not be cut safely');
                     await events.clipboard(content);
                     if (cut) {
                         instance.assertCurrent();
@@ -651,7 +711,7 @@ export class InkKitEditor {
                 container.textContent = clipboardText(expanded);
                 event.clipboardData?.setData('text/plain', container.textContent ?? '');
                 event.clipboardData?.setData('text/html', container.outerHTML);
-                events.error?.(new InkKitError('image-unavailable', 'The host must provide a clipboard handler to copy images'));
+                events.error?.(new InkKitError('image-unavailable', 'The host must provide a clipboard handler for portable images and diagrams'));
             }
         };
         root.addEventListener('copy', instance.copyHandler, true);

package/dist/index.d.ts

@@ -2,4 +2,4 @@ export { InkKitEditor } from './editor.js';
 export type { EditorEvents, CaretState, Mark, Block, FormatCommand, Keymap, } from './editor.js';
 export type { TableCommand } from './tables.js';
 export { InkKitError } from './types.js';
-export type { DocumentFormat, DocumentContext, DocumentInput, DocumentSnapshot, EditorErrorCode, ImageAdapter, CapturedImage, PortableImage, ClipboardInput, ClipboardOutput, ClipboardImage, } from './types.js';
+export type { DocumentFormat, DocumentContext, DocumentInput, DocumentSnapshot, EditorErrorCode, ImageAdapter, CapturedImage, PortableImage, ClipboardInput, ClipboardOutput, ClipboardImage, ClipboardDiagram, PrintableDocument, PrintableWarning, } from './types.js';

package/dist/literals.d.ts

@@ -12,6 +12,7 @@ declare module 'mdast' {
         inkkitLiteral: InkKitLiteral;
     }
 }
+export declare function sourceFrontmatter(source: string): string | undefined;
 export declare function createLiteralPreservation(images: boolean): import("@milkdown/kit/utils").$Remark<"preserveLiterals", unknown>;
 export declare const preserveLiterals: import("@milkdown/kit/utils").$Remark<"preserveLiterals", unknown>;
 export declare const literalBlock: import("@milkdown/kit/utils").$Node;

package/dist/literals.js

@@ -1,6 +1,9 @@
 import { $node, $remark } from '@milkdown/kit/utils';
 import { commentSource, literalCommentSpans, } from './comments.js';
 const unsupported = new Set(['html', 'image', 'imageReference']);
+export function sourceFrontmatter(source) {
+    return /^(---|\+\+\+)\r?\n[\s\S]*?\r?\n\1(?:\r?\n|$)/.exec(source)?.[0];
+}
 function restoreInlineBreaks(node) {
     if ((node.type === 'paragraph' || node.type === 'heading') &&
         node.children.length > 1) {
@@ -51,8 +54,8 @@ export function createLiteralPreservation(images) {
         restoreInlineBreaks(tree);
         // Micromark's positions exclude an initial byte-order mark.
         const source = String(file.value).replace(/^\uFEFF/, '');
-        const frontmatter = /^(---|\+\+\+)\r?\n[\s\S]*?\r?\n\1(?:\r?\n|$)/.exec(source);
-        const frontmatterEnd = frontmatter?.[0].length ?? 0;
+        const frontmatter = sourceFrontmatter(source);
+        const frontmatterEnd = frontmatter?.length ?? 0;
         const preserveBlock = (node, depth = 0) => {
             if (node.type === 'footnoteDefinition') {
                 node.children = node.children.map((child) => preserveBlock(child, depth + 1));
@@ -80,13 +83,13 @@ export function createLiteralPreservation(images) {
         if (frontmatter)
             blocks.push({
                 type: 'inkkitLiteral',
-                value: frontmatter[0].trimEnd(),
+                value: frontmatter.trimEnd(),
                 position: {
                     start: { line: 1, column: 1, offset: 0 },
                     end: {
                         line: 1,
                         column: 1,
-                        offset: frontmatter[0].trimEnd().length,
+                        offset: frontmatter.trimEnd().length,
                     },
                 },
             });

package/dist/mermaid.d.ts

@@ -0,0 +1,8 @@
+import type { Node as ProseNode } from '@milkdown/kit/prose/model';
+import { type PortableImage } from './types.js';
+export declare function isMermaid(node: ProseNode): boolean;
+export declare function validateDiagram(source: string): void;
+export declare function safeDiagramSVG(svg: string): string;
+export declare function renderDiagram(source: string): Promise<string>;
+export declare function diagramImage(source: string): Promise<PortableImage>;
+export declare function mermaidPreview(onError: (error: Error) => void): import("@milkdown/kit/utils").$Prose;