@lapismd/mira 0.0.1

package/dist/preview/remark/custom-checklists.d.ts

@@ -0,0 +1,25 @@
+import type { Root } from "mdast";
+import type { Plugin } from "unified";
+import type { Node } from "unist";
+declare module "micromark-util-types" {
+    interface TokenTypeMap {
+        taskListCustomCheck: "taskListCustomCheck";
+        taskListCustomCheckMarker: "taskListCustomCheckMarker";
+        taskListCustomCheckValueChecked: "taskListCustomCheckValueChecked";
+    }
+}
+type CheckList = Node & {
+    type: "checkList";
+    value: string;
+};
+declare module "mdast" {
+    interface RootContentMap {
+        checkList: CheckList;
+    }
+    interface PhrasingContentMap {
+        checkList: CheckList;
+    }
+}
+export declare const remarkCustomChecklists: Plugin<[], Root>;
+export {};
+//# sourceMappingURL=custom-checklists.d.ts.map

package/dist/preview/remark/custom-checklists.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom-checklists.d.ts","sourceRoot":"","sources":["../../../src/preview/remark/custom-checklists.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAuB,IAAI,EAAQ,MAAM,OAAO,CAAC;AAC7D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AACtC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC;AAGlC,OAAO,QAAQ,sBAAsB,CAAC;IACpC,UAAU,YAAY;QACpB,mBAAmB,EAAE,qBAAqB,CAAC;QAC3C,yBAAyB,EAAE,2BAA2B,CAAC;QACvD,+BAA+B,EAAE,iCAAiC,CAAC;KACpE;CACF;AAMD,KAAK,SAAS,GAAG,IAAI,GAAG;IACtB,IAAI,EAAE,WAAW,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,OAAO,QAAQ,OAAO,CAAC;IACrB,UAAU,cAAc;QACtB,SAAS,EAAE,SAAS,CAAC;KACtB;IAED,UAAU,kBAAkB;QAC1B,SAAS,EAAE,SAAS,CAAC;KACtB;CACF;AAED,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,EAAE,EAAE,IAAI,CAsCnD,CAAC"}

package/dist/preview/remark/custom-checklists.js

