@aicayzer/inkkit 0.0.17 → 0.1.0

package/dist/mermaid.js

@@ -1,321 +0,0 @@
-import { editorLabels } from './labels.js';
-import DOMPurify from 'dompurify';
-import { Plugin, PluginKey } from '@milkdown/kit/prose/state';
-import { Decoration, DecorationSet } from '@milkdown/kit/prose/view';
-import { $prose } from '@milkdown/kit/utils';
-import { InkKitError } from './types.js';
-export function isMermaid(node) {
-    return node.type.name === 'code_block' && node.attrs.language === 'mermaid';
-}
-const refusal = 'HTML, styles, actions, resources and diagram configuration are disabled. The source is retained.';
-// CSS functions that can load an image or display another element. Mermaid's
-// own styles use none of them apart from url() for in-document markers.
-const cssResource = /url\s*\(\s*[^#\s]|(?:image-set|cross-fade|image|element|src)\s*\(/i;
-export function validateDiagram(source) {
-    if (source.length > 30000)
-        throw new Error('The diagram exceeds the 30,000 character rendering limit.');
-    if (!/^\s*(?:%%[^\n]*\n\s*)*(?:flowchart|graph|sequenceDiagram|classDiagram|stateDiagram(?:-v2)?|erDiagram|pie)\b/.test(source))
-        throw new Error('This diagram type is not supported. The source is retained.');
-    // Mermaid can load image bytes before sanitising its result, so resource and
-    // configuration syntax is refused anywhere in the source, labels included.
-    // Statements are checked separately, in Mermaid's parse result.
-    if (/%%\{|^\s*---|<\s*[a-z!/?]|&(?:#\w+|[a-z]+);|@\{|\$\$|(?:https?|data|file|javascript|vbscript|blob):|\/\/|url\s*\(|image-set\s*\(|cross-fade\s*\(|@import|\\/im.test(source))
-        throw new Error(refusal);
-}
-const entries = (value) => value instanceof Map ? [...value.values()] : Array.isArray(value) ? value : [];
-const filled = (value) => value instanceof Map
-    ? value.size > 0
-    : Array.isArray(value)
-        ? value.length > 0
-        : typeof value === 'object' && value !== null
-            ? Object.keys(value).length > 0
-            : Boolean(value);
-// In strict mode a flowchart records a click handler only as this class.
-const clickable = (classes) => (Array.isArray(classes) ? classes : String(classes ?? '').split(/\s+/))
-    .map(String)
-    .includes('clickable');
-function statementIn(node, kinds, seen = new Set()) {
-    if (typeof node !== 'object' || node === null || seen.has(node))
-        return false;
-    seen.add(node);
-    if (kinds.includes(String(node.stmt)))
-        return true;
-    return Object.values(node).some((value) => statementIn(value, kinds, seen));
-}
-// Refuses styles, class definitions, link styles, links, click handlers,
-// tooltips, icons and images wherever the grammar accepted them. The names are
-// those of the pinned Mermaid's diagram databases; if one is missing, the
-// diagram is refused rather than passed unchecked.
-function refuseDirectives({ type, db }) {
-    const store = db;
-    const field = (name) => {
-        if (!(name in store))
-            throw new Error('The diagram could not be checked. The source is retained.');
-        return store[name];
-    };
-    const read = (name) => {
-        const accessor = field(name);
-        if (typeof accessor !== 'function')
-            throw new Error('The diagram could not be checked. The source is retained.');
-        return accessor.call(db);
-    };
-    let found;
-    switch (type) {
-        case 'flowchart-v2': {
-            const edges = read('getEdges');
-            found =
-                filled(read('getClasses')) ||
-                    filled(field('tooltips')) ||
-                    filled(edges.defaultStyle) ||
-                    edges.defaultInterpolate !== undefined ||
-                    entries(read('getVertices')).some((vertex) => filled(vertex.styles) ||
-                        Boolean(vertex.link || vertex.haveCallback || vertex.icon || vertex.img) ||
-                        clickable(vertex.classes)) ||
-                    entries(edges).some((edge) => filled(edge.style) ||
-                        edge.interpolate !== undefined ||
-                        clickable(edge.classes)) ||
-                    entries(read('getSubGraphs')).some((graph) => clickable(graph.classes));
-            break;
-        }
-        case 'stateDiagram':
-            found =
-                statementIn(field('rootDoc'), ['style', 'classDef', 'click']) ||
-                    filled(read('getClasses')) ||
-                    filled(read('getLinks')) ||
-                    entries(read('getStates')).some((state) => filled(state.styles) || filled(state.textStyles));
-            break;
-        case 'classDiagram':
-            found =
-                filled(field('styleClasses')) ||
-                    entries(read('getClasses')).some((node) => filled(node.styles) ||
-                        Boolean(node.link || node.haveCallback || node.tooltip) ||
-                        clickable(node.cssClasses));
-            break;
-        case 'er':
-            found =
-                filled(read('getClasses')) ||
-                    entries(read('getEntities')).some((entity) => filled(entity.cssStyles)) ||
-                    entries(read('getSubGraphs')).some((graph) => filled(graph.cssStyles));
-            break;
-        case 'sequence':
-            found = entries(read('getActors')).some((actor) => filled(actor.links) || filled(actor.properties));
-            break;
-        case 'pie':
-            found = false;
-            break;
-        default:
-            throw new Error('This diagram type is not supported. The source is retained.');
-    }
-    if (found)
-        throw new Error(refusal);
-}
-let sequence = 0;
-let queue = Promise.resolve();
-const cache = new Map();
-export function safeDiagramSVG(svg) {
-    const clean = DOMPurify.sanitize(svg, {
-        USE_PROFILES: { svg: true, svgFilters: true },
-        FORBID_TAGS: ['foreignObject', 'image', 'a', 'script', 'animate', 'set'],
-        FORBID_ATTR: ['href', 'xlink:href'],
-    });
-    const template = document.createElement('template');
-    template.innerHTML = clean;
-    const root = template.content.querySelector('svg');
-    if (!root)
-        throw new Error('The renderer did not produce a diagram.');
-    for (const element of [root, ...root.querySelectorAll('*')]) {
-        for (const attribute of [...element.attributes]) {
-            if (/^on/i.test(attribute.name) ||
-                /(?:https?|data|file|javascript|blob):|@import|\\/i.test(attribute.value) ||
-                cssResource.test(attribute.value))
-                element.removeAttribute(attribute.name);
-        }
-        if (element.tagName.toLowerCase() === 'style' &&
-            (/@import|(?:https?|data|file):|\\/i.test(element.textContent ?? '') ||
-                cssResource.test(element.textContent ?? '')))
-            element.remove();
-    }
-    root.setAttribute('xmlns', 'http://www.w3.org/2000/svg');
-    return root.outerHTML;
-}
-export function renderDiagram(source) {
-    try {
-        validateDiagram(source);
-    }
-    catch (error) {
-        return Promise.reject(error);
-    }
-    const previous = cache.get(source);
-    if (previous)
-        return previous;
-    const rendered = queue.then(async () => {
-        const { default: mermaid } = await import('mermaid');
-        mermaid.initialize({
-            startOnLoad: false,
-            securityLevel: 'strict',
-            htmlLabels: false,
-            suppressErrorRendering: true,
-            fontFamily: 'Arial, sans-serif',
-            altFontFamily: 'Arial, sans-serif',
-            layout: 'dagre',
-            look: 'classic',
-            theme: 'default',
-            maxTextSize: 30000,
-            maxEdges: 500,
-            flowchart: { htmlLabels: false },
-            sequence: {
-                actorFontFamily: 'Arial, sans-serif',
-                noteFontFamily: 'Arial, sans-serif',
-                messageFontFamily: 'Arial, sans-serif',
-            },
-            secure: [
-                'securityLevel',
-                'htmlLabels',
-                'theme',
-                'themeCSS',
-                'themeVariables',
-                'fontFamily',
-                'dompurifyConfig',
-                'flowchart',
-                'startOnLoad',
-                'maxTextSize',
-                'maxEdges',
-                'secure',
-                'altFontFamily',
-                'layout',
-                'look',
-                'sequence',
-                'class',
-                'state',
-                'er',
-                'pie',
-                'suppressErrorRendering',
-            ],
-        });
-        // getDiagramFromText is the pinned Mermaid's own parser, which render runs
-        // again on the same text; the public parse does not return the diagram. It
-        // skips render's configuration step, so the two parse alike only because
-        // the source check refuses %%{ directives and front matter.
-        refuseDirectives(await mermaid.mermaidAPI.getDiagramFromText(source));
-        // Mermaid measures text while laying out, so the holder must be attached
-        // and rendered. Such a holder can load CSS resources before sanitising,
-        // which is why the source and the parse result are checked first.
-        const holder = document.createElement('div');
-        holder.style.cssText =
-            'position:fixed;left:-100000px;top:0;width:1200px;pointer-events:none';
-        holder.setAttribute('aria-hidden', 'true');
-        document.body.append(holder);
-        try {
-            const result = await mermaid.render(`inkkitDiagram${++sequence}`, source, holder);
-            return safeDiagramSVG(result.svg);
-        }
-        finally {
-            holder.remove();
-        }
-    });
-    queue = rendered.catch(() => undefined);
-    cache.set(source, rendered);
-    void rendered.catch(() => {
-        if (cache.get(source) === rendered)
-            cache.delete(source);
-    });
-    if (cache.size > 64)
-        cache.delete(cache.keys().next().value);
-    return rendered;
-}
-export async function diagramImage(source) {
-    const svg = await renderDiagram(source);
-    const parsed = new DOMParser().parseFromString(svg, 'image/svg+xml').documentElement;
-    const bounds = (parsed.getAttribute('viewBox') ?? '')
-        .split(/[\s,]+/)
-        .map(Number);
-    const width = bounds[2] || Number.parseFloat(parsed.getAttribute('width') ?? '');
-    const height = bounds[3] || Number.parseFloat(parsed.getAttribute('height') ?? '');
-    if (!(width > 0 && height > 0 && Number.isFinite(width + height)))
-        throw new Error('The rendered diagram has no usable dimensions.');
-    const scale = Math.min(2, 4096 / width, 4096 / height);
-    const canvas = document.createElement('canvas');
-    canvas.width = Math.max(1, Math.ceil(width * scale));
-    canvas.height = Math.max(1, Math.ceil(height * scale));
-    const context = canvas.getContext('2d');
-    if (!context)
-        throw new Error('Portable diagram output is unavailable.');
-    parsed.setAttribute('width', String(width));
-    parsed.setAttribute('height', String(height));
-    const image = new Image();
-    const url = URL.createObjectURL(new Blob([new XMLSerializer().serializeToString(parsed)], {
-        type: 'image/svg+xml',
-    }));
-    try {
-        await new Promise((resolve, reject) => {
-            image.onload = () => resolve();
-            image.onerror = () => reject(new Error('The diagram image could not be rendered.'));
-            image.src = url;
-        });
-        context.fillStyle = '#ffffff';
-        context.fillRect(0, 0, canvas.width, canvas.height);
-        context.drawImage(image, 0, 0, canvas.width, canvas.height);
-        const data = canvas.toDataURL('image/png').split(',')[1];
-        if (!data)
-            throw new Error('The diagram image could not be exported.');
-        return {
-            bytes: Uint8Array.from(atob(data), (character) => character.charCodeAt(0)),
-            mimeType: 'image/png',
-            filename: 'diagram.png',
-        };
-    }
-    finally {
-        URL.revokeObjectURL(url);
-    }
-}
-export function mermaidPreview(onError) {
-    return $prose((ctx) => new Plugin({
-        key: new PluginKey('mermaidPreview'),
-        props: {
-            decorations(state) {
-                const widgets = [];
-                state.doc.descendants((node, pos) => {
-                    if (!isMermaid(node))
-                        return true;
-                    const source = node.textContent;
-                    widgets.push(Decoration.widget(pos + node.nodeSize, () => {
-                        const preview = document.createElement('div');
-                        preview.className = 'inkkit-mermaid-preview';
-                        preview.contentEditable = 'false';
-                        preview.textContent = editorLabels(ctx).diagramRendering;
-                        preview.setAttribute('role', 'status');
-                        preview.setAttribute('aria-live', 'polite');
-                        let active = true;
-                        preview.cancel =
-                            () => {
-                                active = false;
-                            };
-                        void renderDiagram(source).then((svg) => {
-                            if (active) {
-                                preview.innerHTML = svg;
-                                preview.dataset.state = 'ready';
-                            }
-                        }, (error) => {
-                            if (!active)
-                                return;
-                            const message = error instanceof Error
-                                ? error.message
-                                : 'The diagram could not be rendered.';
-                            preview.textContent = `${editorLabels(ctx).diagramUnavailable} ${message}`;
-                            preview.dataset.state = 'error';
-                            onError(new InkKitError('diagram-unavailable', message));
-                        });
-                        return preview;
-                    }, {
-                        key: `mermaid:${source}`,
-                        side: -1,
-                        ignoreSelection: true,
-                        destroy: (node) => node.cancel?.(),
-                    }));
-                    return false;
-                });
-                return DecorationSet.create(state.doc, widgets);
-            },
-        },
-    }));
-}

package/dist/outline.d.ts

@@ -1,22 +0,0 @@
-import type { Ctx } from '@milkdown/kit/ctx';
-import type { Node as ProseNode } from '@milkdown/kit/prose/model';
-import type { EditorView } from '@milkdown/kit/prose/view';
-export interface Heading {
-    readonly id: string;
-    readonly level: number;
-    readonly text: string;
-    readonly documentId: string;
-    readonly generation: number;
-    readonly revision: number;
-}
-export interface OutlineContext {
-    documentId: string;
-    generation: number;
-    revision: number;
-    epoch: number;
-    mode: 'source' | 'formatted';
-}
-export declare function collectFormattedHeadings(doc: ProseNode, context: OutlineContext): readonly Heading[];
-export declare function collectSourceHeadings(ctx: Ctx, source: string, context: OutlineContext): readonly Heading[];
-export declare function sourceHeadingPosition(ctx: Ctx, source: string, requested: Heading, context: OutlineContext): number;
-export declare function navigateFormattedHeading(view: EditorView, requested: Heading, context: OutlineContext): boolean;

package/dist/outline.js

@@ -1,79 +0,0 @@
-import { parserCtx, remarkCtx } from '@milkdown/kit/core';
-import { TextSelection } from '@milkdown/kit/prose/state';
-import { clipboardText } from './clipboard.js';
-import { revealCalloutAncestors } from './callouts.js';
-import { InkKitError } from './types.js';
-function formattedLocations(doc) {
-    const headings = [];
-    doc.descendants((node, position) => {
-        if (node.type.name === 'heading')
-            headings.push({ node, position });
-    });
-    return headings;
-}
-function sourceLocations(ctx, source) {
-    const processor = ctx.get(remarkCtx);
-    const tree = processor.runSync(processor.parse(source), {
-        value: source,
-    });
-    const positions = [];
-    const bom = source.startsWith('\uFEFF') ? 1 : 0;
-    const visit = (node) => {
-        if (node.type === 'heading' && node.position?.start.offset != null)
-            positions.push({
-                position: node.position.start.offset + bom,
-                level: node.depth,
-            });
-        node.children?.forEach(visit);
-    };
-    visit(tree);
-    const parsed = formattedLocations(ctx.get(parserCtx)(source));
-    if (positions.length !== parsed.length ||
-        positions.some((item, index) => item.level !== parsed[index].node.attrs.level))
-        throw new InkKitError('preservation', 'The current Markdown headings cannot be located safely');
-    return parsed.map((heading, index) => ({
-        ...heading,
-        position: positions[index].position,
-    }));
-}
-function entry(heading, context) {
-    return Object.freeze({
-        id: `heading:${context.epoch}:${context.mode}:${context.generation}:${context.revision}:${heading.position}`,
-        level: Number(heading.node.attrs.level),
-        text: clipboardText(heading.node.content),
-        documentId: context.documentId,
-        generation: context.generation,
-        revision: context.revision,
-    });
-}
-export function collectFormattedHeadings(doc, context) {
-    return Object.freeze(formattedLocations(doc).map((item) => entry(item, context)));
-}
-export function collectSourceHeadings(ctx, source, context) {
-    return Object.freeze(sourceLocations(ctx, source).map((item) => entry(item, context)));
-}
-function currentLocation(locations, requested, context) {
-    for (const location of locations) {
-        const current = entry(location, context);
-        if (current.id === requested.id &&
-            current.documentId === requested.documentId &&
-            current.generation === requested.generation &&
-            current.revision === requested.revision &&
-            current.level === requested.level &&
-            current.text === requested.text)
-            return location.position;
-    }
-    throw new InkKitError('stale-document', 'The heading is no longer current');
-}
-export function sourceHeadingPosition(ctx, source, requested, context) {
-    return currentLocation(sourceLocations(ctx, source), requested, context);
-}
-export function navigateFormattedHeading(view, requested, context) {
-    const position = currentLocation(formattedLocations(view.state.doc), requested, context);
-    revealCalloutAncestors(view, position + 1);
-    view.dispatch(view.state.tr
-        .setSelection(TextSelection.create(view.state.doc, position + 1))
-        .scrollIntoView());
-    view.focus();
-    return true;
-}

package/dist/paste-html.d.ts

@@ -1,23 +0,0 @@
-export declare function isRichElement(element: Element): boolean;
-/** Whether normalisation enters the element, so its content may be rewritten. */
-export declare function isRewrittenElement(element: Element): boolean;
-/**
- * Whether the element's own inline style makes a browser keep the whitespace
- * of its content, as copied editor code does with `white-space: pre`. The
- * declarations are parsed, so case, spacing, comments, quoted text and
- * `!important` do not matter. Style sheets are not consulted.
- */
-export declare function keepsWhitespace(element: Element): boolean;
-/**
- * Rewrites common web-page elements to ones the importer already understands.
- * Elements that will stay literal source are not entered, so their content is
- * preserved exactly.
- */
-export declare function normalizeClipboardHTML(root: Node): void;
-/**
- * Collapses source whitespace the way a browser renders it: runs become one
- * space, and none remains at the edges of a block or beside a line break.
- * `pre`, `code`, elements that stay literal source and elements whose style
- * keeps whitespace are not entered.
- */
-export declare function collapseClipboardWhitespace(root: Node): void;