@lapismd/mira 0.0.1

package/dist/preview/remark/multimarkdown-table.js

@@ -0,0 +1,138 @@
+import { visit } from "unist-util-visit";
+export const remarkMultimarkdownTable = (options = {}) => {
+    const spanOptions = {
+        colspanMarkers: options.colspanMarkers ?? ["", "|"],
+        rowspanMarker: options.rowspanMarker ?? "^",
+        trimWhitespace: options.trimWhitespace ?? true,
+    };
+    return (tree) => {
+        visit(tree, "table", (node) => {
+            if (!node.children || node.children.length < 2) {
+                return;
+            }
+            node.children = processTableSpans(node.children, spanOptions);
+        });
+    };
+};
+function processTableSpans(rows, options) {
+    const grid = rows.map(() => []);
+    const cellSpans = new Map();
+    const columnCount = Math.max(1, rows[0]?.children?.length ?? 1);
+    for (let rowIndex = 0; rowIndex < rows.length; rowIndex += 1) {
+        const originalCells = rows[rowIndex]?.children ?? [];
+        let colIndex = 0;
+        for (let cellIndex = 0; cellIndex < originalCells.length; cellIndex += 1) {
+            const cell = originalCells[cellIndex];
+            if (!cell) {
+                continue;
+            }
+            while (grid[rowIndex]?.[colIndex] !== undefined) {
+                colIndex += 1;
+            }
+            const cellText = tableCellText(cell, options.trimWhitespace);
+            if (cellText === options.rowspanMarker) {
+                extendRowspan(grid, cellSpans, rowIndex, colIndex);
+                colIndex += 1;
+                continue;
+            }
+            const colspanInfo = getColspan(originalCells, cellIndex, options);
+            let { colspan } = colspanInfo;
+            const { nextCellIndex } = colspanInfo;
+            if (colIndex >= columnCount) {
+                cellIndex = nextCellIndex - 1;
+                continue;
+            }
+            colspan = Math.min(colspan, columnCount - colIndex);
+            grid[rowIndex][colIndex] = cell;
+            cellSpans.set(`${rowIndex},${colIndex}`, { rowspan: 1, colspan });
+            for (let offset = 1; offset < colspan; offset += 1) {
+                grid[rowIndex][colIndex + offset] = cell;
+            }
+            cellIndex = nextCellIndex - 1;
+            colIndex += colspan;
+        }
+    }
+    return rows.map((row, rowIndex) => {
+        const seenCells = new Set();
+        const children = [];
+        for (let colIndex = 0; colIndex < columnCount; colIndex += 1) {
+            const cell = grid[rowIndex]?.[colIndex];
+            if (!cell || seenCells.has(cell)) {
+                continue;
+            }
+            seenCells.add(cell);
+            const spanInfo = cellSpans.get(`${rowIndex},${colIndex}`);
+            if (!spanInfo) {
+                continue;
+            }
+            const nextCell = {
+                ...cell,
+                data: {
+                    ...(cell.data ?? {}),
+                    hProperties: {
+                        ...(cell.data?.hProperties ?? {}),
+                    },
+                },
+            };
+            if (spanInfo.colspan > 1) {
+                nextCell.data.hProperties.colSpan = spanInfo.colspan;
+            }
+            if (spanInfo.rowspan > 1) {
+                nextCell.data.hProperties.rowSpan = spanInfo.rowspan;
+            }
+            children.push(nextCell);
+        }
+        return {
+            ...row,
+            children,
+        };
+    });
+}
+function extendRowspan(grid, cellSpans, rowIndex, colIndex) {
+    for (let checkRow = rowIndex - 1; checkRow >= 0; checkRow -= 1) {
+        const spanningCell = grid[checkRow]?.[colIndex];
+        if (!spanningCell) {
+            continue;
+        }
+        const spanInfo = cellSpans.get(`${checkRow},${colIndex}`);
+        if (spanInfo && checkRow + spanInfo.rowspan === rowIndex) {
+            spanInfo.rowspan += 1;
+            grid[rowIndex][colIndex] = spanningCell;
+            return;
+        }
+    }
+    grid[rowIndex][colIndex] = null;
+}
+function tableCellText(cell, trimWhitespace) {
+    const text = nodeText(cell);
+    return trimWhitespace ? text.trim() : text;
+}
+function getColspan(cells, cellIndex, options) {
+    let nextCellIndex = cellIndex + 1;
+    let markerCount = 0;
+    while (nextCellIndex < cells.length) {
+        const nextCell = cells[nextCellIndex];
+        if (!nextCell ||
+            !options.colspanMarkers.includes(tableCellText(nextCell, options.trimWhitespace))) {
+            break;
+        }
+        markerCount += 1;
+        nextCellIndex += 1;
+    }
+    if (markerCount === 0 || nextCellIndex >= cells.length) {
+        return { colspan: 1, nextCellIndex: cellIndex + 1 };
+    }
+    return { colspan: 1 + markerCount, nextCellIndex };
+}
+function nodeText(node) {
+    if (!node || typeof node !== "object") {
+        return "";
+    }
+    if ("value" in node && typeof node.value === "string") {
+        return node.value;
+    }
+    if ("children" in node && Array.isArray(node.children)) {
+        return node.children.map((child) => nodeText(child)).join("");
+    }
+    return "";
+}

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

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

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

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

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

