@lapismd/mira 0.0.1

package/dist/internal/codemirror/markdown/lapis-inline.d.ts

@@ -0,0 +1,11 @@
+import { Tag } from "@lezer/highlight";
+import type { MarkdownConfig } from "@lezer/markdown";
+export declare const WikiLinkParser: MarkdownConfig;
+export declare const lapisTagHighlight: {
+    marker: Tag;
+    name: Tag;
+};
+export declare const TagParser: MarkdownConfig;
+export declare const EmbedLinkParser: MarkdownConfig;
+export declare const PathLinkParser: MarkdownConfig;
+//# sourceMappingURL=lapis-inline.d.ts.map

package/dist/internal/codemirror/markdown/lapis-inline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lapis-inline.d.ts","sourceRoot":"","sources":["../../../../src/internal/codemirror/markdown/lapis-inline.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,GAAG,EAAE,MAAM,kBAAkB,CAAC;AAC9D,OAAO,KAAK,EAAiB,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAErE,eAAO,MAAM,cAAc,EAAE,cAkE5B,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;CAG7B,CAAC;AAEF,eAAO,MAAM,SAAS,EAAE,cA+BvB,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,cAyE7B,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,cAoD5B,CAAC"}

package/dist/internal/codemirror/markdown/lapis-inline.js