@@ -0,0 +1,204 @@
+import { factorySpace } from "micromark-factory-space";
+import { markdownLineEnding, markdownSpace } from "micromark-util-character";
+import { codes } from "micromark-util-symbol";
+import { visit } from "unist-util-visit";
+export const remarkCustomChecklists = function () {
+    const data = this.data();
+    addParserExtension(data, "micromarkExtensions", gfmTaskListItem());
+    addParserExtension(data, "fromMarkdownExtensions", gfmCustomChecklistFromMarkdown());
+    return (tree, file) => {
+        const source = String(file.value ?? "");
+        visit(tree, "listItem", (node) => {
+            const paragraph = node.children[0];
+            const first = paragraph?.children?.[0];
+            if (!paragraph ||
+                paragraph.type !== "paragraph" ||
+                first?.type !== "text") {
+                return;
+            }
+            const match = first.value.match(/^\[([^\]\r\n])\]\s+/u);
+            if (!match) {
+                syncExistingTaskData(node, source);
+                return;
+            }
+            const task = match[1] ?? " ";
+            first.value = first.value.slice(match[0].length);
+            node.checked = task.trim().length > 0;
+            setTaskData(node, task);
+            if (!first.value) {
+                paragraph.children.shift();
+            }
+        });
+    };
+};
+function addParserExtension(data, field, value) {
+    const list = Array.isArray(data[field])
+        ? data[field]
+        : (data[field] = []);
+    list.push(value);
+}
+const taskListCustomCheckTypes = {
+    taskListCustomCheck: "taskListCustomCheck",
+    taskListCustomCheckMarker: "taskListCustomCheckMarker",
+    taskListCustomCheckValueChecked: "taskListCustomCheckValueChecked",
+};
+function isCheckboxChar(code) {
+    if (code === null) {
+        return false;
+    }
+    return ((code >= codes.digit0 && code <= codes.digit9) ||
+        (code >= codes.uppercaseA && code <= codes.uppercaseZ) ||
+        (code >= codes.lowercaseA && code <= codes.lowercaseZ) ||
+        code === codes.dash ||
+        code === codes.underscore ||
+        code === codes.dot ||
+        code === codes.tilde ||
+        code === codes.exclamationMark ||
+        code === codes.dollarSign ||
+        code === codes.ampersand ||
+        code === codes.apostrophe ||
+        code === codes.leftParenthesis ||
+        code === codes.rightParenthesis ||
+        code === codes.asterisk ||
+        code === codes.plusSign ||
+        code === codes.comma ||
+        code === codes.semicolon ||
+        code === codes.atSign ||
+        code === codes.leftCurlyBrace ||
+        code === codes.rightCurlyBrace ||
+        code === codes.slash ||
+        code === codes.numberSign ||
+        code === codes.backslash ||
+        code === codes.quotationMark ||
+        code === codes.greaterThan ||
+        code === codes.lessThan ||
+        code === codes.equalsTo ||
+        code === codes.questionMark);
+}
+function gfmTaskListItem() {
+    return {
+        text: { [codes.leftSquareBracket]: taskListCustomCheck },
+    };
+}
+const taskListCustomCheck = {
+    name: "taskListCustomCheck",
+    tokenize: tokenizeTaskListCustomCheck,
+};
+function gfmCustomChecklistFromMarkdown() {
+    return {
+        enter: {
+            taskListCustomCheck(token) {
+                this.enter({ type: "checkList", value: "" }, token);
+            },
+            taskListCustomCheckValueChecked(token) {
+                const node = this.stack[this.stack.length - 1];
+                if (node.type === "checkList") {
+                    node.value = this.sliceSerialize(token);
+                }
+            },
+        },
+        exit: {
+            taskListCustomCheck(token) {
+                const node = this.stack[this.stack.length - 1];
+                if (node.type === "checkList") {
+                    const paragraph = this.stack[this.stack.length - 2];
+                    const parent = this.stack[this.stack.length - 3];
+                    if (parent.type === "listItem" &&
+                        paragraph.type === "paragraph" &&
+                        paragraph.children[0] === node) {
+                        paragraph.children.shift();
+                        parent.checked = node.value.trim().length > 0;
+                        parent.value = node.value;
+                        setTaskData(parent, node.value);
+                    }
+                }
+                this.exit(token);
+            },
+        },
+    };
+}
+function tokenizeTaskListCustomCheck(effects, ok, nok) {
+    return open;
+    function open(code) {
+        if (code !== codes.leftSquareBracket) {
+            return nok(code);
+        }
+        effects.enter(taskListCustomCheckTypes.taskListCustomCheck);
+        effects.enter(taskListCustomCheckTypes.taskListCustomCheckMarker);
+        effects.consume(code);
+        effects.exit(taskListCustomCheckTypes.taskListCustomCheckMarker);
+        return inside;
+    }
+    function inside(code) {
+        if (isCheckboxChar(code)) {
+            effects.enter(taskListCustomCheckTypes.taskListCustomCheckValueChecked);
+            effects.consume(code);
+            effects.exit(taskListCustomCheckTypes.taskListCustomCheckValueChecked);
+            return close;
+        }
+        return nok(code);
+    }
+    function close(code) {
+        if (code === codes.rightSquareBracket) {
+            effects.enter(taskListCustomCheckTypes.taskListCustomCheckMarker);
+            effects.consume(code);
+            effects.exit(taskListCustomCheckTypes.taskListCustomCheckMarker);
+            effects.exit(taskListCustomCheckTypes.taskListCustomCheck);
+            return after;
+        }
+        return nok(code);
+    }
+    function after(code) {
+        if (markdownLineEnding(code)) {
+            return ok(code);
+        }
+        if (markdownSpace(code)) {
+            return effects.check({ tokenize: spaceThenNonSpace }, ok, nok)(code);
+        }
+        return nok(code);
+    }
+    function spaceThenNonSpace(effects, ok, nok) {
+        return factorySpace(effects, afterSpace, "whitespace");
+        function afterSpace(code) {
+            return code === null || markdownLineEnding(code) ? nok(code) : ok(code);
+        }
+    }
+}
+function syncExistingTaskData(node, source) {
+    const existing = node.data?.hProperties?.["data-task"] ??
+        node.data?.value ??
+        node.value;
+    if (existing && existing !== "x") {
+        setTaskData(node, existing);
+        return;
+    }
+    const marker = findTaskMarkerFromSource(source, node);
+    if (marker) {
+        setTaskData(node, marker);
+        return;
+    }
+    if (typeof node.checked !== "boolean") {
+        return;
+    }
+    setTaskData(node, node.checked ? "x" : " ");
+}
+function findTaskMarkerFromSource(source, node) {
+    const from = node.position?.start.offset;
+    const to = node.position?.end.offset;
+    if (typeof from !== "number" || typeof to !== "number") {
+        return null;
+    }
+    const lineStart = source.lastIndexOf("\n", Math.max(0, from - 1)) + 1;
+    const lineEnd = source.indexOf("\n", from);
+    const content = source.slice(lineStart, lineEnd === -1 ? Math.max(to, lineStart) : Math.max(lineEnd, to));
+    return (content.match(/^\s*(?:[-*+]|\d+[.)])\s+\[([^\]\r\n])\]\s/u)?.[1] ?? null);
+}
+function setTaskData(node, value) {
+    node.data = {
+        ...(node.data ?? {}),
+        hProperties: {
+            ...(node.data?.hProperties ?? {}),
+            "data-task": value,
+        },
+    };
+}

