@lapismd/mira 0.0.1

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

@@ -0,0 +1,154 @@
+import { tags as highlightTags } from "@lezer/highlight";
+import { BlockContext, } from "@lezer/markdown";
+function createAttributeElements(context, text, start) {
+    if (!text) {
+        return [];
+    }
+    const elements = [];
+    const attribute = /([A-Za-z_][\w-]*)(?:=(?:"([^"]*)"|'([^']*)'|([^\s]+)))?/g;
+    let match;
+    while ((match = attribute.exec(text)) !== null) {
+        const key = match[1] ?? "";
+        const value = match[2] ?? match[3] ?? match[4];
+        const nameStart = start + match.index;
+        elements.push(context.elt("DirectiveAttrName", nameStart, nameStart + key.length));
+        if (value !== undefined) {
+            const rawValue = match[0].slice(key.length + 1);
+            const valueStart = nameStart + key.length + 1;
+            elements.push(context.elt("DirectiveAttrValue", valueStart, valueStart + rawValue.length));
+        }
+    }
+    return elements;
+}
+function parseDirectiveMetadata(context, source, start, markerLength, name, argsText, attrsText) {
+    const children = [
+        context.elt("DirectiveMark", start, start + markerLength),
+    ];
+    const nameOffset = source.indexOf(name, markerLength);
+    const nameStart = start + Math.max(markerLength, nameOffset);
+    children.push(context.elt("DirectiveName", nameStart, nameStart + name.length));
+    if (argsText !== undefined) {
+        const bracketStart = source.indexOf("[", nameOffset + name.length);
+        const bracketEnd = source.indexOf("]", bracketStart + 1);
+        if (bracketStart !== -1 && bracketEnd !== -1) {
+            const rawArgs = source.slice(bracketStart + 1, bracketEnd);
+            const leadingWhitespace = rawArgs.length - rawArgs.trimStart().length;
+            const contentStart = start + bracketStart + 1 + leadingWhitespace;
+            const contentEnd = contentStart + argsText.trim().length;
+            const argsChildren = [
+                context.elt("DirectiveDelimiter", start + bracketStart, start + bracketStart + 1),
+                context.elt("DirectiveDelimiter", start + bracketEnd, start + bracketEnd + 1),
+            ];
+            if (argsText.trim() && "parser" in context) {
+                argsChildren.push(...context.parser.parseInline(argsText.trim(), contentStart));
+            }
+            children.push(context.elt("DirectiveArgs", contentStart, contentEnd, argsChildren));
+        }
+    }
+    if (attrsText !== undefined) {
+        const braceStart = source.indexOf("{", nameOffset + name.length);
+        if (braceStart !== -1) {
+            const rawAttrs = source.slice(braceStart + 1, source.indexOf("}", braceStart));
+            const leadingWhitespace = rawAttrs.length - rawAttrs.trimStart().length;
+            children.push(...createAttributeElements(context, attrsText.trim(), start + braceStart + 1 + leadingWhitespace));
+        }
+    }
+    return children;
+}
+class LeafDirectiveParser {
+    nextLine() {
+        return false;
+    }
+    finish(context, leaf) {
+        const match = /^\s*::([A-Za-z0-9_-]+)(?:\[\s*([^\]]*)\s*\])?(?:\{\s*([^}]*)\s*\})?/.exec(leaf.content);
+        if (!match) {
+            return false;
+        }
+        const [source, name = "", argsText, attrsText] = match;
+        const leadingWhitespace = source.length - source.trimStart().length;
+        const start = leaf.start + leadingWhitespace;
+        const trimmedSource = source.trimStart();
+        context.addLeafElement(leaf, context.elt("LeafDirective", leaf.start, leaf.start + leaf.content.length, parseDirectiveMetadata(context, trimmedSource, start, 2, name, argsText, attrsText)));
+        return true;
+    }
+}
+function parseInlineDirective(context, next, position) {
+    if (next !== 58 /* : */) {
+        return -1;
+    }
+    const match = /^:([A-Za-z0-9_-]+)(?:\[\s*([^\]]*)\s*\])?(?:\{\s*([^}]*)\s*\})?/.exec(context.slice(position, context.end));
+    if (!match) {
+        return -1;
+    }
+    const [source, name = "", argsText, attrsText] = match;
+    return context.addElement(context.elt("InlineDirective", position, position + source.length, parseDirectiveMetadata(context, source, position, 1, name, argsText, attrsText)));
+}
+function parseContainerDirective(context, line) {
+    const match = /^(:{3,})\s*([A-Za-z0-9_-]+)(?:\[\s*([^\]]*)\s*\])?(?:\{\s*([^}]*)\s*\})?/.exec(line.text);
+    if (!match) {
+        return false;
+    }
+    const [source, marker = ":::", name = "", argsText, attrsText] = match;
+    const start = context.lineStart + line.pos;
+    context.startComposite("ContainerDirective", line.pos, marker.length);
+    context.addElement(context.elt("ContainerDirective", start, start + line.text.length, parseDirectiveMetadata(context, source, start, marker.length, name, argsText, attrsText)));
+    context.nextLine();
+    return null;
+}
+export const GenericDirectives = {
+    defineNodes: [
+        { name: "InlineDirective" },
+        { name: "LeafDirective", block: true },
+        {
+            name: "ContainerDirective",
+            block: true,
+            composite(context, line, markerLength) {
+                const match = /^(:{3,})\s*$/.exec(line.text);
+                if (!match || (match[1]?.length ?? 0) < markerLength) {
+                    return true;
+                }
+                const markerStart = context.lineStart + line.pos + match[0].indexOf(":");
+                const stack = context.stack;
+                const block = stack[line.depth];
+                if (block) {
+                    block.end = context.lineStart + line.text.length;
+                }
+                context.addElement(context.elt("DirectiveMark", markerStart, markerStart + (match[1]?.length ?? markerLength)));
+                return false;
+            },
+        },
+        { name: "DirectiveMark", style: highlightTags.processingInstruction },
+        { name: "DirectiveName", style: highlightTags.variableName },
+        { name: "DirectiveArgs", style: highlightTags.content },
+        { name: "DirectiveAttrName", style: highlightTags.attributeName },
+        {
+            name: "DirectiveAttrDelimiter",
+            style: highlightTags.processingInstruction,
+        },
+        { name: "DirectiveDelimiter", style: highlightTags.processingInstruction },
+        { name: "DirectiveAttrValue", style: highlightTags.attributeValue },
+    ],
+    parseBlock: [
+        {
+            name: "ContainerDirective",
+            parse: parseContainerDirective,
+            before: "SetextHeading",
+        },
+        {
+            name: "LeafDirective",
+            leaf(_, leaf) {
+                return /^\s*::\s*([A-Za-z0-9_-]+)?\s*(?:\[\s*([^\]]*)\s*\])?\s*(?:\{\s*([^}]*)\s*\})?/.test(leaf.content)
+                    ? new LeafDirectiveParser()
+                    : null;
+            },
+            before: "SetextHeading",
+        },
+    ],
+    parseInline: [
+        {
+            name: "InlineDirective",
+            parse: parseInlineDirective,
+            before: "Link",
+        },
+    ],
+};

