@aicayzer/inkkit 0.0.14 → 0.0.16

package/NOTICE

@@ -1,7 +1,3 @@
-InkKit includes editor behavior and source from PadPad and Memos.
-Copyright (c) 2026 August Cayzer. Licensed under the MIT License.
-Sources: https://github.com/aicayzer/padpad and https://github.com/aicayzer/memos
-
 The scoped table styles in src/style.css are adapted from prosemirror-tables.
 Source: https://github.com/ProseMirror/prosemirror-tables
 

package/README.md

@@ -1,33 +1,31 @@
 # InkKit
 
-InkKit is a reusable Markdown editor for simple writing tools and richer document apps. It provides formatted editing, source preservation, portable clipboard content and optional host-managed images, while your app controls its appearance, files and interface.
+A Markdown editor for the web and for apps that host a web view. It edits formatted text and keeps your Markdown as you wrote it: a document you open and leave is saved unchanged, and an edit rewrites only the blocks it touches.
 
-Write in formatted or source mode with shared undo/redo. Edit tables, task lists, footnotes, reference links, highlights and callouts. Preview bounded Mermaid diagrams offline. Copy readable text and semantic HTML, explicitly copy Markdown source, or capture a complete printable document. Native hosts can use scoped readable-text ranges and demand-driven geometry with their own search controls and viewport insets. Unsupported syntax remains editable literal Markdown.
+- Formatted and source editing, with one undo history
+- Tables, task lists, footnotes, callouts, highlights and reference links
+- Mermaid diagram previews, offline
+- Copy as readable text or HTML, or copy the Markdown itself
+- Images and files through your own storage adapter
+- Your app owns the toolbar, menus, files and appearance
 