package/dist/preview/remark/custom-checklists.test.d.ts

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

package/dist/preview/remark/custom-checklists.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom-checklists.test.d.ts","sourceRoot":"","sources":["../../../src/preview/remark/custom-checklists.test.ts"],"names":[],"mappings":""}

package/dist/preview/remark/custom-checklists.test.js

@@ -0,0 +1,51 @@
+import { describe, expect, it } from "vitest";
+import { createParser } from "../renderer/utils";
+import { findElement } from "../test-utils";
+import { remarkCustomChecklists } from "./custom-checklists";
+describe("custom checklist rendering", () => {
+    it("turns custom task markers into GFM task items with data-task", () => {
+        const parser = createParser([remarkCustomChecklists]);
+        const ast = parser("- [/] Custom task marker");
+        const item = findElement(ast, "li");
+        expect(item?.tagName).toBe("li");
+        expect(item?.properties?.["data-task"]).toBe("/");
+        expect(JSON.stringify(item)).not.toContain("[/]");
+    });
+    it("preserves data-task for standard task items", () => {
+        const parser = createParser([remarkCustomChecklists]);
+        const ast = parser("- [x] Done");
+        const item = findElement(ast, "li");
+        expect(item?.properties?.["data-task"]).toBe("x");
+    });
+    it("supports Lapis custom task marker characters", () => {
+        const parser = createParser([remarkCustomChecklists]);
+        const markers = [
+            ">",
+            "<",
+            "?",
+            "/",
+            "!",
+            '"',
+            "-",
+            "*",
+            "l",
+            "i",
+            "S",
+            "I",
+            "f",
+            "k",
+            "u",
+            "d",
+            "w",
+            "p",
+            "c",
+            "b",
+        ];
+        const ast = parser(markers.map((marker) => `- [${marker}] ${marker} task`).join("\n"));
+        const serialized = JSON.stringify(ast);
+        for (const marker of markers) {
+            expect(serialized).toContain(`"data-task":${JSON.stringify(marker)}`);
+            expect(serialized).not.toContain(`[${marker}]`);
+        }
+    });
+});

package/dist/preview/remark/external-links.d.ts

@@ -0,0 +1,4 @@
+import type { Root } from "mdast";
+import type { Plugin } from "unified";
+export declare const remarkExternalLinks: Plugin<[], Root>;
+//# sourceMappingURL=external-links.d.ts.map

package/dist/preview/remark/external-links.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"external-links.d.ts","sourceRoot":"","sources":["../../../src/preview/remark/external-links.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAQ,IAAI,EAAE,MAAM,OAAO,CAAC;AACxC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAItC,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,EAAE,EAAE,IAAI,CAoBhD,CAAC"}

package/dist/preview/remark/external-links.js