@@ -0,0 +1,105 @@
+import { describe, expect, it } from "vitest";
+import remarkGfm from "remark-gfm";
+import { createParser } from "../renderer/utils";
+import { findElement } from "../test-utils";
+import { rehypeHighlightLines } from "../rehype-highlight-lines";
+import { rehypeTableSpans } from "../rehype-table-spans";
+import { remarkHeadings } from "./headings";
+import { remarkListCallouts } from "./list-callouts";
+import { remarkMultimarkdownTable } from "./multimarkdown-table";
+describe("Lapis preview parity plugins", () => {
+    it("adds Lapis heading classes and data-heading text", () => {
+        const parser = createParser([remarkHeadings]);
+        const ast = parser("## Portable **heading**");
+        const heading = findElement(ast, "h2");
+        expect(heading?.properties?.class).toBe("cm-header cm-header-2");
+        expect(heading?.properties?.["data-heading"]).toBe("Portable heading");
+    });
+    it("adds highlighted code line wrappers from fence metadata", () => {
+        const parser = createParser([], [rehypeHighlightLines]);
+        const ast = parser(["```ts {2}", "const a = 1;", "const b = 2;", "```"].join("\n"));
+        const code = findElement(ast, "code");
+        const lines = findElements(code, "span").filter((element) => String(element.properties?.class ?? "").includes("code-line"));
+        expect(lines).toHaveLength(2);
+        expect(lines[1]?.properties?.class).toContain("highlighted-code-line");
+    });
+    it("adds Lapis MultiMarkdown colspan and rowspan properties", () => {
+        const parser = createParser([remarkGfm, remarkMultimarkdownTable], [rehypeTableSpans]);
+        const ast = parser([
+            "| Package | Role | Status |",
+            "| --- | --- | --- |",
+            "| combined package | | ready |",
+            "| @lapismd/mira/core | editor controller | ready |",
+            "| ^ | rendered markdown | ready |",
+        ].join("\n"));
+        const bodyRows = directElementChildren(findElement(ast, "tbody"), "tr");
+        const cells = findElements(findElement(ast, "tbody"), "td");
+        const cellWithColspan = cells.find((cell) => cell.properties?.colspan === 2);
+        const cellWithRowspan = cells.find((cell) => cell.properties?.rowspan === 2);
+        expect(bodyRows.map((row) => directElementChildren(row, "td").length)).toEqual([2, 3, 2]);
+        expect(cellWithColspan).toBeDefined();
+        expect(cellWithRowspan).toBeDefined();
+    });
+    it("does not treat trailing empty MultiMarkdown cells as colspans", () => {
+        const parser = createParser([remarkGfm, remarkMultimarkdownTable], [rehypeTableSpans]);
+        const ast = parser([
+            "| Package | Role | Status |   |",
+            "| --- | --- | --- | --- |",
+            "| @lapismd/mira/core | editor controller | ready |   |",
+        ].join("\n"));
+        const headerCells = directElementChildren(findElement(ast, "thead"), "tr").flatMap((row) => directElementChildren(row, "th"));
+        const bodyCells = findElements(findElement(ast, "tbody"), "td");
+        expect(headerCells).toHaveLength(4);
+        expect(bodyCells).toHaveLength(4);
+        expect(headerCells[2]?.properties?.colspan).toBeUndefined();
+        expect(bodyCells[2]?.properties?.colspan).toBeUndefined();
+    });
+    it("renders Lapis default list callout markers", () => {
+        const parser = createParser([remarkGfm, remarkListCallouts]);
+        const ast = parser("- & Highlighted item\n- ? Question item");
+        const items = findElements(ast, "li");
+        const markers = findElements(ast, "span").filter((element) => String(element.properties?.class ?? "").includes("lc-list-marker"));
+        expect(items[0]?.properties?.class).toContain("lc-list-callout");
+        expect(items[0]?.properties?.["data-callout"]).toBe("&");
+        expect(items[1]?.properties?.["data-callout"]).toBe("?");
+        expect(markers.map((marker) => marker.properties?.["data-callout-char"])).toEqual(["&", "?"]);
+        expect(markers[0]?.properties?.["data-offset"]).toBe(2);
+        expect(markers[0]?.properties?.["data-offset-end"]).toBe(3);
+    });
+    it("renders an injected list callout catalog and can disable defaults", () => {
+        const parser = createParser([
+            remarkGfm,
+            [
+                remarkListCallouts,
+                {
+                    callouts: [
+                        { char: "&", enabled: false },
+                        { char: "^", color: "80, 70, 220", icon: "bookmark" },
+                    ],
+                },
+            ],
+        ]);
+        const ast = parser("- & Plain item\n- ^ Custom item");
+        const items = findElements(ast, "li");
+        const marker = findElements(ast, "span").find((element) => element.properties?.["data-list-callout-marker"] === "true");
+        expect(String(items[0]?.properties?.class ?? "")).not.toContain("lc-list-callout");
+        expect(items[1]?.properties?.["data-callout"]).toBe("^");
+        expect(items[1]?.properties?.style).toContain("80, 70, 220");
+        expect(marker?.properties?.["data-callout-icon"]).toBe("bookmark");
+    });
+});
+function findElements(node, tagName) {
+    const results = [];
+    if (node.type === "element" && node.tagName === tagName) {
+        results.push(node);
+    }
+    for (const child of node.children ?? []) {
+        if (child.type === "element") {
+            results.push(...findElements(child, tagName));
+        }
+    }
+    return results;
+}
+function directElementChildren(node, tagName) {
+    return (node.children ?? []).filter((child) => child.type === "element" && child.tagName === tagName);
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"pathlink.d.ts","sourceRoot":"","sources":["../../../src/preview/remark/pathlink.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC;AAClC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAOtC,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,EAAE,EAAE,IAAI,CA0B5C,CAAC"}

package/dist/preview/remark/pathlink.js

@@ -0,0 +1,26 @@
+import { isImplicitLocalPathDestination, splitTextNodes, } from "./utils";
+export const remarkPathLinks = () => {
+    return (tree) => splitTextNodes(tree, /(?<!\[)\[(?!\[)([^\]\n]+)](?![\](])/g, (match) => {
+        const id = match[1] ?? "";
+        if (!isImplicitLocalPathDestination(id)) {
+            return {
+                type: "text",
+                value: match[0] ?? "",
+            };
+        }
+        return {
+            type: "pathlink",
+            value: id,
+            data: {
+                hName: "pathlink",
+                hProperties: {
+                    href: id,
+                    id,
+                    label: id,
+                    text: id,
+                },
+                hChildren: [{ type: "text", value: id }],
+            },
+        };
+    });
+};

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

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

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

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

package/dist/preview/remark/tags.js

@@ -0,0 +1,22 @@
+import { splitTextNodes } from "./utils";
+export const remarkTags = () => {
+    return (tree) => splitTextNodes(tree, /(^|[\s([{])#([\p{L}\p{N}_/-]+)/gu, (match) => {
+        const prefix = match[1] ?? "";
+        const value = `#${match[2]}`;
+        const tag = {
+            type: "tag",
+            value,
+            data: {
+                hName: "tag",
+                hProperties: { value },
+                hChildren: [{ type: "text", value }],
+            },
+        };
+        return prefix
+            ? [
+                { type: "text", value: prefix },
+                tag,
+            ]
+            : tag;
+    });
+};

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

@@ -0,0 +1,12 @@
+import type { Root, Text } from "mdast";
+export type MarkdownInlineNode = Text & {
+    data?: Record<string, unknown>;
+};
+export declare function hasRawSpace(value: string): boolean;
+export declare function isUrlLikeDestination(value: string): boolean;
+export declare function isExternalMarkdownDestination(value: string): boolean;
+export declare function isImageDataUri(value: string): boolean;
+export declare function isLocalPathDestination(value: string): boolean;
+export declare function isImplicitLocalPathDestination(value: string): boolean;
+export declare function splitTextNodes(tree: Root, regexp: RegExp, createNode: (match: RegExpMatchArray) => MarkdownInlineNode | MarkdownInlineNode[]): void;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/preview/remark/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC;AAOxC,MAAM,MAAM,kBAAkB,GAAG,IAAI,GAAG;IACtC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC,CAAC;AAEF,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAElD;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAE3D;AAED,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CASpE;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAIrD;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAc7D;AAED,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAWrE;AAED,wBAAgB,cAAc,CAC5B,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,CACV,KAAK,EAAE,gBAAgB,KACpB,kBAAkB,GAAG,kBAAkB,EAAE,GAC7C,IAAI,CAkCN"}

package/dist/preview/remark/utils.js

@@ -0,0 +1,74 @@
+import { visit } from "unist-util-visit";
+export function hasRawSpace(value) {
+    return value.includes(" ");
+}
+export function isUrlLikeDestination(value) {
+    return /^(?:[a-z][a-z\d+.-]*:|\/\/)/i.test(value);
+}
+export function isExternalMarkdownDestination(value) {
+    const text = value.trim();
+    return (/^((https?|ftps?|ssh):)?\/\//i.test(text) ||
+        /^<((https?|ftps?|ssh):)?\/\//i.test(text) ||
+        /^(mailto|tel):/i.test(text) ||
+        /^<(mailto|tel):/i.test(text));
+}
+export function isImageDataUri(value) {
+    return /^data:image\/(?:png|jpe?g|gif|webp|avif);base64,[a-z0-9+/=\s]+$/i.test(value.trim());
+}
+export function isLocalPathDestination(value) {
+    if (!hasRawSpace(value)) {
+        return false;
+    }
+    if (value.trim() !== value || value.length === 0) {
+        return false;
+    }
+    if (/[\n\r\t<>|]/.test(value)) {
+        return false;
+    }
+    if (value.includes("#") || value.includes("?")) {
+        return false;
+    }
+    return !isUrlLikeDestination(value);
+}
+export function isImplicitLocalPathDestination(value) {
+    if (value.trim() !== value || value.length === 0) {
+        return false;
+    }
+    if (/[\n\r\t<>|]/.test(value) || value.includes("[") || value.includes("]")) {
+        return false;
+    }
+    if (value.includes("#") || value.includes("?")) {
+        return false;
+    }
+    return !isUrlLikeDestination(value);
+}
+export function splitTextNodes(tree, regexp, createNode) {
+    visit(tree, "text", (node, index, parent) => {
+        if (index === undefined || !parent?.children) {
+            return;
+        }
+        const replacements = [];
+        let lastIndex = 0;
+        for (const match of node.value.matchAll(regexp)) {
+            const matchIndex = match.index ?? 0;
+            if (matchIndex > lastIndex) {
+                replacements.push({
+                    type: "text",
+                    value: node.value.slice(lastIndex, matchIndex),
+                });
+            }
+            replacements.push(...[createNode(match)].flat());
+            lastIndex = matchIndex + match[0].length;
+        }
+        if (!replacements.length) {
+            return;
+        }
+        if (lastIndex < node.value.length) {
+            replacements.push({
+                type: "text",
+                value: node.value.slice(lastIndex),
+            });
+        }
+        parent.children.splice(index, 1, ...replacements);
+    });
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"wikilink.d.ts","sourceRoot":"","sources":["../../../src/preview/remark/wikilink.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC;AAClC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAGtC,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,EAAE,EAAE,IAAI,CAuB5C,CAAC"}

package/dist/preview/remark/wikilink.js

@@ -0,0 +1,23 @@
+import { splitTextNodes } from "./utils";
+export const remarkWikiLinks = () => {
+    return (tree) => splitTextNodes(tree, /(!?)\[\[([^\]\n]+)]]/g, (match) => {
+        const isEmbed = match[1] === "!";
+        const [target = "", ...details] = (match[2] ?? "").split("|");
+        const alias = details.join("|") || undefined;
+        const label = alias || target;
+        return {
+            type: isEmbed ? "embed" : "wikilink",
+            value: target,
+            data: {
+                hName: isEmbed ? "embed" : "wikilink",
+                hProperties: {
+                    href: target,
+                    id: target,
+                    label,
+                    text: label,
+                },
+                hChildren: isEmbed ? [] : [{ type: "text", value: label }],
+            },
+        };
+    });
+};

package/dist/preview/remark.d.ts

@@ -0,0 +1,12 @@
+export * from "./remark/callouts";
+export * from "./remark/custom-checklists";
+export * from "./remark/external-links";
+export * from "./remark/hast";
+export * from "./remark/headings";
+export * from "./remark/list-callouts";
+export * from "./remark/multimarkdown-table";
+export * from "./remark/pathlink";
+export * from "./remark/tags";
+export * from "./remark/utils";
+export * from "./remark/wikilink";
+//# sourceMappingURL=remark.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"remark.d.ts","sourceRoot":"","sources":["../../src/preview/remark.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,yBAAyB,CAAC;AACxC,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC"}

package/dist/preview/remark.js

@@ -0,0 +1,11 @@
+export * from "./remark/callouts";
+export * from "./remark/custom-checklists";
+export * from "./remark/external-links";
+export * from "./remark/hast";
+export * from "./remark/headings";
+export * from "./remark/list-callouts";
+export * from "./remark/multimarkdown-table";
+export * from "./remark/pathlink";
+export * from "./remark/tags";
+export * from "./remark/utils";
+export * from "./remark/wikilink";

package/dist/preview/renderer/context.svelte.d.ts

@@ -0,0 +1,37 @@
+import type { MiraAssetResolver, MiraExtension, MiraFileAdapter, MiraLinkResolver, MiraRendererComponents, MiraResolvedListCallout } from "@lapismd/mira/extensions";
+import type { HastNode, MarkdownChangeHandler, MarkdownPostProcess } from "./types";
+import type { FrontmatterConfig } from "../components/frontmatter-utils";
+import type { Pluggable } from "unified";
+import type { Options as RemarkRehypeOptions } from "remark-rehype";
+export type MarkdownContext = {
+    markdown: string;
+    sourcePath?: string;
+    extensions: MiraExtension[];
+    remarkPlugins: Pluggable[];
+    rehypePlugins: Pluggable[];
+    remarkRehypeOptions: RemarkRehypeOptions;
+    components: MiraRendererComponents;
+    linkResolver?: MiraLinkResolver;
+    assetResolver?: MiraAssetResolver;
+    fileAdapter?: MiraFileAdapter;
+    listCallouts: MiraResolvedListCallout[];
+    postProcess: MarkdownPostProcess;
+    onChange?: MarkdownChangeHandler;
+    onFrontmatterChange?: (nextYaml: string, nextValue: string) => void;
+    frontmatterOpen: boolean;
+    frontmatterConfig?: FrontmatterConfig;
+    dialog: boolean;
+};
+export type AstNodeContext = {
+    node: HastNode;
+    parent: HastNode | null;
+};
+export declare function setMarkdownContext(context: MarkdownContext): MarkdownContext;
+export declare function useMarkdownContext(): MarkdownContext;
+export declare function tryUseMarkdownContext(): MarkdownContext | null;
+export declare const useMarkdown: typeof useMarkdownContext;
+export declare function setAstNodeContext(context: AstNodeContext): AstNodeContext;
+export declare function useAstNodeContext(): AstNodeContext;
+export declare const useAstNode: typeof useAstNodeContext;
+export declare function getNodeRenderKey(node: HastNode, markdown: string, index: number): string;
+//# sourceMappingURL=context.svelte.d.ts.map

package/dist/preview/renderer/context.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.svelte.d.ts","sourceRoot":"","sources":["../../../src/preview/renderer/context.svelte.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,iBAAiB,EACjB,aAAa,EACb,eAAe,EACf,gBAAgB,EAChB,sBAAsB,EACtB,uBAAuB,EACxB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EACV,QAAQ,EACR,qBAAqB,EACrB,mBAAmB,EACpB,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AACzE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,KAAK,EAAE,OAAO,IAAI,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAKpE,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,aAAa,EAAE,CAAC;IAC5B,aAAa,EAAE,SAAS,EAAE,CAAC;IAC3B,aAAa,EAAE,SAAS,EAAE,CAAC;IAC3B,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,UAAU,EAAE,sBAAsB,CAAC;IACnC,YAAY,CAAC,EAAE,gBAAgB,CAAC;IAChC,aAAa,CAAC,EAAE,iBAAiB,CAAC;IAClC,WAAW,CAAC,EAAE,eAAe,CAAC;IAC9B,YAAY,EAAE,uBAAuB,EAAE,CAAC;IACxC,WAAW,EAAE,mBAAmB,CAAC;IACjC,QAAQ,CAAC,EAAE,qBAAqB,CAAC;IACjC,mBAAmB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IACpE,eAAe,EAAE,OAAO,CAAC;IACzB,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IACtC,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,QAAQ,GAAG,IAAI,CAAC;CACzB,CAAC;AAEF,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,eAAe,GAAG,eAAe,CAG5E;AAED,wBAAgB,kBAAkB,IAAI,eAAe,CAEpD;AAED,wBAAgB,qBAAqB,IAAI,eAAe,GAAG,IAAI,CAE9D;AAED,eAAO,MAAM,WAAW,2BAAqB,CAAC;AAE9C,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,cAAc,GAAG,cAAc,CAGzE;AAED,wBAAgB,iBAAiB,IAAI,cAAc,CAElD;AAED,eAAO,MAAM,UAAU,0BAAoB,CAAC;AAE5C,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,GACZ,MAAM,CA8BR"}

package/dist/preview/renderer/context.svelte.js

@@ -0,0 +1,47 @@
+import { getContext, setContext } from "svelte";
+const MARKDOWN_CONTEXT = Symbol("mira-markdown-context");
+const AST_NODE_CONTEXT = Symbol("mira-ast-node-context");
+export function setMarkdownContext(context) {
+    setContext(MARKDOWN_CONTEXT, context);
+    return context;
+}
+export function useMarkdownContext() {
+    return getContext(MARKDOWN_CONTEXT);
+}
+export function tryUseMarkdownContext() {
+    return getContext(MARKDOWN_CONTEXT) ?? null;
+}
+export const useMarkdown = useMarkdownContext;
+export function setAstNodeContext(context) {
+    setContext(AST_NODE_CONTEXT, context);
+    return context;
+}
+export function useAstNodeContext() {
+    return getContext(AST_NODE_CONTEXT);
+}
+export const useAstNode = useAstNodeContext;
+export function getNodeRenderKey(node, markdown, index) {
+    const typedNode = node;
+    const startOffset = typedNode.position?.start?.offset ?? typedNode.position?.start?.line;
+    const endOffset = typedNode.position?.end?.offset;
+    const excerpt = typeof startOffset === "number"
+        ? markdown.slice(startOffset, typeof endOffset === "number"
+            ? Math.min(endOffset, startOffset + 96)
+            : startOffset + 48)
+        : (typedNode.value?.slice(0, 48) ?? "");
+    return [
+        typedNode.type,
+        typedNode.tagName ?? "",
+        startOffset ?? index,
+        endOffset ?? "",
+        hashString(excerpt),
+        index,
+    ].join(":");
+}
+function hashString(value) {
+    let hash = 5381;
+    for (let index = 0; index < value.length; index += 1) {
+        hash = (hash * 33) ^ value.charCodeAt(index);
+    }
+    return (hash >>> 0).toString(36);
+}