@aicayzer/inkkit 0.0.18 → 0.1.0

package/dist/linked-syntax.js

@@ -1,320 +0,0 @@
-import { $node, $remark } from '@milkdown/kit/utils';
-import { defaultHandlers } from 'mdast-util-to-markdown';
-const fromTable = (raw) => raw.replace(/(\\*)\|/g, (_match, escapes) => `${'\\'.repeat(Math.floor(escapes.length / 2))}|`);
-const toTable = (raw) => raw.replace(/(\\*)\|/g, (_match, escapes) => `${'\\'.repeat(escapes.length * 2 + 1)}|`);
-export function parseLinkedSyntax(raw, inTable = false) {
-    const source = inTable ? fromTable(raw) : raw;
-    const embed = source.startsWith('!');
-    const prefix = embed ? '![[' : '[[';
-    if (!source.startsWith(prefix) || !source.endsWith(']]'))
-        return undefined;
-    const content = source.slice(prefix.length, -2);
-    const parts = { target: '', fragment: '', alias: '' };
-    let section = 'target', hasFragment = false, hasAlias = false;
-    for (let index = 0; index < content.length; index++) {
-        const character = content[index];
-        if (character === '\\') {
-            const escaped = content[++index];
-            if (!escaped || !'[]|#\\'.includes(escaped))
-                return undefined;
-            parts[section] += escaped;
-        }
-        else if (character === '|') {
-            if (hasAlias)
-                return undefined;
-            hasAlias = true;
-            section = 'alias';
-        }
-        else if (character === '#' && section !== 'alias') {
-            if (hasFragment)
-                return undefined;
-            hasFragment = true;
-            section = 'fragment';
-        }
-        else {
-            if ('[]'.includes(character) ||
-                (character.charCodeAt(0) < 32 && character !== '\t') ||
-                character === '\u007f')
-                return undefined;
-            parts[section] += character;
-        }
-    }
-    if ((!parts.target.trim() && !(hasFragment && parts.fragment.trim())) ||
-        (hasFragment && !parts.fragment.trim()) ||
-        (hasAlias && !parts.alias.trim()) ||
-        parts.target.trimStart().startsWith('^') ||
-        parts.fragment.trimStart().startsWith('^'))
-        return undefined;
-    const size = /^[ \t]*(\d{1,5})(?:x(\d{1,5}))?[ \t]*$/.exec(parts.alias);
-    if (embed &&
-        (!parts.target.trim() ||
-            (hasAlias &&
-                (!size ||
-                    Number(size[1]) < 1 ||
-                    (size[2] != null && Number(size[2]) < 1)))))
-        return undefined;
-    const target = embed ? parts.target.trim() : parts.target;
-    const fragment = hasFragment
-        ? embed
-            ? parts.fragment.trim()
-            : parts.fragment
-        : null;
-    return {
-        raw,
-        target,
-        fragment,
-        label: !embed && hasAlias
-            ? parts.alias
-            : target + (fragment != null ? `#${fragment}` : ''),
-        width: embed && hasAlias ? Number(size[1]) : null,
-        embed,
-        inTable,
-    };
-}
-function linkedTokenizer(embed) {
-    return function (effects, ok, nok) {
-        const prefix = embed ? '![[' : '[[';
-        let index = 0, raw = '';
-        return opening;
-        function consume(code) {
-            raw += code === -2 ? '\t' : code === -1 ? ' ' : String.fromCodePoint(code);
-            effects.consume(code);
-        }
-        function opening(code) {
-            if (code !== prefix.charCodeAt(index))
-                return nok(code);
-            if (!index)
-                effects.enter('inkkitLinkedSyntax');
-            consume(code);
-            index++;
-            return index === prefix.length ? body : opening;
-        }
-        function body(code) {
-            if (code === null ||
-                (code < 32 && code !== -2 && code !== -1 && code !== 9) ||
-                code === 91)
-                return nok(code);
-            consume(code);
-            if (code === 92)
-                return escaped;
-            return code === 93 ? closing : body;
-        }
-        function escaped(code) {
-            if (code === null || code < 32)
-                return nok(code);
-            consume(code);
-            return body;
-        }
-        function closing(code) {
-            if (code !== 93)
-                return nok(code);
-            consume(code);
-            if (!parseLinkedSyntax(raw) && !parseLinkedSyntax(raw, true))
-                return nok(code);
-            effects.exit('inkkitLinkedSyntax');
-            return ok;
-        }
-    };
-}
-function tableForm(raw, authoredInTable, outputInTable) {
-    if (authoredInTable === outputInTable)
-        return raw;
-    return outputInTable ? toTable(raw) : fromTable(raw);
-}
-export function wikiMarkdown(node, inTable = false) {
-    return tableForm(String(node.attrs.raw), Boolean(node.attrs.inTable), inTable);
-}
-export function wikiReference(node) {
-    return {
-        target: String(node.attrs.target),
-        ...(node.attrs.fragment != null
-            ? { fragment: String(node.attrs.fragment) }
-            : {}),
-        label: String(node.attrs.label),
-    };
-}
-export function fileReference(node) {
-    const reference = String(node.attrs.src ?? '');
-    const named = node.attrs.inkkitFileRaw != null;
-    const alt = String(node.attrs.alt ?? '');
-    const match = /\|(\d{1,5})$/.exec(alt);
-    const fragment = named
-        ? node.attrs.inkkitFileFragment
-        : reference.includes('#')
-            ? reference.slice(reference.indexOf('#') + 1)
-            : null;
-    const label = named
-        ? String(node.attrs.inkkitFileTarget ?? '') +
-            (fragment != null ? `#${fragment}` : '')
-        : match
-            ? alt.slice(0, match.index)
-            : alt;
-    const width = named && alt === label && node.attrs.inkkitFileWidth == null
-        ? null
-        : match
-            ? Number(match[1])
-            : null;
-    return {
-        reference,
-        kind: named ? 'wiki' : 'path',
-        ...(fragment != null ? { fragment: String(fragment) } : {}),
-        ...(label ? { label } : {}),
-        ...(width != null ? { width } : {}),
-    };
-}
-export function namedFileMarkdown(node, inTable = false) {
-    if (node.attrs.inkkitFileRaw == null)
-        return undefined;
-    let raw = String(node.attrs.inkkitFileRaw);
-    const authoredInTable = Boolean(node.attrs.inkkitFileInTable);
-    const width = fileReference(node).width ?? null;
-    const original = node.attrs.inkkitFileWidth ?? null;
-    if (width !== original) {
-        if (authoredInTable)
-            raw = fromTable(raw);
-        if (original != null)
-            raw = raw.replace(/\|[ \t]*\d{1,5}(?:x\d{1,5})?[ \t]*\]\]$/, ']]');
-        if (width != null)
-            raw = `${raw.slice(0, -2)}|${width}]]`;
-        return inTable ? toTable(raw) : raw;
-    }
-    return tableForm(raw, authoredInTable, inTable);
-}
-export const wikiLinkSchema = $node('inkkit_wiki_link', () => ({
-    inline: true,
-    group: 'inline',
-    atom: true,
-    marks: '',
-    attrs: {
-        raw: { default: '' },
-        target: { default: '' },
-        fragment: { default: null },
-        label: { default: '' },
-        inTable: { default: false },
-    },
-    parseDOM: [
-        {
-            tag: 'span[data-inkkit-wiki]',
-            getAttrs(dom) {
-                const parsed = parseLinkedSyntax(dom.getAttribute('data-inkkit-wiki-raw') ?? '', dom.getAttribute('data-inkkit-wiki-table') === 'true');
-                return parsed && !parsed.embed
-                    ? {
-                        raw: parsed.raw,
-                        target: parsed.target,
-                        fragment: parsed.fragment,
-                        label: parsed.label,
-                        inTable: parsed.inTable,
-                    }
-                    : false;
-            },
-        },
-    ],
-    toDOM: (node) => [
-        'span',
-        {
-            'data-inkkit-wiki': node.attrs.target,
-            'data-inkkit-fragment': node.attrs.fragment ?? '',
-            'data-inkkit-wiki-raw': node.attrs.raw,
-            'data-inkkit-wiki-table': String(node.attrs.inTable),
-            role: 'link',
-            tabindex: '0',
-        },
-        node.attrs.label,
-    ],
-    parseMarkdown: {
-        match: (node) => node.type === 'inkkitWikiLink',
-        runner(state, node, type) {
-            state.addNode(type, {
-                raw: node.raw,
-                target: node.target,
-                fragment: node.fragment,
-                label: node.label,
-                inTable: node.inTable,
-            });
-        },
-    },
-    toMarkdown: {
-        match: (node) => node.type.name === 'inkkit_wiki_link',
-        runner(state, node) {
-            state.addNode('inkkitWikiLink', undefined, node.attrs.label, {
-                raw: node.attrs.raw,
-                target: node.attrs.target,
-                fragment: node.attrs.fragment,
-                label: node.attrs.label,
-                inTable: node.attrs.inTable,
-            });
-        },
-    },
-}));
-export function linkedSyntax(wikiLinks, files) {
-    const syntax = { text: {} };
-    if (wikiLinks)
-        syntax.text[91] = {
-            name: 'inkkitWikiLink',
-            tokenize: linkedTokenizer(false),
-            previous: (code) => code !== 33 && code !== 91,
-        };
-    if (files)
-        syntax.text[33] = {
-            name: 'inkkitNamedFile',
-            tokenize: linkedTokenizer(true),
-        };
-    const from = {
-        enter: {
-            inkkitLinkedSyntax(token) {
-                const inTable = this.stack.some((node) => node.type === 'tableCell');
-                const parsed = parseLinkedSyntax(this.sliceSerialize(token), inTable);
-                if (!parsed) {
-                    this.enter({ type: 'text', value: this.sliceSerialize(token) }, token);
-                    return;
-                }
-                if (parsed.embed)
-                    this.enter({
-                        type: 'image',
-                        url: parsed.target +
-                            (parsed.fragment != null ? `#${parsed.fragment}` : ''),
-                        alt: parsed.label + (parsed.width != null ? `|${parsed.width}` : ''),
-                        title: null,
-                        inkkitFileRaw: parsed.raw,
-                        inkkitFileTarget: parsed.target,
-                        inkkitFileFragment: parsed.fragment,
-                        inkkitFileWidth: parsed.width,
-                        inkkitFileInTable: inTable,
-                    }, token);
-                else
-                    this.enter({
-                        type: 'inkkitWikiLink',
-                        value: parsed.label,
-                        raw: parsed.raw,
-                        target: parsed.target,
-                        fragment: parsed.fragment,
-                        label: parsed.label,
-                        inTable,
-                    }, token);
-            },
-        },
-        exit: {
-            inkkitLinkedSyntax(token) {
-                this.exit(token);
-            },
-        },
-    };
-    const wiki = (node, _parent, state) => tableForm(String(node.raw), Boolean(node.inTable), state.stack.includes('tableCell'));
-    const named = (node, parent, state, info) => {
-        if (node.inkkitFileRaw != null)
-            return tableForm(String(node.inkkitFileRaw), Boolean(node.inkkitFileInTable), state.stack.includes('tableCell'));
-        return defaultHandlers.image(node, parent, state, info);
-    };
-    // Standard image handling is installed by CommonMark; wrap it only for authored named tokens.
-    return $remark('inkkitLinkedSyntax', () => function () {
-        const data = this.data();
-        (data.micromarkExtensions ??= []).push(syntax);
-        (data.fromMarkdownExtensions ??= []).push(from);
-        (data.toMarkdownExtensions ??= []).push({
-            handlers: {
-                inkkitWikiLink: wiki,
-                ...(files ? { image: named } : {}),
-            },
-        });
-    });
-}