@@ -0,0 +1,34 @@
+import { visit } from "unist-util-visit";
+import { isExternalMarkdownDestination } from "./utils";
+export const remarkExternalLinks = () => {
+    return (tree) => {
+        visit(tree, "link", (node) => {
+            if (!isExternalMarkdownDestination(node.url)) {
+                return;
+            }
+            const tooltip = externalLinkTooltip(node);
+            node.data = {
+                ...(node.data ?? {}),
+                hProperties: {
+                    ...(node.data?.hProperties ?? {}),
+                    ...(tooltip ? { "data-tooltip": tooltip } : {}),
+                    className: "external-link",
+                    target: "_blank",
+                    rel: "noreferrer",
+                },
+            };
+        });
+    };
+};
+function externalLinkTooltip(node) {
+    let tooltip = node.url;
+    if (node.children.length === 1 &&
+        node.children[0]?.type === "text" &&
+        node.children[0].value === node.url) {
+        tooltip = undefined;
+    }
+    if (node.title) {
+        return [node.title, tooltip || ""].filter(Boolean).join(" > ");
+    }
+    return tooltip;
+}

package/dist/preview/remark/hast.d.ts

@@ -0,0 +1,6 @@
+import type { Root } from "mdast";
+import type { Plugin } from "unified";
+export declare const remarkDirectivesToHast: Plugin<[], Root>;
+export declare const remarkFrontmatterToHast: Plugin<[], Root>;
+export declare const remarkPositionsToData: Plugin<[], Root>;
+//# sourceMappingURL=hast.d.ts.map

package/dist/preview/remark/hast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hast.d.ts","sourceRoot":"","sources":["../../../src/preview/remark/hast.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC;AAClC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAGtC,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,EAAE,EAAE,IAAI,CAqBnD,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,EAAE,EAAE,IAAI,CAsBpD,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,EAAE,EAAE,IAAI,CAiBlD,CAAC"}

package/dist/preview/remark/hast.js

@@ -0,0 +1,60 @@
+import { visit } from "unist-util-visit";
+export const remarkDirectivesToHast = () => {
+    return (tree) => {
+        visit(tree, (node) => {
+            if (node.type !== "containerDirective" &&
+                node.type !== "leafDirective" &&
+                node.type !== "textDirective") {
+                return;
+            }
+            node.data = {
+                ...(node.data ?? {}),
+                hName: "directive",
+                hProperties: {
+                    ...(node.attributes ?? {}),
+                    "data-directive": node.name,
+                },
+            };
+        });
+    };
+};
+export const remarkFrontmatterToHast = () => {
+    return (tree) => {
+        visit(tree, (node) => {
+            if (node.type !== "yaml" && node.type !== "toml") {
+                return;
+            }
+            const frontmatterType = node.type;
+            node.type = "frontmatter";
+            node.data = {
+                ...(node.data ?? {}),
+                hName: "frontmatter",
+                hProperties: {
+                    ...(node.data?.hProperties ?? {}),
+                    frontmatter: node.value ?? "",
+                    value: node.value ?? "",
+                    "data-frontmatter": frontmatterType,
+                },
+                hChildren: [],
+            };
+        });
+    };
+};
+export const remarkPositionsToData = () => {
+    return (tree) => {
+        visit(tree, (node) => {
+            if (!node.position) {
+                return;
+            }
+            node.data = {
+                ...(node.data ?? {}),
+                hProperties: {
+                    ...(node.data?.hProperties ?? {}),
+                    "data-line": node.position.start.line,
+                    "data-offset": node.position.start.offset,
+                    "data-offset-end": node.position.end.offset,
+                },
+            };
+        });
+    };
+};

package/dist/preview/remark/headings.d.ts

@@ -0,0 +1,8 @@
+import type { Root } from "mdast";
+import type { Plugin } from "unified";
+export type RemarkHeadingsOptions = {
+    ids?: boolean;
+    prefix?: string;
+};
+export declare const remarkHeadings: Plugin<[RemarkHeadingsOptions?] | [], Root>;
+//# sourceMappingURL=headings.d.ts.map

package/dist/preview/remark/headings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"headings.d.ts","sourceRoot":"","sources":["../../../src/preview/remark/headings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAA4B,IAAI,EAAE,MAAM,OAAO,CAAC;AAC5D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAItC,MAAM,MAAM,qBAAqB,GAAG;IAClC,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,CAAC,qBAAqB,CAAC,CAAC,GAAG,EAAE,EAAE,IAAI,CA0BtE,CAAC"}