package/dist/internal/codemirror/markdown/grid-table.d.ts

@@ -0,0 +1,3 @@
+import type { MarkdownConfig } from "@lezer/markdown";
+export declare const GridTable: MarkdownConfig;
+//# sourceMappingURL=grid-table.d.ts.map

package/dist/internal/codemirror/markdown/grid-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grid-table.d.ts","sourceRoot":"","sources":["../../../../src/internal/codemirror/markdown/grid-table.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAMV,cAAc,EACf,MAAM,iBAAiB,CAAC;AA0JzB,eAAO,MAAM,SAAS,EAAE,cAkCvB,CAAC"}

package/dist/internal/codemirror/markdown/grid-table.js

@@ -0,0 +1,129 @@
+import { tags } from "@lezer/highlight";
+function parseRow(context, line, startIndex = 0, elements, offset = 0) {
+    let count = 0;
+    let first = true;
+    let cellStart = -1;
+    let cellEnd = -1;
+    let escaped = false;
+    const parseCell = () => {
+        elements?.push(context.elt("GridTableCell", offset + cellStart, offset + cellEnd, context.parser.parseInline(line.slice(cellStart, cellEnd), offset + cellStart)));
+    };
+    for (let index = startIndex; index < line.length; index += 1) {
+        const next = line.charCodeAt(index);
+        if (next === 43) {
+            const rest = line.substring(index);
+            if (isHorizontalSeparator(rest)) {
+                elements?.push(context.elt("GridTableDivider", index + offset, index + offset + rest.length));
+                return count;
+            }
+        }
+        else if (next === 124 && !escaped) {
+            if (!first || cellStart > -1) {
+                count += 1;
+            }
+            first = false;
+            if (cellStart > -1) {
+                parseCell();
+            }
+            elements?.push(context.elt("GridTableDelimiter", index + offset, index + offset + 1));
+            cellStart = -1;
+            cellEnd = -1;
+        }
+        else if (escaped || (next !== 32 && next !== 9)) {
+            if (cellStart < 0) {
+                cellStart = index;
+            }
+            cellEnd = index + 1;
+        }
+        escaped = !escaped && next === 92;
+    }
+    if (cellStart > -1) {
+        count += 1;
+        parseCell();
+    }
+    return count;
+}
+class GridTableParser {
+    lines = [];
+    rows = [];
+    isComplete = false;
+    constructor(line) {
+        this.lines.push(line);
+    }
+    nextLine(context, line) {
+        const lineText = line.text.slice(line.pos);
+        this.lines.push(lineText);
+        const content = [];
+        if (isHorizontalSeparator(lineText)) {
+            content.push(context.elt("GridTableDelimiter", context.lineStart + line.pos, context.lineStart + line.text.length));
+        }
+        parseRow(context, lineText.trim(), line.pos, content, context.lineStart);
+        if (this.lines.length > 1) {
+            const trimmed = lineText.trim();
+            if (trimmed === "" ||
+                (!this.isGridTableLine(trimmed) && this.lines.length > 2)) {
+                this.isComplete = true;
+                return true;
+            }
+        }
+        this.rows.push(...content);
+        return false;
+    }
+    finish(context, leaf) {
+        context.addLeafElement(leaf, context.elt("GridTable", leaf.start, leaf.start + leaf.content.length, [
+            context.elt("GridTableDelimiter", leaf.start, leaf.start + this.lines[0].length),
+            ...this.rows,
+        ]));
+        return true;
+    }
+    isGridTableLine(line) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            return false;
+        }
+        if (isHorizontalSeparator(trimmed)) {
+            return true;
+        }
+        return (trimmed.includes("|") && (trimmed.startsWith("|") || /^\s*\|/.test(line)));
+    }
+}
+const gridTableSeparatorPattern = /^(\+[:>]?[=-]+[vx^]?[=-]*[:<]?)+\+$/;
+function hasGridTableMarker(value) {
+    return gridTableSeparatorPattern.test(value.trim());
+}
+function isHorizontalSeparator(line) {
+    return gridTableSeparatorPattern.test(line.trim());
+}
+export const GridTable = {
+    defineNodes: [
+        { name: "GridTable", block: true },
+        { name: "GridTableHeader", style: { "GridTableHeader/...": tags.heading } },
+        "GridTableRow",
+        { name: "GridTableCell", style: tags.content },
+        { name: "GridTableDivider", style: tags.processingInstruction },
+        { name: "GridTableDelimiter", style: tags.processingInstruction },
+    ],
+    parseBlock: [
+        {
+            name: "GridTable",
+            leaf(_, leaf) {
+                if (hasGridTableMarker(leaf.content)) {
+                    return new GridTableParser(leaf.content);
+                }
+                return null;
+            },
+            endLeaf(_, line, leaf) {
+                const parser = leaf.parsers.find((candidate) => candidate instanceof GridTableParser);
+                if (!parser) {
+                    return false;
+                }
+                if (parser.isComplete) {
+                    return true;
+                }
+                const lineText = line.text.slice(line.pos).trim();
+                return lineText === "" || !parser.isGridTableLine(lineText);
+            },
+            before: "Table",
+        },
+    ],
+};

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

