@aicayzer/inkkit 0.0.4 → 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/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';
@@ -27,6 +27,7 @@ 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],
@@ -334,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;

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, ClipboardDiagram, } 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/print.d.ts

@@ -0,0 +1,7 @@
+import type { Fragment, Schema } from '@milkdown/kit/prose/model';
+import { type DocumentContext, type ImageAdapter, type PrintableDocument } from './types.js';
+type PrintableContent = Pick<PrintableDocument, 'html' | 'styles' | 'assets' | 'warnings'>;
+export declare function printableText(text: string): PrintableContent;
+export declare function hasAuthoredImagesInLiterals(content: Fragment, parse: (source: string) => unknown): boolean;
+export declare function printableMarkdown(content: Fragment, schema: Schema, adapter: ImageAdapter | undefined, context: DocumentContext): Promise<PrintableContent>;
+export {};

package/dist/print.js

@@ -0,0 +1,377 @@
+import { clipboardContent } from './clipboard.js';
+import { shareableFragment } from './comments.js';
+import { splitAlt } from './images.js';
+import { sourceFrontmatter } from './literals.js';
+import { diagramImage, renderDiagram } from './mermaid.js';
+import { InkKitError, } from './types.js';
+const styles = `
+:root { color-scheme: light; font: 11pt/1.5 Arial, sans-serif; }
+html, body { margin: 0; padding: 0; height: auto; overflow: visible; background: white; color: #222; }
+.inkkit-print-document { padding: 1rem; overflow-wrap: anywhere; }
+h1, h2, h3, h4, h5, h6 { line-height: 1.25; break-after: avoid; }
+p, ul, ol, blockquote, pre, table, figure { margin-block: 0 1em; }
+li > p { margin-bottom: .35em; }
+li > ul, li > ol { margin-bottom: .35em; }
+a { color: inherit; text-decoration: underline; }
+mark { color: inherit; background: #fff0a8; print-color-adjust: exact; }
+code, pre { font-family: ui-monospace, Menlo, monospace; }
+pre { white-space: pre-wrap; overflow-wrap: anywhere; overflow: visible; padding: .65em; border: 1px solid #ddd; font-size: .9em; }
+.inkkit-print-literal { padding: 0; border: 0; font-size: 1em; tab-size: 4; }
+blockquote { margin-inline: 0; padding-inline-start: 1em; border-inline-start: 3px solid #aaa; }
+.inkkit-callout { padding: .65em 1em; border-inline-start: 3px solid #777; }
+.inkkit-callout-title { display: block; margin-bottom: .4em; }
+.inkkit-callout-body { display: block; }
+.inkkit-print-footnote { border-inline-start: 2px solid #aaa; padding-inline-start: 1em; margin-bottom: 1em; }
+sup { font-size: .75em; }
+.inkkit-print-task-marker { font-family: ui-monospace, Menlo, monospace; }
+table { width: 100%; border-collapse: collapse; table-layout: fixed; font-size: .95em; }
+th, td { border: 1px solid #aaa; padding: .4em .6em; vertical-align: top; overflow-wrap: anywhere; }
+th { font-weight: bold; }
+th p, td p { margin: 0; }
+thead { display: table-header-group; }
+tfoot { display: table-footer-group; }
+tr { break-inside: avoid; }
+img { max-width: 100%; height: auto; }
+figure { margin-inline: 0; }
+.inkkit-print-diagram img { display: block; }
+figure, img { break-inside: avoid; }
+hr { border: 0; border-top: 1px solid #aaa; }
+@page { margin: 18mm; }
+@media print {
+  .inkkit-print-document { padding: 0; }
+  img { max-height: 90vh; object-fit: contain; }
+}
+`.trim();
+function documentOutput(content, assets = [], warnings = []) {
+    const page = document.implementation.createHTMLDocument('');
+    page.head.textContent = '';
+    const charset = page.createElement('meta');
+    charset.setAttribute('charset', 'utf-8');
+    const style = page.createElement('style');
+    style.textContent = styles;
+    page.head.append(charset, style);
+    const main = page.createElement('main');
+    main.className = 'inkkit-print-document';
+    while (content.firstChild)
+        main.appendChild(content.firstChild);
+    page.body.append(main);
+    return {
+        html: '<!DOCTYPE html>\n' + page.documentElement.outerHTML,
+        styles,
+        assets,
+        warnings,
+    };
+}
+export function printableText(text) {
+    const container = document.createElement('div');
+    const pre = document.createElement('pre');
+    pre.className = 'inkkit-print-literal';
+    pre.textContent = text;
+    container.append(pre);
+    return documentOutput(container);
+}
+export function hasAuthoredImagesInLiterals(content, parse) {
+    const hasImage = (value) => {
+        if (!value || typeof value !== 'object')
+            return false;
+        const node = value;
+        if (node.type === 'image')
+            return true;
+        if (['html', 'code', 'inlineCode', 'imageReference'].includes(String(node.type)))
+            return false;
+        return Array.isArray(node.children) && node.children.some(hasImage);
+    };
+    let found = false;
+    shareableFragment(content).descendants((node) => {
+        if (found)
+            return false;
+        if (node.type.name !== 'literal_markdown')
+            return true;
+        const source = node.textContent.replace(/^\uFEFF/, '');
+        const body = source.slice(sourceFrontmatter(source)?.length ?? 0);
+        if (body && hasImage(parse(body)))
+            found = true;
+        return false;
+    });
+    return found;
+}
+function matchesSignature(bytes, mimeType) {
+    const ascii = (start, end) => String.fromCharCode(...bytes.subarray(start, end));
+    switch (mimeType) {
+        case 'image/png':
+            return (bytes.length >= 24 &&
+                [137, 80, 78, 71, 13, 10, 26, 10].every((byte, index) => bytes[index] === byte) &&
+                ascii(12, 16) === 'IHDR');
+        case 'image/jpeg':
+            return (bytes.length >= 4 &&
+                bytes[0] === 255 &&
+                bytes[1] === 216 &&
+                bytes[2] === 255);
+        case 'image/gif':
+            return bytes.length >= 10 && /^(GIF87a|GIF89a)$/.test(ascii(0, 6));
+        case 'image/webp':
+            return (bytes.length >= 12 && ascii(0, 4) === 'RIFF' && ascii(8, 12) === 'WEBP');
+        case 'image/avif':
+            return (bytes.length >= 16 &&
+                ascii(4, 8) === 'ftyp' &&
+                /avif|avis/.test(ascii(8, 32)));
+        case 'image/bmp':
+            return bytes.length >= 26 && ascii(0, 2) === 'BM';
+        case 'image/tiff':
+            return (bytes.length >= 8 &&
+                (ascii(0, 4) === 'II*\0' || ascii(0, 4) === 'MM\0*'));
+        default:
+            return false;
+    }
+}
+async function validatedImage(input) {
+    const image = {
+        bytes: new Uint8Array(input.bytes),
+        mimeType: input.mimeType.toLowerCase(),
+    };
+    if (!matchesSignature(image.bytes, image.mimeType))
+        throw new Error('The portable image bytes do not match a supported image format.');
+    const url = URL.createObjectURL(new Blob([image.bytes], { type: image.mimeType }));
+    try {
+        await new Promise((resolve, reject) => {
+            const decoder = new Image();
+            const timeout = setTimeout(() => {
+                decoder.onload = decoder.onerror = null;
+                decoder.removeAttribute('src');
+                reject(new Error('The portable image could not be decoded.'));
+            }, 10000);
+            const finish = (error) => {
+                clearTimeout(timeout);
+                decoder.onload = decoder.onerror = null;
+                if (error)
+                    reject(error);
+                else
+                    resolve();
+            };
+            decoder.onload = () => finish(decoder.naturalWidth > 0 && decoder.naturalHeight > 0
+                ? undefined
+                : new Error('The portable image has no usable dimensions.'));
+            decoder.onerror = () => finish(new Error('The portable image could not be decoded.'));
+            decoder.src = url;
+        });
+        return image;
+    }
+    finally {
+        URL.revokeObjectURL(url);
+    }
+}
+function dataURL(image) {
+    let binary = '';
+    for (const byte of image.bytes)
+        binary += String.fromCharCode(byte);
+    return `data:${image.mimeType};base64,${btoa(binary)}`;
+}
+const semanticTags = new Set([
+    'DIV',
+    'P',
+    'SPAN',
+    'STRONG',
+    'EM',
+    'DEL',
+    'S',
+    'MARK',
+    'A',
+    'SUP',
+    'SUB',
+    'PRE',
+    'CODE',
+    'BLOCKQUOTE',
+    'H1',
+    'H2',
+    'H3',
+    'H4',
+    'H5',
+    'H6',
+    'UL',
+    'OL',
+    'LI',
+    'TABLE',
+    'THEAD',
+    'TBODY',
+    'TFOOT',
+    'TR',
+    'TH',
+    'TD',
+    'HR',
+    'BR',
+    'IMG',
+    'FIGURE',
+    'FIGCAPTION',
+]);
+const printClasses = new Set([
+    'inkkit-callout',
+    'inkkit-callout-title',
+    'inkkit-callout-body',
+    'inkkit-print-footnote',
+    'inkkit-print-task-marker',
+    'inkkit-print-diagram',
+]);
+function safeLink(value) {
+    if (/[\u0000-\u001f\u007f\\]/.test(value))
+        return undefined;
+    const href = value.trim();
+    if (!href)
+        return undefined;
+    // A colon in the first path component denotes a scheme, including an
+    // obfuscated one. Relative paths can still contain colons after a slash.
+    if (/^[^/?#]*:/.test(href) && !/^(https?:|mailto:)/i.test(href))
+        return undefined;
+    return href.replaceAll(' ', '%20');
+}
+function cleanSemantics(container, localIDs) {
+    for (const element of container.querySelectorAll('*')) {
+        if (!semanticTags.has(element.tagName)) {
+            if (/^(SCRIPT|STYLE|LINK|META|IFRAME|OBJECT|EMBED|BUTTON|INPUT|TEXTAREA|SELECT)$/.test(element.tagName))
+                element.remove();
+            else
+                element.replaceWith(...Array.from(element.childNodes));
+            continue;
+        }
+        const classes = Array.from(element.classList).filter((name) => printClasses.has(name));
+        const href = element.tagName === 'A' ? element.getAttribute('href') : null;
+        const src = element.tagName === 'IMG' ? element.getAttribute('src') : null;
+        const alt = element.tagName === 'IMG' ? element.getAttribute('alt') : null;
+        const width = element.tagName === 'IMG' ? element.getAttribute('width') : null;
+        const title = element.getAttribute('title');
+        const id = element.getAttribute('id');
+        const order = element.tagName === 'OL' ? element.getAttribute('start') : null;
+        const alignment = element instanceof HTMLElement ? element.style.textAlign : '';
+        for (const attribute of [...element.attributes])
+            element.removeAttribute(attribute.name);
+        if (classes.length)
+            element.setAttribute('class', classes.join(' '));
+        const destination = href == null ? undefined : safeLink(href);
+        if (destination != null)
+            element.setAttribute('href', destination);
+        if (src &&
+            /^data:image\/(png|jpeg|gif|webp|avif|bmp|tiff);base64,[A-Za-z0-9+/=]+$/.test(src))
+            element.setAttribute('src', src);
+        if (alt != null)
+            element.setAttribute('alt', alt);
+        if (width && /^\d+$/.test(width))
+            element.setAttribute('width', width);
+        if (title)
+            element.setAttribute('title', title);
+        if (id && localIDs.has(id))
+            element.setAttribute('id', id);
+        if (order && /^\d+$/.test(order))
+            element.setAttribute('start', order);
+        if (/^(left|center|right)$/.test(alignment) &&
+            /^(TH|TD)$/.test(element.tagName))
+            element.setAttribute('style', `text-align: ${alignment}`);
+    }
+    const walker = document.createTreeWalker(container, NodeFilter.SHOW_COMMENT);
+    const comments = [];
+    while (walker.nextNode())
+        comments.push(walker.currentNode);
+    for (const comment of comments)
+        comment.parentNode?.removeChild(comment);
+}
+export async function printableMarkdown(content, schema, adapter, context) {
+    content = shareableFragment(content);
+    const container = document.createElement('div');
+    container.innerHTML = clipboardContent(content, schema).html;
+    const references = [];
+    const tasks = [];
+    content.descendants((node) => {
+        if (node.type.name === 'image')
+            references.push({
+                reference: String(node.attrs.src ?? ''),
+                ...splitAlt(String(node.attrs.alt ?? '')),
+            });
+        if (node.type.name === 'list_item')
+            tasks.push(node.attrs.checked ?? null);
+    });
+    for (const [index, item] of [...container.querySelectorAll('li')].entries()) {
+        if (tasks[index] == null)
+            continue;
+        const marker = document.createElement('span');
+        marker.className = 'inkkit-print-task-marker';
+        marker.textContent = tasks[index] ? '[x] ' : '[ ] ';
+        (item.firstElementChild?.tagName === 'P'
+            ? item.firstElementChild
+            : item).prepend(marker);
+    }
+    const footnotes = new Map();
+    const localIDs = new Set();
+    for (const [index, definition] of [
+        ...container.querySelectorAll('[data-inkkit-footnote-definition]'),
+    ].entries()) {
+        const identifier = definition.getAttribute('data-inkkit-footnote-definition');
+        const id = `inkkit-print-note-${index + 1}`;
+        localIDs.add(id);
+        if (!footnotes.has(identifier))
+            footnotes.set(identifier, id);
+        definition.setAttribute('id', id);
+        definition.className = 'inkkit-print-footnote';
+    }
+    for (const reference of container.querySelectorAll('[data-inkkit-footnote-reference]')) {
+        const id = footnotes.get(reference.getAttribute('data-inkkit-footnote-reference'));
+        if (!id)
+            continue;
+        const link = document.createElement('a');
+        link.setAttribute('href', `#${id}`);
+        link.textContent = reference.textContent;
+        reference.replaceChildren(link);
+    }
+    const images = new Map();
+    for (const [index, element] of [
+        ...container.querySelectorAll('img'),
+    ].entries()) {
+        const reference = references[index];
+        try {
+            if (!adapter || !reference)
+                throw new Error('The authored image is unavailable.');
+            const image = await validatedImage(await adapter.exportImage(reference.reference, { ...context }));
+            images.set(element, image);
+            element.setAttribute('src', dataURL(image));
+            element.setAttribute('alt', reference.alt);
+            if (reference.width != null && reference.width > 0)
+                element.setAttribute('width', String(Math.min(4096, reference.width)));
+        }
+        catch (error) {
+            throw new InkKitError('image-unavailable', error instanceof Error
+                ? error.message
+                : 'The authored image is unavailable.');
+        }
+    }
+    const warnings = [];
+    for (const code of container.querySelectorAll('pre[data-language="mermaid"] > code')) {
+        const source = code.textContent ?? '';
+        try {
+            await renderDiagram(source);
+        }
+        catch (error) {
+            const message = `${error instanceof Error ? error.message : 'This diagram could not be rendered.'} The source is printed below.`;
+            warnings.push({ code: 'diagram-unavailable', message });
+            const warning = document.createElement('p');
+            warning.textContent = message;
+            code.parentElement.before(warning);
+            continue;
+        }
+        try {
+            const image = await validatedImage(await diagramImage(source));
+            const figure = document.createElement('figure');
+            figure.className = 'inkkit-print-diagram';
+            const element = document.createElement('img');
+            element.setAttribute('src', dataURL(image));
+            element.setAttribute('alt', 'Mermaid diagram');
+            figure.append(element);
+            images.set(element, image);
+            code.parentElement.replaceWith(figure);
+        }
+        catch (error) {
+            throw new InkKitError('diagram-unavailable', error instanceof Error
+                ? error.message
+                : 'The diagram image is unavailable.');
+        }
+    }
+    cleanSemantics(container, localIDs);
+    const assets = [...container.querySelectorAll('img')].map((element) => images.get(element));
+    return documentOutput(container, assets, warnings);
+}

package/dist/types.d.ts

@@ -64,3 +64,17 @@ export interface ClipboardDiagram {
     image?: PortableImage;
     error?: string;
 }
+export interface PrintableWarning {
+    code: 'diagram-unavailable';
+    message: string;
+}
+export interface PrintableDocument {
+    documentId: string;
+    generation: number;
+    revision: number;
+    format: DocumentFormat;
+    html: string;
+    styles: string;
+    assets: readonly PortableImage[];
+    warnings: readonly PrintableWarning[];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aicayzer/inkkit",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "A preserving Markdown editor for offline web views and the web",
   "license": "MIT",
   "type": "module",