package/dist/preview/remark/headings.js

@@ -0,0 +1,40 @@
+import { visit } from "unist-util-visit";
+import { slugHeadingText } from "../outline";
+export const remarkHeadings = (options = {}) => {
+    return (tree) => {
+        const counts = new Map();
+        visit(tree, "heading", (node) => {
+            const text = headingText(node.children);
+            const id = options.ids
+                ? uniqueHeadingId(`${options.prefix ?? ""}${slugHeadingText(text)}`, counts)
+                : undefined;
+            node.data = {
+                ...(node.data ?? {}),
+                hProperties: {
+                    "data-heading": headingText(node.children),
+                    ...(id ? { id } : {}),
+                    ...(node.data?.hProperties ?? {}),
+                    className: `cm-header cm-header-${node.depth}`,
+                },
+            };
+        });
+    };
+};
+function headingText(children) {
+    return children
+        .map((child) => {
+        if ("value" in child && typeof child.value === "string") {
+            return child.value;
+        }
+        if ("children" in child && Array.isArray(child.children)) {
+            return headingText(child.children);
+        }
+        return "";
+    })
+        .join("");
+}
+function uniqueHeadingId(value, counts) {
+    const count = counts.get(value) ?? 0;
+    counts.set(value, count + 1);
+    return count === 0 ? value : `${value}-${count}`;
+}

package/dist/preview/remark/links.test.d.ts

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

package/dist/preview/remark/links.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"links.test.d.ts","sourceRoot":"","sources":["../../../src/preview/remark/links.test.ts"],"names":[],"mappings":""}

package/dist/preview/remark/links.test.js

@@ -0,0 +1,62 @@
+import { describe, expect, it } from "vitest";
+import { createParser } from "../renderer/utils";
+import { findElement } from "../test-utils";
+import { isExternalMarkdownDestination, isImplicitLocalPathDestination, isLocalPathDestination, } from "./utils";
+import { remarkExternalLinks } from "./external-links";
+import { remarkPathLinks } from "./pathlink";
+import { remarkWikiLinks } from "./wikilink";
+describe("link parity plugins", () => {
+    it("marks external links with the Lapis external-link class", () => {
+        const parser = createParser([remarkExternalLinks]);
+        const ast = parser("[Example](https://example.com)");
+        const link = findElement(ast, "a");
+        expect(link?.properties?.href).toBe("https://example.com");
+        expect(link?.properties?.class).toBe("external-link");
+        expect(link?.properties?.target).toBe("_blank");
+        expect(link?.properties?.rel).toBe("noreferrer");
+    });
+    it("keeps wiki and embed links on Lapis id/text properties", () => {
+        const parser = createParser([remarkWikiLinks]);
+        const ast = parser("[[Project Plan|Plan]] and ![[Image Asset|Diagram]]");
+        const wikilink = findElement(ast, "wikilink");
+        const embed = findElement(ast, "embed");
+        expect(wikilink?.properties?.id).toBe("Project Plan");
+        expect(wikilink?.properties?.text).toBe("Plan");
+        expect(wikilink?.children).toEqual([{ type: "text", value: "Plan" }]);
+        expect(embed?.properties?.id).toBe("Image Asset");
+        expect(embed?.properties?.text).toBe("Diagram");
+        expect(embed?.children).toEqual([]);
+    });
+    it("preserves compound embed labels and dimensions", () => {
+        const parser = createParser([remarkWikiLinks]);
+        const ast = parser("![[Image Asset|Diagram|320x180]]");
+        const embed = findElement(ast, "embed");
+        expect(embed?.properties?.id).toBe("Image Asset");
+        expect(embed?.properties?.text).toBe("Diagram|320x180");
+    });
+    it("parses implicit local path links as pathlink elements", () => {
+        const parser = createParser([remarkPathLinks]);
+        const ast = parser("[Project Plan]");
+        const pathlink = findElement(ast, "pathlink");
+        expect(pathlink?.properties?.id).toBe("Project Plan");
+        expect(pathlink?.properties?.text).toBe("Project Plan");
+    });
+    it("does not consume wikilinks or embeds while parsing implicit path links", () => {
+        const parser = createParser([remarkWikiLinks, remarkPathLinks]);
+        const ast = parser("[[Project Plan|Plan]] ![[Image Asset|Diagram]] [Project Plan]");
+        expect(findElement(ast, "wikilink")?.properties?.id).toBe("Project Plan");
+        expect(findElement(ast, "embed")?.properties?.id).toBe("Image Asset");
+        expect(findElement(ast, "pathlink")?.properties?.id).toBe("Project Plan");
+    });
+    it("classifies external and local path destinations like Lapis", () => {
+        expect(isExternalMarkdownDestination("https://example.com")).toBe(true);
+        expect(isExternalMarkdownDestination("//example.com")).toBe(true);
+        expect(isExternalMarkdownDestination("mailto:test@example.com")).toBe(true);
+        expect(isExternalMarkdownDestination("tel:+15555551212")).toBe(true);
+        expect(isExternalMarkdownDestination("Project Plan.md")).toBe(false);
+        expect(isLocalPathDestination("Project Plan.md")).toBe(true);
+        expect(isLocalPathDestination("Project.md")).toBe(false);
+        expect(isImplicitLocalPathDestination("Project.md")).toBe(true);
+        expect(isImplicitLocalPathDestination("https://example.com")).toBe(false);
+    });
+});