@@ -0,0 +1,16 @@
+import type { LanguageDescription } from "@codemirror/language";
+import type { Extension } from "@codemirror/state";
+export { createMarkdownAuthoringExtensions, type MiraMarkdownAuthoringOptions, } from "./authoring";
+export { createMarkdownCompletionExtensions, createMarkdownCompletionSources, formatMiraInternalLink, type MiraMarkdownCompletionOptions, } from "./completion";
+export { createMarkdownInputHandlerExtensions } from "./input-handlers";
+export { convertHtmlToMarkdown, createMarkdownSmartPasteExtension, } from "./paste";
+export { GenericDirectives } from "./directives";
+export { EmbedLinkParser, PathLinkParser, TagParser, WikiLinkParser, } from "./lapis-inline";
+export type MiraMarkdownCodeMirrorOptions = {
+    codeLanguages?: LanguageDescription[];
+    sourceMode?: boolean;
+};
+export declare function createMiraMarkdownLanguage(codeLanguages?: LanguageDescription[]): Extension;
+export declare function createMarkdownCodeMirrorExtensions(options?: MiraMarkdownCodeMirrorOptions): Extension[];
+export declare function markdownSourceDecorations(): Extension;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/internal/codemirror/markdown/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAEhE,OAAO,KAAK,EAAE,SAAS,EAAS,MAAM,mBAAmB,CAAC;AAsB1D,OAAO,EACL,iCAAiC,EACjC,KAAK,4BAA4B,GAClC,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,kCAAkC,EAClC,+BAA+B,EAC/B,sBAAsB,EACtB,KAAK,6BAA6B,GACnC,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,oCAAoC,EAAE,MAAM,kBAAkB,CAAC;AACxE,OAAO,EACL,qBAAqB,EACrB,iCAAiC,GAClC,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,EACL,eAAe,EACf,cAAc,EACd,SAAS,EACT,cAAc,GACf,MAAM,gBAAgB,CAAC;AAExB,MAAM,MAAM,6BAA6B,GAAG;IAC1C,aAAa,CAAC,EAAE,mBAAmB,EAAE,CAAC;IACtC,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF,wBAAgB,0BAA0B,CACxC,aAAa,GAAE,mBAAmB,EAAO,GACxC,SAAS,CAiBX;AAcD,wBAAgB,kCAAkC,CAChD,OAAO,GAAE,6BAAkC,GAC1C,SAAS,EAAE,CAUb;AAED,wBAAgB,yBAAyB,IAAI,SAAS,CAIrD"}

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