package/dist/literals.d.ts

@@ -1,20 +0,0 @@
-import type { Literal } from 'mdast';
-import { type CommentSpan } from './comments.js';
-interface InkKitLiteral extends Literal {
-    type: 'inkkitLiteral';
-    comments?: CommentSpan[];
-}
-declare module 'mdast' {
-    interface BlockContentMap {
-        inkkitLiteral: InkKitLiteral;
-    }
-    interface RootContentMap {
-        inkkitLiteral: InkKitLiteral;
-    }
-}
-export declare function sourceFrontmatter(source: string): string | undefined;
-export declare function lineBreakHTML(value: string): boolean;
-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;
-export {};

package/dist/literals.js

@@ -1,216 +0,0 @@
-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];
-}
-export function lineBreakHTML(value) {
-    return ['<br />', '<br>', '<br >', '<br/>'].includes(value.trim());
-}
-function restoreInlineBreaks(node) {
-    // A cell cannot hold a line ending, so even a lone break there is content.
-    if (((node.type === 'paragraph' || node.type === 'heading') &&
-        node.children.length > 1) ||
-        node.type === 'tableCell') {
-        node.children = node.children.map((child) => child.type === 'html' && lineBreakHTML(child.value)
-            ? {
-                type: 'break',
-                data: { inkkitHTMLBreak: true },
-                position: child.position,
-            }
-            : child);
-    }
-    if ('children' in node)
-        node.children.forEach(restoreInlineBreaks);
-}
-function containsUnsupported(node, images, inline = false) {
-    // Only a standalone break represents a spacer; inline HTML must remain literal.
-    if (!inline && node.type === 'html' && lineBreakHTML(node.value))
-        return false;
-    if (node.type === 'paragraph' && node.children.length === 1) {
-        const child = node.children[0];
-        if (child?.type === 'html' && lineBreakHTML(child.value))
-            return false;
-    }
-    // GFM ignores cells past the header's count, so a grid cannot show them.
-    if (node.type === 'table' &&
-        node.children.some((row) => row.children.length > (node.children[0]?.children.length ?? 0)))
-        return true;
-    return ((unsupported.has(node.type) && !(images && node.type === 'image')) ||
-        ('children' in node &&
-            node.children.some((child) => containsUnsupported(child, images, inline || node.type === 'paragraph' || node.type === 'heading'))));
-}
-function containsUnresolved(node, source) {
-    if (node.type === 'text') {
-        const start = node.position?.start.offset;
-        const end = node.position?.end.offset;
-        if (start == null || end == null)
-            return false;
-        const raw = source.slice(start, end);
-        return /(?<!\\)\[\^[^\]\n]+\]|(?<!\\)\[[^\]\n]+\](?:\[[^\]\n]*\])?/.test(raw);
-    }
-    return ('children' in node &&
-        node.children.some((child) => containsUnresolved(child, source)));
-}
-function containsUnsupportedLinked(node, source) {
-    const start = node.position?.start.offset, end = node.position?.end.offset;
-    if (start == null || end == null || node.type === 'definition')
-        return false;
-    const supported = [];
-    const visit = (child) => {
-        if ([
-            'inkkitWikiLink',
-            'image',
-            'code',
-            'inlineCode',
-            'link',
-            'inkkitCommentInline',
-            'inkkitCommentBlock',
-        ].includes(child.type)) {
-            const from = child.position?.start.offset, to = child.position?.end.offset;
-            if (from != null && to != null)
-                supported.push({ from, to });
-            return;
-        }
-        if ('children' in child)
-            child.children.forEach(visit);
-    };
-    visit(node);
-    for (const match of source
-        .slice(start, end)
-        .matchAll(/!?\[\[[^\r\n]*?\]\]/g)) {
-        const from = start + match.index, to = from + match[0].length;
-        let escapes = 0;
-        while (from - escapes > 0 && source[from - escapes - 1] === '\\')
-            escapes++;
-        if (escapes % 2)
-            continue;
-        if (!supported.some((span) => span.from <= from && span.to >= to))
-            return true;
-    }
-    return false;
-}
-// Keep syntax we cannot faithfully edit as literal text, without making the rest
-// of the document a source editor or allowing HTML and image network requests.
-export function createLiteralPreservation(images) {
-    return $remark('preserveLiterals', () => () => (tree, file) => {
-        restoreInlineBreaks(tree);
-        // Micromark's positions exclude an initial byte-order mark.
-        const source = String(file.value).replace(/^\uFEFF/, '');
-        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));
-                return node;
-            }
-            const start = node.position?.start.offset;
-            const end = node.position?.end.offset;
-            if (start == null ||
-                end == null ||
-                (!containsUnsupported(node, images) &&
-                    !containsUnresolved(node, source) &&
-                    !containsUnsupportedLinked(node, source)))
-                return node;
-            let raw = source.slice(start, end);
-            // Definition indentation is restored by the footnote serializer.
-            for (let index = 0; index < depth; index++)
-                raw = raw.replace(/\r?\n(?: {4}|\t)/g, '\n');
-            return {
-                type: 'inkkitLiteral',
-                value: raw,
-                comments: literalCommentSpans(raw),
-                position: node.position,
-            };
-        };
-        const blocks = [];
-        if (frontmatter)
-            blocks.push({
-                type: 'inkkitLiteral',
-                value: frontmatter.trimEnd(),
-                position: {
-                    start: { line: 1, column: 1, offset: 0 },
-                    end: {
-                        line: 1,
-                        column: 1,
-                        offset: frontmatter.trimEnd().length,
-                    },
-                },
-            });
-        for (const node of tree.children) {
-            const start = node.position?.start.offset;
-            const end = node.position?.end.offset;
-            if (start == null || end == null) {
-                blocks.push(node);
-                continue;
-            }
-            if (start < frontmatterEnd) {
-                // TOML delimiters are ordinary paragraph text to CommonMark, so a
-                // paragraph may also contain body text immediately after the header.
-                if (end > frontmatterEnd)
-                    blocks.push({
-                        type: 'inkkitLiteral',
-                        value: source.slice(frontmatterEnd, end),
-                        position: {
-                            start: { line: 1, column: 1, offset: frontmatterEnd },
-                            end: node.position.end,
-                        },
-                    });
-                continue;
-            }
-            if (node.type === 'inkkitLiteral')
-                node.comments = literalCommentSpans(node.value);
-            blocks.push(preserveBlock(node));
-        }
-        tree.children = blocks;
-    });
-}
-export const preserveLiterals = createLiteralPreservation(false);
-export const literalBlock = $node('literal_markdown', () => ({
-    group: 'block',
-    content: '(text | comment_inline)*',
-    marks: '',
-    code: true,
-    defining: true,
-    parseDOM: [
-        { tag: 'pre.literal-markdown', preserveWhitespace: 'full', priority: 100 },
-    ],
-    toDOM: () => [
-        'pre',
-        { class: 'literal-markdown', 'aria-label': 'Preserved Markdown' },
-        0,
-    ],
-    parseMarkdown: {
-        match: (node) => node.type === 'inkkitLiteral',
-        runner: (state, node, type) => {
-            state.openNode(type);
-            const value = String(node.value ?? '');
-            let cursor = 0;
-            for (const span of node.comments ?? []) {
-                if (span.start > cursor)
-                    state.addText(value.slice(cursor, span.start));
-                state.openNode(state.schema.nodes.comment_inline, {
-                    syntax: span.syntax,
-                    block: Boolean(span.block),
-                });
-                if (span.value)
-                    state.addText(span.value);
-                state.closeNode();
-                cursor = span.end;
-            }
-            if (cursor < value.length)
-                state.addText(value.slice(cursor));
-            state.closeNode();
-        },
-    },
-    toMarkdown: {
-        match: (node) => node.type.name === 'literal_markdown',
-        runner: (state, node) => {
-            let source = '';
-            node.forEach((child) => {
-                source += child.isText ? child.text : commentSource(child);
-            });
-            state.addNode('html', undefined, source);
-        },
-    },
-}));

package/dist/mermaid.d.ts

@@ -1,28 +0,0 @@
-import type { Node as ProseNode } from '@milkdown/kit/prose/model';
-import { type PortableImage } from './types.js';
-export declare function isMermaid(node: ProseNode): boolean;
-interface Annotations {
-    names: string[];
-    rest: string;
-}
-export declare function validateDiagram(source: string): Annotations;
-interface ParsedDiagram {
-    type: string;
-    db: unknown;
-}
-interface Mermaid {
-    initialize(config: object): void;
-    render(id: string, text: string, container?: Element): Promise<{
-        svg: string;
-    }>;
-    mermaidAPI: {
-        getDiagramFromText(text: string): Promise<ParsedDiagram>;
-    };
-}
-export declare function registerMermaid(load: () => Promise<Mermaid>): void;
-export declare const diagramsAvailable: () => boolean;
-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;
-export {};