package/dist/preview/remark/list-callouts.d.ts

@@ -0,0 +1,14 @@
+import type { Root } from "mdast";
+import type { Plugin } from "unified";
+import { type MiraListCallout, type MiraResolvedListCallout } from "@lapismd/mira/extensions";
+export type ListCallout = MiraResolvedListCallout;
+export type RemarkListCalloutOptions = {
+    callouts?: readonly MiraListCallout[];
+};
+export declare const defaultListCallouts: readonly ListCallout[];
+export declare const listCalloutMap: Map<string, MiraResolvedListCallout>;
+export declare const listCalloutMarkerRegexp: RegExp;
+export declare const remarkListCallouts: Plugin<[RemarkListCalloutOptions?], Root>;
+export declare function createListCalloutMarkerRegexp(callouts: readonly Pick<MiraListCallout, "char">[]): RegExp;
+export declare function escapeRegExp(value: string): string;
+//# sourceMappingURL=list-callouts.d.ts.map

package/dist/preview/remark/list-callouts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-callouts.d.ts","sourceRoot":"","sources":["../../../src/preview/remark/list-callouts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAuB,IAAI,EAAQ,MAAM,OAAO,CAAC;AAC7D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAEtC,OAAO,EAGL,KAAK,eAAe,EACpB,KAAK,uBAAuB,EAC7B,MAAM,0BAA0B,CAAC;AAElC,MAAM,MAAM,WAAW,GAAG,uBAAuB,CAAC;AAElD,MAAM,MAAM,wBAAwB,GAAG;IACrC,QAAQ,CAAC,EAAE,SAAS,eAAe,EAAE,CAAC;CACvC,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,SAAS,WAAW,EACvB,CAAC;AAEhC,eAAO,MAAM,cAAc,sCAE1B,CAAC;AAEF,eAAO,MAAM,uBAAuB,QAGnC,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,CAAC,wBAAwB,CAAC,CAAC,EAAE,IAAI,CA4ExE,CAAC;AAEF,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,SAAS,IAAI,CAAC,eAAe,EAAE,MAAM,CAAC,EAAE,GACjD,MAAM,CAQR;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAElD"}

package/dist/preview/remark/list-callouts.js