-Host controls, read-only and text-input policies, command availability, scoped appearance, labels and shortcuts are available from 0.0.8. Check the [releases](https://github.com/aicayzer/inkkit/releases) for published versions and verification evidence.
+## Install
 
 ```sh
 npm install @aicayzer/inkkit
 ```
 
+## Use
+
 ```ts
 import { InkKitEditor } from '@aicayzer/inkkit'
 import '@aicayzer/inkkit/style.css'
 
-const root = document.getElementById('editor')!
-const editor = await InkKitEditor.mount(root, {
-  changed(text, generation) {
-    // Notify the host; capture a fresh snapshot when saving.
-  },
-  stateChanged(state) {
-    // Update the host's formatting controls.
-  },
-  openLink(href) {
-    // Open through the host.
-  },
-  copy(text) {
-    // Write code-block text to the clipboard.
-  },
+const editor = await InkKitEditor.mount(document.getElementById('editor')!, {
+  changed(markdown, generation) {},
+  stateChanged(state) {},
+  openLink(href) {},
+  copy(text) {},
 })
 
 editor.loadDocument({
@@ -36,17 +34,22 @@ editor.loadDocument({
   format: 'md',
   text: '# Hello\n\nStart writing.\n',
 })
-const snapshot = editor.snapshot(1)
+
+const { text } = editor.snapshot(1)
 ```
 
-InkKit runs on the web and in offline web views. Hosts use its public TypeScript facade and own toolbars, menus, persistence, clipboard bridges, Print/PDF actions and image storage. Images require an adapter; private references stay opaque. TXT stays literal. RTF document editing is outside current support.
+## Built with InkKit
 
-Start with the [feature guide](docs/supported-syntax.md) and [simple and rich integration examples](docs/integration.md). The [documentation index](docs/README.md) links to precise API, preservation, playground, verification and publication guidance.
+- [Memos](https://github.com/aicayzer/memos): a small Mac app for memos, in one floating window
+- [PadPad](https://github.com/aicayzer/padpad): a small Mac app for quick text and files
 
-Scope and release status live in the [InkKit Project](https://github.com/users/aicayzer/projects/3) and [version milestones](https://github.com/aicayzer/inkkit/milestones). Only documented, released features form the supported package contract.
+## Learn more
 
-MIT licensed. InkKit builds on the public PadPad and Memos editors; see [NOTICE](NOTICE).
+- [Supported syntax](docs/supported-syntax.md)
+- [Integration guide](docs/integration.md)
+- [API reference](docs/api.md)
+- [All documentation](docs/README.md)
 
-Optional wiki links and a host-owned asynchronous file adapter support named/path images, audio, video, PDFs and file cards. Authored source and sizing are preserved; portable copy/print uses validated images or documented descriptive fallbacks. See [linked syntax](docs/supported-syntax.md#linked-syntax) and [adapter contracts](docs/api.md#optional-wiki-links-and-files).
+## License
 
-From 0.0.11, minimal hosts can mount with `rendering: { codeHighlighting: false, diagramPreview: false }` to skip optional presentation work. Source, shared history and explicit portable exports retain their contracts. Mermaid loads on first actual render. Single-file offline bundles still contain the rendering code; see [performance measurements](docs/performance.md).
+[MIT](LICENSE). Third-party notices are in [NOTICE](NOTICE).

package/dist/comments.js

@@ -1,6 +1,7 @@
 import { $node, $prose, $remark } from '@milkdown/kit/utils';
 import { Fragment } from '@milkdown/kit/prose/model';
 import { Plugin, PluginKey } from '@milkdown/kit/prose/state';
+import { isImageBlock } from './image-blocks.js';
 import { fromMarkdown } from 'mdast-util-from-markdown';
 const lineEnding = (code) => code === -3 || code === -4 || code === -5;
 const whitespace = (code) => code === 32 || code === -1 || code === -2;
@@ -418,6 +419,12 @@ export function shareableFragment(content) {
     content.forEach((node) => {
         if (isComment(node))
             return;
+        // Shared output treats a standalone image as the paragraph its Markdown holds.
+        if (isImageBlock(node)) {
+            const { paragraph, image } = node.type.schema.nodes;
+            filtered.push(paragraph.create(null, image.create(node.attrs)));
+            return;
+        }
         if (node.type.name === 'reference_definition' &&
             labelHasComments(node.attrs.label))
             return;

package/dist/dialect.js

@@ -8,6 +8,7 @@ import { linkedSyntax, wikiLinkSchema, namedFileMarkdown, fileReference, } from
 import { normalizeTableAlignment, normalizeTableColumnAlignment, } from './table-alignment.js';
 import { preservingCodeBlocks, remarkCodeFences, fencedCodeHandler, } from './code-fences.js';
 import { literalBlock, createLiteralPreservation } from './literals.js';
+import { imageAttrs, imageBlocks, markdownImageAttrs, readParagraph, } from './image-blocks.js';
 import { references, remarkReferencesPlugin } from './references.js';
 import { callouts, remarkCalloutsPlugin } from './callouts.js';
 import { inlineHighlight } from './inline-highlight.js';
@@ -110,6 +111,12 @@ const preserveSpacerParagraphs = paragraphSchema.extendSchema((base) => (ctx) =>
     const schema = base(ctx);
     return {
         ...schema,
+        parseMarkdown: {
+            ...schema.parseMarkdown,
+            runner(state, node, type) {
+                readParagraph(state, node, type);
+            },
+        },
         toMarkdown: {
             ...schema.toMarkdown,
             runner(state, node) {
@@ -174,19 +181,11 @@ const visibleSoftbreaks = hardbreakSchema.extendSchema((base) => (ctx) => {
             ],
     };
 });
-// Remark represents a missing title as null; the image schema accepts strings.
 const normalizedImages = imageSchema.extendSchema((base) => (ctx) => {
     const schema = base(ctx);
     return {
         ...schema,
-        attrs: {
-            ...schema.attrs,
-            inkkitFileRaw: { default: null },
-            inkkitFileTarget: { default: null },
-            inkkitFileFragment: { default: null },
-            inkkitFileWidth: { default: null },
-            inkkitFileInTable: { default: false },
-        },
+        attrs: imageAttrs,
         parseDOM: [
             {
                 tag: 'img[src]',
@@ -202,16 +201,7 @@ const normalizedImages = imageSchema.extendSchema((base) => (ctx) => {
         parseMarkdown: {
             ...schema.parseMarkdown,
             runner(state, node, type) {
-                state.addNode(type, {
-                    src: String(node.url ?? ''),
-                    alt: String(node.alt ?? ''),
-                    title: String(node.title ?? ''),
-                    inkkitFileRaw: node.inkkitFileRaw ?? null,
-                    inkkitFileTarget: node.inkkitFileTarget ?? null,
-                    inkkitFileFragment: node.inkkitFileFragment ?? null,
-                    inkkitFileWidth: node.inkkitFileWidth ?? null,
-                    inkkitFileInTable: node.inkkitFileInTable ?? false,
-                });
+                state.addNode(type, markdownImageAttrs(node));
             },
         },
         toMarkdown: {
@@ -324,6 +314,7 @@ export function createDialect(images, wikiLinks = false, files = false) {
         preserveSpacerParagraphs,
         visibleSoftbreaks,
         normalizedImages,
+        imageBlocks,
         autolinkInputRule,
         extendListItemSchemaForTask,
         strikethroughAttr,

package/dist/editor.d.ts

@@ -179,6 +179,9 @@ export declare class InkKitEditor {
         focus?: boolean;
         reveal?: boolean;
     }): void;
+    /** Throws when a document reached by an edit, after every appended normalisation, cannot be
+     *  saved as preserved Markdown. Dispatch and the replacement commands share this check. */
+    private assertPreserved;
     replaceTextRange(range: TextRange, text: string): boolean;
     textRangeRects(range: TextRange): readonly TextRect[];
     textRangesRects(ranges: readonly TextRange[]): readonly (readonly TextRect[])[];

package/dist/editor.js

@@ -21,6 +21,8 @@ import { sourceAttribute, cleanSourceDoc, editedPlainSource, sourceSelection, ra
 import { normaliseLabel, referenceDefinitions, footnoteDefinitions, } from './references.js';
 import { selectionMarkdown, selectionContent, referenceMetadata, withReferenceMetadata, } from './reference-clipboard.js';
 import { imageView } from './images.js';
+import { isImage, isImageBlock } from './image-blocks.js';
+import { GapCursor } from '@milkdown/kit/prose/gapcursor';
 import { wikiLinkView } from './wiki-view.js';
 import { withFileSignal } from './files.js';
 import { tablePlugins, tableCommand, tableCommands, tableAvailability, tableContext, configureTableMovement, } from './tables.js';
@@ -991,7 +993,7 @@ export class InkKitEditor {
             const parsed = this.editor.ctx.get(parserCtx)(selected.shareable);
             let portable = false;
             parsed.descendants((node) => {
-                if (node.type.name === 'image' || isMermaid(node))
+                if (isImage(node) || isMermaid(node))
                     portable = true;
             });
             const cut = event.type === 'cut' && this.writable;
@@ -1091,13 +1093,9 @@ export class InkKitEditor {
                 ...options,
                 dispatchTransaction: function (tr) {
                     const next = this.state.apply(tr);
-                    if (!instance.loading &&
-                        instance.preservation &&
-                        !instance.literalSurface &&
-                        !next.doc.eq(this.state.doc)) {
+                    if (!instance.loading) {
                         try {
-                            // Validate the final state, including dialect normalisation transactions.
-                            instance.currentText(next.doc);
+                            instance.assertPreserved(this.state.doc, next.doc);
                         }
                         catch (error) {
                             this.updateState(this.state);
@@ -1319,7 +1317,7 @@ export class InkKitEditor {
             const expanded = selectionContent(view.state.doc, fragment);
             let hasImages = false;
             expanded.descendants((node) => {
-                if (node.type.name === 'image' || isMermaid(node))
+                if (isImage(node) || isMermaid(node))
                     hasImages = true;
             });
             if (!hasImages) {
@@ -1606,6 +1604,12 @@ export class InkKitEditor {
             this.revealTextRange(range);
         this.publishCommandState();
     }
+    /** Throws when a document reached by an edit, after every appended normalisation, cannot be
+     *  saved as preserved Markdown. Dispatch and the replacement commands share this check. */
+    assertPreserved(before, after) {
+        if (this.preservation && !this.literalSurface && !after.eq(before))
+            this.currentText(after);
+    }
     replaceTextRange(range, text) {
         const projection = this.validateTextRange(range);
         this.assertMutation();
@@ -1631,9 +1635,8 @@ export class InkKitEditor {
             throw new InkKitError('invalid-range', 'Replacement cannot remove embedded content or structural separators');
         const from = projectionPosition(projection, range.from, 1);
         const to = projectionPosition(projection, range.to, range.from === range.to ? 1 : -1);
-        return replaceFormattedRange(this.editor.ctx.get(editorViewCtx), from, to, text, (doc) => {
-            this.currentText(doc);
-        });
+        const view = this.editor.ctx.get(editorViewCtx);
+        return replaceFormattedRange(view, from, to, text, (tr) => this.assertPreserved(view.state.doc, view.state.apply(tr).doc));
     }
     textRangeRects(range) {
         return this.textRangesRects([range])[0];
@@ -1804,10 +1807,12 @@ export class InkKitEditor {
         const view = this.editor.ctx.get(editorViewCtx);
         // A caret at the end, where writing carries on; at the start it would sit in a first-line heading and
         // show its marks. The last place text can go, so a document ending in a rule takes a caret above it
-        // rather than selecting the rule itself.
+        // rather than selecting the rule itself. After a final image, typing opens a paragraph below it.
         const { doc } = view.state;
-        const end = Selection.findFrom(doc.resolve(doc.content.size), -1, true) ??
-            Selection.atEnd(doc);
+        const $end = doc.resolve(doc.content.size);
+        const end = isImageBlock(doc.lastChild)
+            ? new GapCursor($end)
+            : (Selection.findFrom($end, -1, true) ?? Selection.atEnd(doc));
         view.dispatch(setSearchState(view.state.tr.setSelection(end), new SearchQuery({ search: '' })));
     }
     find(text, expectedGeneration) {
@@ -1875,9 +1880,8 @@ export class InkKitEditor {
             this.plainSearch = search;
             return result.count;
         }
-        return replaceFormatted(this.editor.ctx.get(editorViewCtx), search, replacement, (doc) => {
-            this.currentText(doc);
-        }, all);
+        const view = this.editor.ctx.get(editorViewCtx);
+        return replaceFormatted(view, search, replacement, (tr) => this.assertPreserved(view.state.doc, view.state.apply(tr).doc), all);
     }
     outlineContext() {
         return {
@@ -2098,22 +2102,34 @@ export class InkKitEditor {
             throw new InkKitError('image-unavailable', 'This editor has no image adapter');
         const view = this.editor.ctx.get(editorViewCtx);
         const { schema } = view.state;
-        const nodes = images.map((image) => schema.nodes.image.create({
+        // One paragraph per image: each is read back as a standalone image block where one fits.
+        const blocks = images.map((image) => schema.nodes.paragraph.create(null, schema.nodes.image.create({
             src: image.path,
             alt: image.alt,
             title: image.title ?? '',
-        }));
-        if (x != null && y != null)
-            this.insertBlocks(nodes.map((node) => schema.nodes.paragraph.create(null, node)), x, y);
-        else
-            view.dispatch(view.state.tr
-                .replaceSelectionWith(schema.nodes.paragraph.create(null, nodes))
-                .scrollIntoView());
+        })));
+        if (x != null && y != null) {
+            this.insertBlocks(blocks, x, y);
+            return;
+        }
+        const tr = view.state.tr.replaceSelection(new Slice(Fragment.fromArray(blocks), 0, 0));
+        // After the last image, so typing continues below it rather than in the block that follows.
+        const last = blocks.at(-1).firstChild;
+        let after;
+        tr.doc.descendants((node, pos) => {
+            if (node === last)
+                after = pos + node.nodeSize;
+            return after == null;
+        });
+        if (after != null)
+            tr.setSelection(TextSelection.create(tr.doc, after));
+        view.dispatch(tr.scrollIntoView());
     }
     insertBlocks(blocks, x, y) {
         const view = this.editor.ctx.get(editorViewCtx);
         const { state } = view;
-        const $pos = state.doc.resolve(view.posAtCoords({ left: x, top: y })?.pos ?? state.selection.from);
+        const hit = view.posAtCoords({ left: x, top: y });
+        const $pos = state.doc.resolve(hit?.pos ?? state.selection.from);
         const tr = state.tr;
         let at;
         if ($pos.depth === 1 &&
@@ -2123,7 +2139,16 @@ export class InkKitEditor {
             tr.replaceWith(at, $pos.after(1), blocks);
         }
         else {
-            at = $pos.depth > 0 ? $pos.after(1) : $pos.pos;
+            // A point over a top-level leaf, such as an image, resolves beside it rather than inside.
+            const leaf = $pos.depth === 0 && hit && hit.inside >= 0
+                ? state.doc.resolve(hit.inside)
+                : undefined;
+            at =
+                $pos.depth > 0
+                    ? $pos.after(1)
+                    : leaf?.depth === 0
+                        ? hit.inside + state.doc.nodeAt(hit.inside).nodeSize
+                        : $pos.pos;
             tr.insert(at, blocks);
         }
         const end = at + blocks.reduce((size, node) => size + node.nodeSize, 0) - 1;

package/dist/highlight.js

@@ -5,41 +5,128 @@ import { $prose } from '@milkdown/kit/utils';
 const lowlight = createLowlight(common);
 // Colors are decorations over the plain text, so the markdown is untouched;
 // a block without a known language stays plain.
+function blockDecorations(node, pos) {
+    const language = String(node.attrs.language ?? '').toLowerCase();
+    const found = [];
+    if (!language || !lowlight.registered(language))
+        return found;
+    let offset = pos + 1;
+    const walk = (children, classes) => {
+        for (const child of children) {
+            if (child.type === 'text') {
+                const end = offset + child.value.length;
+                if (classes.length > 0)
+                    found.push(Decoration.inline(offset, end, { class: classes.join(' ') }));
+                offset = end;
+            }
+            else if (child.type === 'element') {
+                const own = child.properties?.className ?? [];
+                walk(child.children, [...classes, ...own]);
+            }
+        }
+    };
+    walk(lowlight.highlight(language, node.textContent).children, []);
+    return found;
+}
 function decorations(doc) {
     const found = [];
     doc.descendants((node, pos) => {
-        if (node.type.name !== 'code_block')
+        if (!node.isTextblock)
             return true;
-        const language = String(node.attrs.language ?? '').toLowerCase();
-        if (!language || !lowlight.registered(language))
-            return false;
-        let offset = pos + 1;
-        const walk = (children, classes) => {
-            for (const child of children) {
-                if (child.type === 'text') {
-                    const end = offset + child.value.length;
-                    if (classes.length > 0)
-                        found.push(Decoration.inline(offset, end, { class: classes.join(' ') }));
-                    offset = end;
-                }
-                else if (child.type === 'element') {
-                    const own = child.properties?.className ?? [];
-                    walk(child.children, [...classes, ...own]);
-                }
-            }
-        };
-        walk(lowlight.highlight(language, node.textContent).children, []);
+        if (node.type.name === 'code_block')
+            for (const decoration of blockDecorations(node, pos))
+                found.push(decoration);
         return false;
     });
     return DecorationSet.create(doc, found);
 }
+// Every range of the new document an update may have touched: each step's own
+// range, plus the whole span where the two documents differ, which also covers
+// steps that change a node without changing its size.
+function touched(tr) {
+    const ranges = [];
+    tr.mapping.maps.forEach((map, index) => {
+        const rest = tr.mapping.slice(index + 1);
+        map.forEach((_, __, from, to) => ranges.push([rest.map(from, -1), rest.map(to, 1)]));
+    });
+    const start = tr.before.content.findDiffStart(tr.doc.content);
+    if (start != null) {
+        const end = tr.before.content.findDiffEnd(tr.doc.content);
+        // The scans overlap when inserted or deleted text repeats its neighbours.
+        if (end)
+            ranges.push([start, end.b + Math.max(0, start - Math.min(end.a, end.b))]);
+    }
+    return ranges;
+}
+// Mapping carries colors of unchanged blocks to their new positions without
+// reading them, but leaves stale colors inside any block that was edited. Those
+// blocks are highlighted again; no other block is. Stale colors are dropped by
+// rebuilding the set: DecorationSet.remove compares every removed decoration
+// with every other in its block, which is quadratic in a large block.
+function update(mapped, tr) {
+    const stale = [];
+    const fresh = [];
+    const seen = new Set();
+    for (const [from, to] of touched(tr)) {
+        let start = from;
+        let end = to;
+        const blocks = [];
+        tr.doc.nodesBetween(from, to, (node, pos) => {
+            if (!node.isTextblock)
+                return true;
+            start = Math.min(start, pos);
+            end = Math.max(end, pos + node.nodeSize);
+            if (node.type.name === 'code_block' && !seen.has(pos)) {
+                seen.add(pos);
+                blocks.push([node, pos]);
+            }
+            return false;
+        });
+        stale.push([start, end]);
+        for (const [node, pos] of blocks)
+            for (const decoration of blockDecorations(node, pos))
+                fresh.push(decoration);
+    }
+    const found = [];
+    for (const [start, end] of stale)
+        for (const decoration of mapped.find(start, end))
+            found.push(decoration);
+    if (found.length === 0)
+        return mapped.add(tr.doc, fresh);
+    // remove is quadratic in the decorations it removes, so only a large block takes the rebuild below.
+    if (found.length <= 256)
+        return mapped.remove(found).add(tr.doc, fresh);
+    stale.sort((a, b) => a[0] - b[0]);
+    const merged = [];
+    for (const range of stale) {
+        const last = merged.at(-1);
+        if (last && range[0] <= last[1])
+            last[1] = Math.max(last[1], range[1]);
+        else
+            merged.push([range[0], range[1]]);
+    }
+    const kept = mapped.find().filter((decoration) => {
+        let low = 0;
+        let high = merged.length;
+        while (low < high) {
+            const middle = (low + high) >> 1;
+            if (merged[middle][0] < decoration.to)
+                low = middle + 1;
+            else
+                high = middle;
+        }
+        const range = merged[low - 1];
+        return !range || range[1] <= decoration.from;
+    });
+    return DecorationSet.create(tr.doc, kept.concat(fresh));
+}
 export const highlightPlugin = $prose(() => new Plugin({
     key: new PluginKey('highlight'),
     state: {
         init: (_, state) => decorations(state.doc),
         apply: (tr, previous) => tr.docChanged
-            ? decorations(tr.doc)
-            : previous.map(tr.mapping, tr.doc),
+            ? update(previous.map(tr.mapping, tr.doc), tr)
+            : previous,
     },
     props: {
         decorations(state) {

package/dist/image-blocks.d.ts

@@ -0,0 +1,71 @@
+import type { MilkdownPlugin } from '@milkdown/kit/ctx';
+import { type Node as ProseNode, type NodeType } from '@milkdown/kit/prose/model';
+import type { ParserState } from '@milkdown/kit/transformer';
+export declare const imageBlockName = "image_block";
+/** Attributes shared by an inline image and a standalone image block. */
+export declare const imageAttrs: {
+    src: {
+        default: string;
+        validate: string;
+    };
+    alt: {
+        default: string;
+        validate: string;
+    };
+    title: {
+        default: string;
+        validate: string;
+    };
+    inkkitFileRaw: {
+        default: null;
+    };
+    inkkitFileTarget: {
+        default: null;
+    };
+    inkkitFileFragment: {
+        default: null;
+    };
+    inkkitFileWidth: {
+        default: null;
+    };
+    inkkitFileInTable: {
+        default: boolean;
+    };
+};
+interface MarkdownParagraph {
+    children?: unknown[];
+    value?: unknown;
+}
+interface MarkdownImage {
+    type: string;
+    url?: unknown;
+    alt?: unknown;
+    title?: unknown;
+    inkkitFileRaw?: unknown;
+    inkkitFileTarget?: unknown;
+    inkkitFileFragment?: unknown;
+    inkkitFileWidth?: unknown;
+    inkkitFileInTable?: unknown;
+}
+export declare function markdownImageAttrs(node: MarkdownImage): {
+    src: string;
+    alt: string;
+    title: string;
+    inkkitFileRaw: {} | null;
+    inkkitFileTarget: {} | null;
+    inkkitFileFragment: {} | null;
+    inkkitFileWidth: {} | null;
+    inkkitFileInTable: {};
+};
+/** Whether a node displays an authored image, inline or as its own block. */
+export declare function isImage(node: ProseNode): boolean;
+export declare function isImageBlock(node: ProseNode | null | undefined): boolean;
+/** The image a paragraph holds as its only content, without marks, which makes the paragraph a
+ *  standalone image block. A linked or emphasised image stays inline so its marks are kept. */
+export declare function standaloneImage(children: readonly ProseNode[]): ProseNode | undefined;
+/** Reads a Markdown paragraph, as an image block when it holds a standalone image and the enclosing
+ *  block accepts one. */
+export declare function readParagraph(state: ParserState, node: MarkdownParagraph, paragraph: NodeType): void;
+export declare const imageBlockSchema: import("@milkdown/kit/utils").$NodeSchema<"image_block">;
+export declare const imageBlocks: MilkdownPlugin[];
+export {};