@@ -0,0 +1,189 @@
+import { tags as highlightTags, Tag } from "@lezer/highlight";
+export const WikiLinkParser = {
+    defineNodes: [
+        { name: "WikiLink", style: highlightTags.meta },
+        { name: "WikiLinkBracket", style: highlightTags.bracket },
+        { name: "WikiLinkPath", style: highlightTags.link },
+        { name: "WikiLinkAnchor", style: highlightTags.meta },
+        { name: "WikiLinkText", style: highlightTags.attributeValue },
+    ],
+    parseInline: [
+        {
+            before: "Link",
+            name: "WikiLink",
+            parse(context, next, position) {
+                if (next !== 91) {
+                    return -1;
+                }
+                const match = /^\[\[([^\]|#\r\n]+)(?:#([^\]|\r\n]+))?(?:\|([^\]\r\n]+))?\]\]/u.exec(context.slice(position, context.end));
+                if (!match) {
+                    return -1;
+                }
+                const fullMatch = match[0];
+                const path = match[1] ?? "";
+                const anchor = match[2];
+                const text = match[3];
+                const children = [];
+                let index = position;
+                children.push(context.elt("WikiLinkBracket", index, index + 2));
+                index += 2;
+                children.push(context.elt("WikiLinkPath", index, index + path.length));
+                index += path.length;
+                if (anchor) {
+                    children.push(context.elt("WikiLinkAnchor", index + 1, index + 1 + anchor.length));
+                    index += 1 + anchor.length;
+                }
+                if (text) {
+                    children.push(context.elt("WikiLinkText", index + 1, index + 1 + text.length));
+                    index += 1 + text.length;
+                }
+                children.push(context.elt("WikiLinkBracket", index, position + fullMatch.length));
+                return context.addElement(context.elt("WikiLink", position, position + fullMatch.length, children));
+            },
+        },
+    ],
+};
+export const lapisTagHighlight = {
+    marker: Tag.define(),
+    name: Tag.define(),
+};
+export const TagParser = {
+    defineNodes: [
+        { name: "Tag" },
+        { name: "TagMarker", style: lapisTagHighlight.marker },
+        { name: "TagName", style: lapisTagHighlight.name },
+    ],
+    parseInline: [
+        {
+            name: "Tag",
+            parse(context, next, position) {
+                if (next !== 35) {
+                    return -1;
+                }
+                const match = /^#([/a-zA-Z0-9_-]+)/u.exec(context.slice(position, context.end));
+                const tagName = match?.[1];
+                if (!match || !tagName) {
+                    return -1;
+                }
+                return context.addElement(context.elt("Tag", position, position + match[0].length, [
+                    context.elt("TagMarker", position, position + 1),
+                    context.elt("TagName", position + 1, position + 1 + tagName.length),
+                ]));
+            },
+        },
+    ],
+};
+export const EmbedLinkParser = {
+    defineNodes: [
+        { name: "EmbedLink", style: highlightTags.meta },
+        { name: "EmbedLinkMarker", style: highlightTags.meta },
+        { name: "EmbedLinkBracket", style: highlightTags.bracket },
+        { name: "EmbedLinkPath", style: highlightTags.link },
+        { name: "EmbedLinkAnchor", style: highlightTags.meta },
+        { name: "EmbedLinkText", style: highlightTags.attributeValue },
+    ],
+    parseInline: [
+        {
+            before: "Image",
+            name: "EmbedLink",
+            parse(context, next, position) {
+                if (next !== 33) {
+                    return -1;
+                }
+                const match = /^!\[\[([^\]|#\r\n]+)(?:#([^\]|\r\n]+))?(?:\|([^\]\r\n]+))?\]\]/u.exec(context.slice(position, context.end));
+                if (!match) {
+                    return -1;
+                }
+                const fullMatch = match[0];
+                const path = match[1] ?? "";
+                const anchor = match[2];
+                const text = match[3];
+                const children = [];
+                let index = position;
+                children.push(context.elt("EmbedLinkMarker", index, index + 1));
+                index += 1;
+                children.push(context.elt("EmbedLinkBracket", index, index + 2));
+                index += 2;
+                children.push(context.elt("EmbedLinkPath", index, index + path.length));
+                index += path.length;
+                if (anchor) {
+                    children.push(context.elt("EmbedLinkAnchor", index + 1, index + 1 + anchor.length));
+                    index += 1 + anchor.length;
+                }
+                if (text) {
+                    children.push(context.elt("EmbedLinkText", index + 1, index + 1 + text.length));
+                    index += 1 + text.length;
+                }
+                children.push(context.elt("EmbedLinkBracket", index, position + fullMatch.length));
+                return context.addElement(context.elt("EmbedLink", position, position + fullMatch.length, children));
+            },
+        },
+    ],
+};
+export const PathLinkParser = {
+    defineNodes: [
+        { name: "PathLink" },
+        { name: "PathLinkMark", style: highlightTags.bracket },
+        { name: "PathLinkText", style: highlightTags.link },
+        { name: "PathLinkDestination", style: highlightTags.link },
+    ],
+    parseInline: [
+        {
+            before: "Link",
+            name: "PathLink",
+            parse(context, next, position) {
+                if (next !== 91) {
+                    return -1;
+                }
+                const match = matchLocalPathLink(context.slice(position, context.end));
+                if (!match) {
+                    return -1;
+                }
+                const children = [];
+                let index = position;
+                children.push(context.elt("PathLinkMark", index, index + 1));
+                index += 1;
+                children.push(context.elt("PathLinkText", index, index + match.text.length));
+                index += match.text.length;
+                children.push(context.elt("PathLinkMark", index, index + 2));
+                index += 2;
+                children.push(context.elt("PathLinkDestination", index, index + match.destination.length));
+                index += match.destination.length;
+                children.push(context.elt("PathLinkMark", index, index + 1));
+                return context.addElement(context.elt("PathLink", position, position + match.fullMatch.length, children));
+            },
+        },
+    ],
+};
+function hasRawSpace(value) {
+    return value.includes(" ");
+}
+function isUrlLikeDestination(value) {
+    return /^(?:[a-z][a-z\d+.-]*:|\/\/)/iu.test(value);
+}
+function isLocalPathDestination(value) {
+    if (!hasRawSpace(value)) {
+        return false;
+    }
+    if (value.trim() !== value || value.length === 0) {
+        return false;
+    }
+    if (/[\n\r\t<>|]/u.test(value)) {
+        return false;
+    }
+    if (value.includes("#") || value.includes("?")) {
+        return false;
+    }
+    return !isUrlLikeDestination(value);
+}
+function matchLocalPathLink(value) {
+    const match = /^\[([^\]\n]+)\]\(([^)\n]+)\)/u.exec(value);
+    if (!match || !isLocalPathDestination(match[2] ?? "")) {
+        return null;
+    }
+    return {
+        fullMatch: match[0],
+        text: match[1] ?? "",
+        destination: match[2] ?? "",
+    };
+}

package/dist/internal/codemirror/markdown/latex.d.ts

@@ -0,0 +1,5 @@
+import { Parser } from "@lezer/common";
+import { type MarkdownConfig } from "@lezer/markdown";
+export declare const latexParser: Parser;
+export declare function parseLatex(parser?: Parser): MarkdownConfig;
+//# sourceMappingURL=latex.d.ts.map

package/dist/internal/codemirror/markdown/latex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"latex.d.ts","sourceRoot":"","sources":["../../../../src/internal/codemirror/markdown/latex.ts"],"names":[],"mappings":"AACA,OAAO,EAAc,MAAM,EAAsB,MAAM,eAAe,CAAC;AAEvE,OAAO,EAGL,KAAK,cAAc,EAEpB,MAAM,iBAAiB,CAAC;AAezB,eAAO,MAAM,WAAW,QAAyC,CAAC;AASlE,wBAAgB,UAAU,CAAC,MAAM,GAAE,MAAoB,GAAG,cAAc,CA+FvE"}

package/dist/internal/codemirror/markdown/latex.js

@@ -0,0 +1,97 @@
+import { StreamLanguage } from "@codemirror/language";
+import { parseMixed, Parser } from "@lezer/common";
+import { tags } from "@lezer/highlight";
+import { InlineContext, } from "@lezer/markdown";
+import { stexMath } from "@codemirror/legacy-modes/mode/stex";
+const INLINE_MATH_DOLLAR = "InlineMathDollar";
+const INLINE_MATH_BRACKET = "InlineMathBracket";
+const BLOCK_MATH_DOLLAR = "BlockMathDollar";
+const BLOCK_MATH_BRACKET = "BlockMathBracket";
+const delimiterLength = {
+    [INLINE_MATH_DOLLAR]: 1,
+    [INLINE_MATH_BRACKET]: 2,
+    [BLOCK_MATH_DOLLAR]: 2,
+    [BLOCK_MATH_BRACKET]: 2,
+};
+export const latexParser = StreamLanguage.define(stexMath).parser;
+const delimiters = Object.keys(delimiterLength).reduce((accumulator, name) => {
+    accumulator[name] = { mark: `${name}Mark`, resolve: name };
+    return accumulator;
+}, {});
+export function parseLatex(parser = latexParser) {
+    const defineNodes = [];
+    Object.keys(delimiterLength).forEach((name) => {
+        defineNodes.push({
+            name,
+            style: tags.emphasis,
+        }, { name: `${name}Mark`, style: tags.processingInstruction });
+    });
+    return {
+        defineNodes,
+        parseInline: [
+            {
+                name: BLOCK_MATH_DOLLAR,
+                parse(context, next, position) {
+                    if (next !== 36 || context.char(position + 1) !== 36) {
+                        return -1;
+                    }
+                    return addDelimiter(context, BLOCK_MATH_DOLLAR, position, true, true);
+                },
+            },
+            {
+                name: INLINE_MATH_DOLLAR,
+                parse(context, next, position) {
+                    if (next !== 36 || context.char(position + 1) === 36) {
+                        return -1;
+                    }
+                    return addDelimiter(context, INLINE_MATH_DOLLAR, position, true, true);
+                },
+            },
+            {
+                before: "Escape",
+                name: INLINE_MATH_BRACKET,
+                parse(context, next, position) {
+                    if (next !== 92 || ![40, 41].includes(context.char(position + 1))) {
+                        return -1;
+                    }
+                    return addDelimiter(context, INLINE_MATH_BRACKET, position, context.char(position + 1) === 40, context.char(position + 1) === 41);
+                },
+            },
+            {
+                before: "Escape",
+                name: BLOCK_MATH_BRACKET,
+                parse(context, next, position) {
+                    if (next !== 92 || ![91, 93].includes(context.char(position + 1))) {
+                        return -1;
+                    }
+                    return addDelimiter(context, BLOCK_MATH_BRACKET, position, context.char(position + 1) === 91, context.char(position + 1) === 93);
+                },
+            },
+        ],
+        wrap: parser
+            ? parseMixed((node) => {
+                const length = delimiterLength[node.type.name];
+                if (!length) {
+                    return null;
+                }
+                return {
+                    overlay: [
+                        {
+                            from: node.from + length,
+                            to: node.to - length,
+                        },
+                    ],
+                    parser,
+                };
+            })
+            : undefined,
+    };
+}
+function addDelimiter(context, name, position, open, close) {
+    const length = delimiterLength[name];
+    const delimiter = delimiters[name];
+    if (!length || !delimiter) {
+        return -1;
+    }
+    return context.addDelimiter(delimiter, position, position + length, open, close);
+}

package/dist/internal/codemirror/markdown/list-after-lazy-quote.d.ts

@@ -0,0 +1,10 @@
+import type { MarkdownConfig } from "@lezer/markdown";
+/**
+ * Keep CodeMirror's syntax tree aligned with the reading renderer when an
+ * unquoted list marker follows a lazily continued blockquote paragraph.
+ *
+ * Lezer otherwise keeps non-`1.` ordered markers inside the quote paragraph,
+ * which makes a following four-space list continuation parse as indented code.
+ */
+export declare const ListAfterLazyBlockquote: MarkdownConfig;
+//# sourceMappingURL=list-after-lazy-quote.d.ts.map

package/dist/internal/codemirror/markdown/list-after-lazy-quote.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-after-lazy-quote.d.ts","sourceRoot":"","sources":["../../../../src/internal/codemirror/markdown/list-after-lazy-quote.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAsB,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAiB1E;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,EAAE,cAarC,CAAC"}

package/dist/internal/codemirror/markdown/list-after-lazy-quote.js

@@ -0,0 +1,28 @@
+function droppedBlockquoteContext(context, line) {
+    const handledDepth = Math.min(line.depth, context.depth);
+    for (let depth = handledDepth; depth < context.depth; depth += 1) {
+        if (context.parentType(depth).name === "Blockquote") {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Keep CodeMirror's syntax tree aligned with the reading renderer when an
+ * unquoted list marker follows a lazily continued blockquote paragraph.
+ *
+ * Lezer otherwise keeps non-`1.` ordered markers inside the quote paragraph,
+ * which makes a following four-space list continuation parse as indented code.
+ */
+export const ListAfterLazyBlockquote = {
+    parseBlock: [
+        {
+            name: "ListAfterLazyBlockquote",
+            before: "OrderedList",
+            endLeaf(context, line) {
+                return (droppedBlockquoteContext(context, line) &&
+                    /^(?:[-+*]|\d+[.)])\s+/u.test(line.text.slice(line.pos)));
+            },
+        },
+    ],
+};

package/dist/internal/codemirror/markdown/paste.d.ts

@@ -0,0 +1,5 @@
+import type { Extension } from "@codemirror/state";
+import type { MiraSmartPasteConfig } from "@lapismd/mira/extensions";
+export declare function convertHtmlToMarkdown(html: string): Promise<string>;
+export declare function createMarkdownSmartPasteExtension(config?: boolean | MiraSmartPasteConfig): Extension;
+//# sourceMappingURL=paste.d.ts.map

package/dist/internal/codemirror/markdown/paste.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paste.d.ts","sourceRoot":"","sources":["../../../../src/internal/codemirror/markdown/paste.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAOrE,wBAAsB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CASzE;AAED,wBAAgB,iCAAiC,CAC/C,MAAM,GAAE,OAAO,GAAG,oBAAyB,GAC1C,SAAS,CAwDX"}

package/dist/internal/codemirror/markdown/paste.js

@@ -0,0 +1,84 @@
+import remarkGridTable from "@adobe/remark-gridtables";
+import { EditorView } from "@codemirror/view";
+import rehypeParse from "rehype-parse";
+import rehypeRemark from "rehype-remark";
+import remarkGfm from "remark-gfm";
+import remarkStringify from "remark-stringify";
+import { unified } from "unified";
+export async function convertHtmlToMarkdown(html) {
+    const file = await unified()
+        .use(rehypeParse)
+        .use(rehypeRemark)
+        .use(remarkGfm)
+        .use(remarkGridTable)
+        .use(remarkStringify)
+        .process(html);
+    return String(file);
+}
+export function createMarkdownSmartPasteExtension(config = {}) {
+    const resolved = resolveSmartPasteConfig(config);
+    if (!resolved.enabled) {
+        return [];
+    }
+    return EditorView.domEventHandlers({
+        paste(event, view) {
+            if (clipboardHasImageFile(event.clipboardData)) {
+                return false;
+            }
+            const html = event.clipboardData?.getData("text/html") ?? "";
+            const plainText = event.clipboardData?.getData("text/plain") ?? "";
+            if (resolved.html && html) {
+                event.preventDefault();
+                const selection = view.state.selection.main;
+                void Promise.resolve((resolved.convertHtml ?? convertHtmlToMarkdown)(html))
+                    .then((markdown) => {
+                    replaceSelection(view, markdown, selection.from, selection.to);
+                })
+                    .catch((error) => {
+                    resolved.onError?.(error);
+                    if (plainText) {
+                        replaceSelection(view, plainText, selection.from, selection.to);
+                    }
+                });
+                return true;
+            }
+            if (resolved.urlOverSelection &&
+                /^https?:\/\/\S+$/u.test(plainText.trim())) {
+                const selection = view.state.selection.main;
+                const selectedText = view.state.doc.sliceString(selection.from, selection.to);
+                if (selectedText) {
+                    event.preventDefault();
+                    replaceSelection(view, `[${selectedText}](${plainText.trim()})`, selection.from, selection.to);
+                    return true;
+                }
+            }
+            return false;
+        },
+    });
+}
+function resolveSmartPasteConfig(config) {
+    if (config === false) {
+        return { enabled: false, html: false, urlOverSelection: false };
+    }
+    const resolved = typeof config === "object" ? config : {};
+    return {
+        enabled: resolved.enabled ?? true,
+        html: resolved.html ?? true,
+        urlOverSelection: resolved.urlOverSelection ?? true,
+        ...resolved,
+    };
+}
+function clipboardHasImageFile(clipboard) {
+    return Array.from(clipboard?.items ?? []).some((item) => item.kind === "file" && item.type.startsWith("image/"));
+}
+function replaceSelection(view, insert, from, to) {
+    const safeFrom = Math.min(from, view.state.doc.length);
+    const safeTo = Math.min(Math.max(safeFrom, to), view.state.doc.length);
+    view.dispatch({
+        changes: { from: safeFrom, insert, to: safeTo },
+        selection: { anchor: safeFrom + insert.length },
+        scrollIntoView: true,
+        userEvent: "input.paste",
+    });
+    view.focus();
+}

package/dist/internal/codemirror/markdown/showcase-fixture.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=showcase-fixture.test.d.ts.map

package/dist/internal/codemirror/markdown/showcase-fixture.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"showcase-fixture.test.d.ts","sourceRoot":"","sources":["../../../../src/internal/codemirror/markdown/showcase-fixture.test.ts"],"names":[],"mappings":""}

package/dist/internal/codemirror/markdown/showcase-fixture.test.js

@@ -0,0 +1,50 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { ensureSyntaxTree } from "@codemirror/language";
+import { EditorState } from "@codemirror/state";
+import { describe, expect, it } from "vitest";
+import { createMarkdownCodeMirrorExtensions } from ".";
+const fixturePath = path.resolve(import.meta.dirname, "../../../../../../stories/markdown/layout/CodeMirror Layout Showcase.md");
+describe("Mira CodeMirror Layout Showcase fixture", () => {
+    it("exercises the parser extensions used by every editor mode", () => {
+        const source = readFileSync(fixturePath, "utf8");
+        const state = EditorState.create({
+            doc: source,
+            extensions: createMarkdownCodeMirrorExtensions(),
+        });
+        const tree = ensureSyntaxTree(state, state.doc.length, 1_000);
+        expect(tree).not.toBeNull();
+        const cursor = tree.cursor();
+        const names = [];
+        function walk() {
+            names.push(cursor.name);
+            if (!cursor.firstChild()) {
+                return;
+            }
+            do {
+                walk();
+            } while (cursor.nextSibling());
+            cursor.parent();
+        }
+        walk();
+        expect(names).toEqual(expect.arrayContaining([
+            "Document",
+            "ATXHeading1",
+            "ATXHeading2",
+            "Table",
+            "GridTable",
+            "Blockquote",
+            "BulletList",
+            "OrderedList",
+            "WikiLink",
+            "EmbedLink",
+            "PathLink",
+            "Tag",
+            "InlineDirective",
+            "LeafDirective",
+            "FencedCode",
+            "BlockMathDollar",
+            "InlineMathDollar",
+        ]));
+    });
+});

package/dist/internal/codemirror/markdown/types.d.ts

@@ -0,0 +1,6 @@
+declare module "@adobe/remark-gridtables" {
+  import type { Plugin } from "unified";
+
+  const remarkGridTable: Plugin;
+  export default remarkGridTable;
+}

package/dist/internal/codemirror/rich/block-controls.d.ts

@@ -0,0 +1,4 @@
+import { type Extension } from "@codemirror/state";
+import type { MiraRichEditorOptions } from "./types";
+export declare function blockControlExtensions(options: MiraRichEditorOptions): Extension[];
+//# sourceMappingURL=block-controls.d.ts.map

package/dist/internal/codemirror/rich/block-controls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block-controls.d.ts","sourceRoot":"","sources":["../../../../src/internal/codemirror/rich/block-controls.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,SAAS,EAEf,MAAM,mBAAmB,CAAC;AAqB3B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAoHrD,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,qBAAqB,GAC7B,SAAS,EAAE,CA0Bb"}