@@ -0,0 +1,91 @@
+import { visit } from "unist-util-visit";
+import { defaultMiraEditorListCallouts, resolveMiraListCallouts, } from "@lapismd/mira/extensions";
+export const defaultListCallouts = defaultMiraEditorListCallouts;
+export const listCalloutMap = new Map(defaultListCallouts.map((callout) => [callout.char, callout]));
+export const listCalloutMarkerRegexp = new RegExp(`^\\s*(${defaultListCallouts.map((callout) => escapeRegExp(callout.char)).join("|")})\\s+`, "u");
+export const remarkListCallouts = (options = {}) => {
+    const callouts = resolveMiraListCallouts(options.callouts);
+    const calloutMap = new Map(callouts.map((callout) => [callout.char, callout]));
+    const markerRegexp = createListCalloutMarkerRegexp(callouts);
+    return (tree) => {
+        visit(tree, "listItem", (node) => {
+            const paragraph = node.children[0];
+            const first = paragraph?.children?.[0];
+            if (paragraph?.type !== "paragraph" ||
+                first?.type !== "text" ||
+                !first.value) {
+                return;
+            }
+            const match = markerRegexp.exec(first.value);
+            const marker = match?.[1];
+            const callout = marker ? calloutMap.get(marker) : undefined;
+            if (!match || !marker || !callout) {
+                return;
+            }
+            const remainder = first.value.slice(match[0].length);
+            const sourceOffset = first.position?.start.offset;
+            const markerIndex = match[0].indexOf(marker);
+            const markerOffset = typeof sourceOffset === "number" && markerIndex >= 0
+                ? sourceOffset + markerIndex
+                : undefined;
+            const markerNode = {
+                type: "listCalloutMarker",
+                data: {
+                    hName: "span",
+                    hProperties: {
+                        className: "lc-list-marker",
+                        "aria-hidden": "true",
+                        "data-list-callout-marker": "true",
+                        "data-callout-char": callout.char,
+                        ...(callout.icon ? { "data-callout-icon": callout.icon } : {}),
+                        ...(markerOffset === undefined
+                            ? {}
+                            : {
+                                "data-offset": markerOffset,
+                                "data-offset-end": markerOffset + marker.length,
+                            }),
+                    },
+                    hChildren: [],
+                },
+            };
+            first.value = remainder;
+            paragraph.children.splice(0, 0, markerNode);
+            node.data = {
+                ...(node.data ?? {}),
+                hProperties: {
+                    ...(node.data?.hProperties ?? {}),
+                    className: mergeClassNames(node.data?.hProperties?.className, "lc-list-callout"),
+                    "data-callout": callout.char,
+                    style: mergeStyle(node.data?.hProperties?.style, `--lc-callout-color: ${callout.color}`),
+                },
+            };
+        });
+    };
+};
+export function createListCalloutMarkerRegexp(callouts) {
+    const markers = callouts
+        .map((callout) => callout.char.trim())
+        .filter(Boolean)
+        .sort((left, right) => right.length - left.length);
+    return markers.length
+        ? new RegExp(`^\\s*(${markers.map(escapeRegExp).join("|")})\\s+`, "u")
+        : /$a/u;
+}
+export function escapeRegExp(value) {
+    return value.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
+}
+function mergeClassNames(current, className) {
+    const values = Array.isArray(current)
+        ? current.map(String)
+        : typeof current === "string"
+            ? current.split(/\s+/u)
+            : [];
+    if (!values.includes(className)) {
+        values.push(className);
+    }
+    return values.filter(Boolean).join(" ");
+}
+function mergeStyle(current, style) {
+    const currentStyle = typeof current === "string" ? current.trim() : "";
+    return [currentStyle, style].filter(Boolean).join("; ");
+}

package/dist/preview/remark/multimarkdown-table.d.ts

@@ -0,0 +1,11 @@
+import type { Root } from "mdast";
+import type { Plugin } from "unified";
+export type MultiMarkdownTableOptions = {
+    colspanMarkers?: string[];
+    rowspanMarker?: string;
+    trimWhitespace?: boolean;
+};
+export declare const remarkMultimarkdownTable: Plugin<[
+    MultiMarkdownTableOptions?
+], Root>;
+//# sourceMappingURL=multimarkdown-table.d.ts.map

package/dist/preview/remark/multimarkdown-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multimarkdown-table.d.ts","sourceRoot":"","sources":["../../../src/preview/remark/multimarkdown-table.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAA8B,MAAM,OAAO,CAAC;AAC9D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAGtC,MAAM,MAAM,yBAAyB,GAAG;IACtC,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B,CAAC;AAIF,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAC3C;IAAC,yBAAyB,CAAC;CAAC,EAC5B,IAAI,CAiBL,CAAC"}