@@ -0,0 +1,125 @@
+import { markdown } from "@codemirror/lang-markdown";
+import { yamlFrontmatter } from "@codemirror/lang-yaml";
+import { languages } from "@codemirror/language-data";
+import { Decoration, EditorView, ViewPlugin, } from "@codemirror/view";
+import { Table } from "@lezer/markdown";
+import { getTaskMarkerRange } from "../rich/utils/tasks";
+import { GenericDirectives } from "./directives";
+import { GridTable } from "./grid-table";
+import { ListAfterLazyBlockquote } from "./list-after-lazy-quote";
+import { parseLatex } from "./latex";
+import { EmbedLinkParser, PathLinkParser, TagParser, WikiLinkParser, } from "./lapis-inline";
+export { createMarkdownAuthoringExtensions, } from "./authoring";
+export { createMarkdownCompletionExtensions, createMarkdownCompletionSources, formatMiraInternalLink, } from "./completion";
+export { createMarkdownInputHandlerExtensions } from "./input-handlers";
+export { convertHtmlToMarkdown, createMarkdownSmartPasteExtension, } from "./paste";
+export { GenericDirectives } from "./directives";
+export { EmbedLinkParser, PathLinkParser, TagParser, WikiLinkParser, } from "./lapis-inline";
+export function createMiraMarkdownLanguage(codeLanguages = []) {
+    return yamlFrontmatter({
+        content: markdown({
+            codeLanguages: [...languages, ...codeLanguages],
+            extensions: [
+                ListAfterLazyBlockquote,
+                Table,
+                GridTable,
+                GenericDirectives,
+                EmbedLinkParser,
+                WikiLinkParser,
+                PathLinkParser,
+                TagParser,
+                parseLatex(),
+            ],
+        }),
+    });
+}
+const wikiLinkMark = Decoration.mark({
+    class: "cm-internal-link cm-wikilink",
+});
+const embedMark = Decoration.mark({
+    class: "cm-internal-link cm-embed-link",
+});
+const tagMark = Decoration.mark({ class: "cm-hashtag" });
+const taskFormattingMark = Decoration.mark({
+    class: "cm-formatting cm-formatting-task",
+});
+const frontmatterMark = Decoration.line({ class: "cm-hmd-frontmatter" });
+export function createMarkdownCodeMirrorExtensions(options = {}) {
+    return [
+        createMiraMarkdownLanguage(options.codeLanguages),
+        markdownSourceDecorations(),
+        EditorView.editorAttributes.of({
+            class: options.sourceMode
+                ? "mira-markdown-source markdown-source-view"
+                : "mira-markdown-source",
+        }),
+    ];
+}
+export function markdownSourceDecorations() {
+    return ViewPlugin.fromClass(MarkdownSourceDecorations, {
+        decorations: (value) => value.decorations,
+    });
+}
+class MarkdownSourceDecorations {
+    view;
+    decorations;
+    constructor(view) {
+        this.view = view;
+        this.decorations = buildDecorations(view);
+    }
+    update(update) {
+        if (update.docChanged || update.viewportChanged) {
+            this.decorations = buildDecorations(update.view);
+        }
+    }
+}
+function buildDecorations(view) {
+    const ranges = [];
+    const frontmatter = getFrontmatterRange(view.state.doc.toString());
+    for (const visibleRange of view.visibleRanges) {
+        let line = view.state.doc.lineAt(visibleRange.from);
+        while (line.from <= visibleRange.to) {
+            if (frontmatter &&
+                line.from >= frontmatter.from &&
+                line.to <= frontmatter.to) {
+                ranges.push(frontmatterMark.range(line.from));
+            }
+            decorateInlineMarkdown(line.text, line.from, ranges);
+            if (line.to >= visibleRange.to || line.number >= view.state.doc.lines) {
+                break;
+            }
+            line = view.state.doc.line(line.number + 1);
+        }
+    }
+    return Decoration.set(ranges, true);
+}
+function decorateInlineMarkdown(text, lineStart, ranges) {
+    const taskRange = getTaskMarkerRange(text, lineStart);
+    if (taskRange) {
+        ranges.push(taskFormattingMark.range(taskRange.checkboxStart, taskRange.checkboxEnd));
+    }
+    for (const match of text.matchAll(/!\[\[[^\]\n]+]]/g)) {
+        ranges.push(embedMark.range(lineStart + match.index, lineStart + match.index + match[0].length));
+    }
+    for (const match of text.matchAll(/(?<!!)\[\[[^\]\n]+]]/g)) {
+        ranges.push(wikiLinkMark.range(lineStart + match.index, lineStart + match.index + match[0].length));
+    }
+    for (const match of text.matchAll(/(^|[\s([{])#[\p{L}\p{N}_/-]+/gu)) {
+        const prefixLength = match[1]?.length ?? 0;
+        const from = lineStart + match.index + prefixLength;
+        ranges.push(tagMark.range(from, from + match[0].length - prefixLength));
+    }
+}
+function getFrontmatterRange(doc) {
+    if (!doc.startsWith("---\n")) {
+        return null;
+    }
+    const end = doc.indexOf("\n---", 4);
+    if (end === -1) {
+        return null;
+    }
+    return {
+        from: 0,
+        to: end + 4,
+    };
+}

package/dist/internal/codemirror/markdown/index.test.d.ts

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

package/dist/internal/codemirror/markdown/index.test.d.ts.map

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

package/dist/internal/codemirror/markdown/index.test.js

@@ -0,0 +1,158 @@
+import { describe, expect, it } from "vitest";
+import { syntaxTree } from "@codemirror/language";
+import { EditorState } from "@codemirror/state";
+import { EditorView } from "@codemirror/view";
+import { createMarkdownCodeMirrorExtensions } from ".";
+describe("createMarkdownCodeMirrorExtensions", () => {
+    it("returns markdown language and decoration extensions", () => {
+        expect(createMarkdownCodeMirrorExtensions()).toHaveLength(3);
+    });
+    it("parses Lapis-style grid tables", () => {
+        const state = EditorState.create({
+            doc: [
+                "+---------+----------+",
+                "| Feature | Behavior |",
+                "+=========+==========+",
+                "| Menus   | Actions  |",
+                "+---------+----------+",
+            ].join("\n"),
+            extensions: createMarkdownCodeMirrorExtensions(),
+        });
+        expect(syntaxTree(state).toString()).toContain("GridTable");
+    });
+    it("starts a list after a lazy blockquote before parsing its indented quote", () => {
+        const state = EditorState.create({
+            doc: [
+                "- Unordered parent",
+                "  > Quoted paragraph",
+                "  > > Nested quote keeps a second quote guide.",
+                "3. Blockquote inside a list item:",
+                "",
+                "    > Skip a line and indent the quote markers four spaces.",
+                "    > The rendered blockquote stays attached to its first source line.",
+            ].join("\n"),
+            extensions: createMarkdownCodeMirrorExtensions(),
+        });
+        const tree = syntaxTree(state).toString();
+        expect(tree).toContain("BulletList(ListItem(ListMark,Paragraph,Blockquote(QuoteMark,Paragraph,QuoteMark,Blockquote");
+        expect(tree).toContain("OrderedList(ListItem(ListMark,Paragraph,Blockquote(QuoteMark,Paragraph(QuoteMark))))");
+        expect(tree).not.toContain("CodeBlock");
+    });
+    it("marks quoted task delimiters for source-mode styling", async () => {
+        const parent = document.createElement("div");
+        document.body.append(parent);
+        const view = new EditorView({
+            doc: "  >   - [ ] Quoted checklist child",
+            extensions: createMarkdownCodeMirrorExtensions({ sourceMode: true }),
+            parent,
+        });
+        await new Promise((resolve) => requestAnimationFrame(() => resolve(null)));
+        const delimiter = parent.querySelector(".cm-formatting-task");
+        expect(delimiter?.textContent).toBe("[ ]");
+        view.destroy();
+        parent.remove();
+    });
+    it.each([
+        ["justify", ["+>-----<+", "| A b C |", "+-------+"]],
+        ["center", ["+:-----:+", "|  ABC  |", "+-------+"]],
+        ["left", ["+:------+", "| ABC   |", "+------+"]],
+        ["right", ["+------:+", "|   ABC |", "+------+"]],
+        [
+            "top",
+            [
+                "+---^---+",
+                "| Larum |",
+                "| Ipsum |",
+                "|       |",
+                "|       |",
+                "+-------+",
+            ],
+        ],
+        [
+            "middle",
+            [
+                "+---x---+",
+                "|       |",
+                "| Larum |",
+                "| Ipsum |",
+                "|       |",
+                "+-------+",
+            ],
+        ],
+        [
+            "bottom",
+            [
+                "+---v---+",
+                "|       |",
+                "|       |",
+                "| Larum |",
+                "| Ipsum |",
+                "+-------+",
+            ],
+        ],
+    ])("parses Adobe %s alignment grid table separators", (_, markdown) => {
+        const state = EditorState.create({
+            doc: markdown.join("\n"),
+            extensions: createMarkdownCodeMirrorExtensions(),
+        });
+        expect(syntaxTree(state).toString()).toContain("GridTable");
+    });
+    it("parses Lapis wikilink, embed, pathlink, and tag nodes", () => {
+        const state = EditorState.create({
+            doc: [
+                "[[Project Plan#Section|Plan]]",
+                "![[Architecture Diagram#Overview|Diagram]]",
+                "[Project](notes/Project Plan.md)",
+                "#mira/editor",
+            ].join("\n"),
+            extensions: createMarkdownCodeMirrorExtensions(),
+        });
+        const tree = syntaxTree(state).toString();
+        expect(tree).toContain("WikiLink");
+        expect(tree).toContain("WikiLinkPath");
+        expect(tree).toContain("WikiLinkAnchor");
+        expect(tree).toContain("WikiLinkText");
+        expect(tree).toContain("EmbedLink");
+        expect(tree).toContain("EmbedLinkPath");
+        expect(tree).toContain("EmbedLinkAnchor");
+        expect(tree).toContain("EmbedLinkText");
+        expect(tree).toContain("PathLink");
+        expect(tree).toContain("PathLinkDestination");
+        expect(tree).toContain("Tag");
+        expect(tree).toContain("TagName");
+    });
+    it("parses single-backslash bracket math delimiters", () => {
+        const state = EditorState.create({
+            doc: ["inline \\(x + 1\\)", "\\[", "x + 1", "\\]"].join("\n"),
+            extensions: createMarkdownCodeMirrorExtensions(),
+        });
+        const tree = syntaxTree(state).toString();
+        expect(tree).toContain("InlineMathBracket");
+        expect(tree).toContain("BlockMathBracket");
+    });
+    it("parses container, leaf, and inline directives structurally", () => {
+        const state = EditorState.create({
+            doc: [
+                ':::cell[Load data]{lang="ts"}',
+                "```ts",
+                "const value = 1;",
+                "```",
+                ":::",
+                "",
+                "::badge[Stable]{tone=success}",
+                "",
+                'Use :abbr[HTML]{title="HyperText Markup Language"}.',
+            ].join("\n"),
+            extensions: createMarkdownCodeMirrorExtensions(),
+        });
+        const tree = syntaxTree(state).toString();
+        expect(tree).toContain("ContainerDirective");
+        expect(tree).toContain("LeafDirective");
+        expect(tree).toContain("InlineDirective");
+        expect(tree).toContain("DirectiveName");
+        expect(tree).toContain("DirectiveArgs");
+        expect(tree).toContain("DirectiveAttrName");
+        expect(tree).toContain("DirectiveAttrValue");
+        expect(tree).toContain("FencedCode");
+    });
+});

package/dist/internal/codemirror/markdown/input-handlers.d.ts

@@ -0,0 +1,4 @@
+import type { Extension } from "@codemirror/state";
+import type { MiraMarkdownInputHandlerConfig } from "@lapismd/mira/extensions";
+export declare function createMarkdownInputHandlerExtensions(config?: boolean | MiraMarkdownInputHandlerConfig): Extension[];
+//# sourceMappingURL=input-handlers.d.ts.map

package/dist/internal/codemirror/markdown/input-handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-handlers.d.ts","sourceRoot":"","sources":["../../../../src/internal/codemirror/markdown/input-handlers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,0BAA0B,CAAC;AAE/E,wBAAgB,oCAAoC,CAClD,MAAM,GAAE,OAAO,GAAG,8BAAmC,GACpD,SAAS,EAAE,CAoEb"}

package/dist/internal/codemirror/markdown/input-handlers.js

@@ -0,0 +1,56 @@
+import { EditorView } from "@codemirror/view";
+export function createMarkdownInputHandlerExtensions(config = {}) {
+    if (config === false ||
+        (typeof config === "object" && config.enabled === false)) {
+        return [];
+    }
+    const resolved = typeof config === "object"
+        ? config
+        : {};
+    const codeFence = resolved.codeFence ?? true;
+    const frontmatter = resolved.frontmatter ?? true;
+    const ellipsis = resolved.ellipsis ?? false;
+    return [
+        EditorView.inputHandler.of((view, from, to, text) => {
+            const line = view.state.doc.lineAt(from);
+            if (codeFence && text === "`" && from === line.to && line.text === "``") {
+                view.dispatch({
+                    changes: { from: line.from, insert: "```\n```", to },
+                    selection: { anchor: line.from + 3 },
+                    userEvent: "input.type",
+                });
+                return true;
+            }
+            if (frontmatter &&
+                ((text === "-" && from === 2 && view.state.sliceDoc(0, 2) === "--") ||
+                    (text === "-" && from === 1 && view.state.sliceDoc(0, 1) === "—"))) {
+                view.dispatch({
+                    changes: { from: 0, insert: "---\n\n---", to },
+                    selection: { anchor: 4 },
+                    userEvent: "input.type",
+                });
+                return true;
+            }
+            if (ellipsis &&
+                text === "." &&
+                from >= 2 &&
+                view.state.sliceDoc(from - 2, from) === "..") {
+                view.dispatch({
+                    changes: { from: from - 2, insert: "…", to },
+                    selection: { anchor: from - 1 },
+                    userEvent: "input.type",
+                });
+                return true;
+            }
+            if (ellipsis && text === "...") {
+                view.dispatch({
+                    changes: { from, insert: "…", to },
+                    selection: { anchor: from + 1 },
+                    userEvent: "input.type",
+                });
+                return true;
+            }
+            return false;
+        }),
+    ];
+}