@aicayzer/inkkit 0.0.18 → 0.1.0

package/dist/code-fences.js

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

package/dist/comments.d.ts

@@ -1,76 +0,0 @@
-import { Fragment, type Node as ProseNode } from '@milkdown/kit/prose/model';
-import { type Transaction } from '@milkdown/kit/prose/state';
-import type { EditorView } from '@milkdown/kit/prose/view';
-import type { Literal } from 'mdast';
-export type CommentSyntax = 'html' | 'obsidian';
-interface Comment extends Literal {
-    type: 'inkkitCommentInline' | 'inkkitCommentBlock';
-    syntax: CommentSyntax;
-    block?: boolean;
-}
-declare module 'mdast' {
-    interface PhrasingContentMap {
-        inkkitCommentInline: Comment & {
-            type: 'inkkitCommentInline';
-        };
-    }
-    interface BlockContentMap {
-        inkkitCommentBlock: Comment & {
-            type: 'inkkitCommentBlock';
-        };
-    }
-    interface RootContentMap {
-        inkkitCommentInline: Comment & {
-            type: 'inkkitCommentInline';
-        };
-        inkkitCommentBlock: Comment & {
-            type: 'inkkitCommentBlock';
-        };
-    }
-}
-declare module 'micromark-util-types' {
-    interface TokenTypeMap {
-        inkkitCommentInline: 'inkkitCommentInline';
-        inkkitCommentBlock: 'inkkitCommentBlock';
-        inkkitCommentData: 'inkkitCommentData';
-    }
-}
-export declare function commentSource(node: ProseNode): string;
-export interface CommentSpan {
-    start: number;
-    end: number;
-    syntax: CommentSyntax;
-    value: string;
-    block?: boolean;
-}
-export declare function literalCommentSpans(value: string): CommentSpan[];
-export declare const remarkCommentsPlugin: import("@milkdown/kit/utils").$Remark<"remarkComments", unknown>;
-export declare const commentInline: import("@milkdown/kit/utils").$Node;
-export declare const commentBlock: import("@milkdown/kit/utils").$Node;
-export declare const commentVisibility: import("@milkdown/kit/utils").$Prose;
-export declare function setCommentVisibility(view: EditorView, visible: boolean): void;
-export declare const comments: (import("@milkdown/kit/utils").$Node | import("@milkdown/kit/utils").$Prose)[];
-/**
- * Whether text inside a comment ends it early for a reader other than InkKit.
- * HTML ends a comment at `-->` or `--!>`, and treats a start of `>` or `->` as
- * an empty comment. A `%%` comment ends at its next `%%`.
- */
-export declare function commentTextEndsEarly(syntax: string, text: string): boolean;
-/**
- * Refuses an edit that gives a comment text which ends it early. A comment
- * that already held that text before the edit is left alone, so a note that
- * has one still loads and can be edited elsewhere.
- */
-export declare function assertCommentsEndWhereWritten(before: ProseNode, after: ProseNode): void;
-/** Marks a transaction that replaces the document with source given as written. */
-export declare const sourceReplacement = "inkkit:sourceReplacement";
-/**
- * Whether an edit is typed or inserted by a person in the formatted editor. A
- * history step restores a document the editor already accepted, and a source
- * replacement is the author's own text, so neither is checked.
- */
-export declare function isWrittenEdit(tr: Transaction): boolean;
-export declare function isComment(node: ProseNode): boolean;
-export declare function shareableFragment(content: Fragment): Fragment;
-export declare function commentSelectionContent(doc: ProseNode, from: number, to: number, content: Fragment): Fragment;
-export {};