@lapismd/mira 0.0.4 → 0.1.0

package/dist/core/images.test.js

@@ -1,109 +0,0 @@
-// @vitest-environment jsdom
-import { EditorView } from "@codemirror/view";
-import { describe, expect, it, vi } from "vitest";
-import { createImageMarkdown, createUploadingImageMarkdown, insertImageFiles, miraUploadingImageScheme, } from "./images";
-function createView(doc = "") {
-    const parent = document.createElement("div");
-    document.body.append(parent);
-    const view = new EditorView({ doc, parent });
-    return {
-        view,
-        destroy() {
-            view.destroy();
-            parent.remove();
-        },
-    };
-}
-function pngFile(name = "shot.png") {
-    return new File([new Uint8Array([137, 80, 78, 71])], name, {
-        type: "image/png",
-    });
-}
-describe("image markdown insertion", () => {
-    it("generates reference-style image markdown by default", () => {
-        expect(createImageMarkdown({
-            alt: "Alt Text",
-            doc: "",
-            src: "data:image/png;base64,abc=",
-            syntax: "reference",
-        })).toBe("![Alt Text][alt-text]\n\n[alt-text]: data:image/png;base64,abc=");
-    });
-    it("avoids colliding with existing image reference labels", () => {
-        expect(createImageMarkdown({
-            alt: "Alt Text",
-            doc: "[alt-text]: old",
-            src: "data:image/png;base64,abc=",
-            syntax: "reference",
-        })).toContain("[alt-text-2]: data:image/png;base64,abc=");
-    });
-    it("can generate Carta-compatible inline image markdown", () => {
-        expect(createImageMarkdown({
-            alt: "Alt Text",
-            doc: "",
-            src: "data:image/png;base64,abc=",
-            syntax: "inline",
-        })).toBe("![Alt Text](data:image/png;base64,abc=)");
-    });
-    it("creates GitHub-style uploading placeholders with unique tokens", () => {
-        const placeholder = createUploadingImageMarkdown(pngFile(), "abc-123");
-        expect(placeholder).toBe(`![Uploading shot.png…](${miraUploadingImageScheme}abc-123)`);
-    });
-    it("inserts uploading placeholders then replaces them when upload finishes", async () => {
-        const { view, destroy } = createView("Before ");
-        view.dispatch({
-            selection: { anchor: view.state.doc.length },
-        });
-        let resolveUpload;
-        const upload = new Promise((resolve) => {
-            resolveUpload = resolve;
-        });
-        const insertPromise = insertImageFiles(view, [pngFile()], {
-            imageUpload: () => upload,
-            imageSyntax: "inline",
-        });
-        expect(view.state.doc.toString()).toMatch(/^Before !\[Uploading shot\.png…\]\(mira-uploading:[^)]+\)$/);
-        resolveUpload("https://cdn.example/shot.png");
-        await insertPromise;
-        expect(view.state.doc.toString()).toBe("Before ![shot](https://cdn.example/shot.png)");
-        destroy();
-    });
-    it("removes the placeholder when upload fails", async () => {
-        const { view, destroy } = createView("Hello");
-        view.dispatch({
-            selection: { anchor: view.state.doc.length },
-        });
-        const onImageUploadError = vi.fn();
-        await insertImageFiles(view, [pngFile()], {
-            imageUpload: async () => {
-                throw new Error("upload failed");
-            },
-            imageSyntax: "inline",
-            onImageUploadError,
-        });
-        expect(view.state.doc.toString()).toBe("Hello");
-        expect(onImageUploadError).toHaveBeenCalledOnce();
-        destroy();
-    });
-    it("uploads multiple images in parallel with distinct placeholders", async () => {
-        const { view, destroy } = createView("");
-        const resolvers = [];
-        const uploads = [
-            new Promise((resolve) => resolvers.push(resolve)),
-            new Promise((resolve) => resolvers.push(resolve)),
-        ];
-        let uploadIndex = 0;
-        const insertPromise = insertImageFiles(view, [pngFile("a.png"), pngFile("b.png")], {
-            imageUpload: () => uploads[uploadIndex++],
-            imageSyntax: "inline",
-        });
-        const during = view.state.doc.toString();
-        expect(during).toContain("![Uploading a.png…](");
-        expect(during).toContain("![Uploading b.png…](");
-        expect(during.match(/mira-uploading:/g)?.length).toBe(2);
-        resolvers[1]("https://cdn.example/b.png");
-        resolvers[0]("https://cdn.example/a.png");
-        await insertPromise;
-        expect(view.state.doc.toString()).toBe("![a](https://cdn.example/a.png)\n\n![b](https://cdn.example/b.png)");
-        destroy();
-    });
-});

package/dist/core/index.test.d.ts

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

package/dist/core/index.test.d.ts.map

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

package/dist/core/index.test.js

@@ -1,11 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { EditorState } from "@codemirror/state";
-import { fromOffset, toOffset } from ".";
-describe("position conversion", () => {
-    it("round trips offsets and editor positions", () => {
-        const state = EditorState.create({ doc: "one\ntwo" });
-        const position = fromOffset(state.doc, 5);
-        expect(position).toEqual({ line: 1, ch: 1 });
-        expect(toOffset(state.doc, position)).toBe(5);
-    });
-});

package/dist/core/markdown-actions.test.d.ts

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

package/dist/core/markdown-actions.test.d.ts.map

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

package/dist/core/markdown-actions.test.js

@@ -1,182 +0,0 @@
-import { EditorSelection } from "@codemirror/state";
-import { redo, undo } from "@codemirror/commands";
-import { describe, expect, it } from "vitest";
-import { createBaseCodeMirrorExtensions } from "../internal/codemirror/base";
-import { createMarkdownCodeMirrorExtensions } from "../internal/codemirror/markdown";
-import { isMiraMarkdownActionActive, MiraEditorController } from ".";
-function createController(value, options = {}) {
-    return new MiraEditorController({
-        value,
-        codeMirrorExtensions: [
-            createBaseCodeMirrorExtensions({
-                lineNumbers: false,
-                readonly: options.readonly,
-            }),
-            createMarkdownCodeMirrorExtensions({ sourceMode: true }),
-        ],
-        onChange(next, change) {
-            options.onChange?.(next, change.userEvent);
-        },
-    });
-}
-function select(controller, anchor, head = anchor) {
-    controller.view.dispatch({
-        selection: EditorSelection.single(anchor, head),
-    });
-}
-function apply(value, action, anchor, head = anchor) {
-    const controller = createController(value);
-    select(controller, anchor, head);
-    expect(controller.applyMarkdownAction(action)).toBe(true);
-    return {
-        controller,
-        selection: controller.view.state.selection.main,
-        value: controller.getValue(),
-    };
-}
-describe("inline Markdown toolbar actions", () => {
-    it("reports an exact formatted selection as active", () => {
-        const controller = createController("A **bold** word");
-        select(controller, 4, 8);
-        expect(isMiraMarkdownActionActive(controller.view.state, "bold")).toBe(true);
-        expect(isMiraMarkdownActionActive(controller.view.state, "italic")).toBe(false);
-        select(controller, 5, 8);
-        expect(isMiraMarkdownActionActive(controller.view.state, "bold")).toBe(false);
-    });
-    it.each([
-        ["bold", "word", "**word**"],
-        ["italic", "word", "_word_"],
-        ["strikethrough", "word", "~~word~~"],
-        ["inlineCode", "word", "`word`"],
-    ])("wraps the current word for %s", (action, source, expected) => {
-        const result = apply(source, action, 2);
-        expect(result.value).toBe(expected);
-        expect(result.selection.anchor).toBe(2 + expected.indexOf(source) - 0);
-        expect(result.selection.empty).toBe(true);
-    });
-    it.each([
-        ["bold", "**word**", 4],
-        ["bold", "__word__", 4],
-        ["italic", "_word_", 3],
-        ["italic", "*word*", 3],
-        ["strikethrough", "~~word~~", 4],
-        ["inlineCode", "`word`", 3],
-    ])("removes enclosing %s syntax at the caret", (action, source, caret) => {
-        const result = apply(source, action, caret);
-        expect(result.value).toBe("word");
-        expect(result.selection.anchor).toBe(caret - (source.length - 4) / 2);
-    });
-    it("wraps and unwraps an exact selection while preserving its direction", () => {
-        const wrapped = apply("one two", "bold", 7, 4);
-        expect(wrapped.value).toBe("one **two**");
-        expect(wrapped.selection.anchor).toBe(9);
-        expect(wrapped.selection.head).toBe(6);
-        expect(wrapped.controller.applyMarkdownAction("bold")).toBe(true);
-        expect(wrapped.controller.getValue()).toBe("one two");
-        expect(wrapped.controller.view.state.selection.main.anchor).toBe(7);
-        expect(wrapped.controller.view.state.selection.main.head).toBe(4);
-    });
-    it("inserts empty delimiter pairs on whitespace and places the caret inside", () => {
-        const result = apply("one two", "bold", 3);
-        expect(result.value).toBe("one**** two");
-        expect(result.selection.anchor).toBe(5);
-    });
-    it("uses a longer inline-code fence when the selection contains backticks", () => {
-        const result = apply("a`b", "inlineCode", 0, 3);
-        expect(result.value).toBe("``a`b``");
-    });
-    it("preserves nested formatting when removing only the requested syntax", () => {
-        const result = apply("**bold _and italic_**", "bold", 8);
-        expect(result.value).toBe("bold _and italic_");
-    });
-    it("wraps a current word as a link, selects its target, and unlinks from the target", () => {
-        const linked = apply("Visit Mira today", "link", 8);
-        expect(linked.value).toBe("Visit [Mira](https://example.com) today");
-        expect(linked.controller.view.state.sliceDoc(linked.selection.from, linked.selection.to)).toBe("https://example.com");
-        expect(linked.controller.applyMarkdownAction("link")).toBe(true);
-        expect(linked.controller.getValue()).toBe("Visit Mira today");
-    });
-    it("creates one undoable transaction with the formatting user event", () => {
-        const changes = [];
-        const controller = createController("word", {
-            onChange(value, event) {
-                changes.push({ value, event });
-            },
-        });
-        select(controller, 2);
-        expect(controller.applyMarkdownAction("bold")).toBe(true);
-        expect(changes).toEqual([{ value: "**word**", event: "input.format" }]);
-        expect(undo(controller.view)).toBe(true);
-        expect(controller.getValue()).toBe("word");
-        expect(redo(controller.view)).toBe(true);
-        expect(controller.getValue()).toBe("**word**");
-    });
-    it("preserves the editor scroll position while restoring focus", () => {
-        const controller = createController("word");
-        const host = document.createElement("div");
-        document.body.append(host);
-        controller.mount(host);
-        select(controller, 2);
-        controller.view.scrollDOM.scrollTop = 31;
-        controller.view.scrollDOM.scrollLeft = 7;
-        expect(controller.applyMarkdownAction("bold")).toBe(true);
-        expect(controller.view.hasFocus).toBe(true);
-        expect(controller.view.scrollDOM.scrollTop).toBe(31);
-        expect(controller.view.scrollDOM.scrollLeft).toBe(7);
-        controller.destroy();
-        host.remove();
-    });
-    it("rejects authoring actions in a readonly editor", () => {
-        const controller = createController("word", { readonly: true });
-        select(controller, 2);
-        expect(controller.applyMarkdownAction("bold")).toBe(false);
-        expect(controller.getValue()).toBe("word");
-    });
-});
-describe("line Markdown toolbar actions", () => {
-    it("adds and removes exactly one H1 prefix at a caret within the line", () => {
-        const result = apply("Paragraph", "heading", 4);
-        expect(result.value).toBe("# Paragraph");
-        expect(result.selection.anchor).toBe(6);
-        expect(result.controller.applyMarkdownAction("heading")).toBe(true);
-        expect(result.controller.getValue()).toBe("Paragraph");
-        expect(result.controller.view.state.selection.main.anchor).toBe(4);
-    });
-    it("removes existing ATX and Setext heading syntax", () => {
-        expect(apply("### Heading ###", "heading", 6).value).toBe("Heading");
-        expect(apply("Heading\n=======", "heading", 3).value).toBe("Heading");
-    });
-    it("normalizes mixed selected lines to H1 and excludes a final column-zero line", () => {
-        const source = "## Existing\nPlain\nUntouched";
-        const result = apply(source, "heading", 0, source.indexOf("Untouched"));
-        expect(result.value).toBe("# Existing\n# Plain\nUntouched");
-    });
-    it("normalizes mixed blockquote lines and toggles them off together", () => {
-        const source = "> Quoted\nPlain\n\nLast";
-        const result = apply(source, "quote", 0, source.length);
-        expect(result.value).toBe("> Quoted\n> Plain\n>\n> Last");
-        expect(result.controller.applyMarkdownAction("quote")).toBe(true);
-        expect(result.controller.getValue()).toBe("Quoted\nPlain\n\nLast");
-    });
-    it("preserves list and quote ancestry when adding nested block prefixes", () => {
-        expect(apply("- Item", "quote", 4).value).toBe("- > Item");
-        expect(apply("> Item", "bulletList", 4).value).toBe("> - Item");
-        expect(apply("> - Item", "heading", 6).value).toBe("> - # Item");
-    });
-    it("normalizes and converts bullet, ordered, and task markers", () => {
-        const source = "- Bullet\n2. Ordered\n* [x] Done";
-        const tasks = apply(source, "taskList", 0, source.length);
-        expect(tasks.value).toBe("- [ ] Bullet\n- [ ] Ordered\n* [x] Done");
-        const numbered = apply(tasks.value, "numberedList", 0, tasks.value.length);
-        expect(numbered.value).toBe("1. Bullet\n1. Ordered\n1. Done");
-    });
-    it("removes custom task markers without leaving checkbox delimiters", () => {
-        const source = "- [?] Question\n- [>] Forwarded";
-        const result = apply(source, "taskList", 0, source.length);
-        expect(result.value).toBe("Question\nForwarded");
-    });
-    it("skips selected blank rows for lists but starts a list on an empty caret line", () => {
-        expect(apply("One\n\nTwo", "bulletList", 0, 8).value).toBe("- One\n\n- Two");
-        expect(apply("", "numberedList", 0).value).toBe("1. ");
-    });
-});

package/dist/extensions/doodle-dividers.test.d.ts

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

package/dist/extensions/doodle-dividers.test.d.ts.map

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

package/dist/extensions/doodle-dividers.test.js

@@ -1,296 +0,0 @@
-import { history, undo } from "@codemirror/commands";
-import { EditorState, Transaction } from "@codemirror/state";
-import { EditorView } from "@codemirror/view";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { createMiraMarkdownLanguage } from "../internal/codemirror/markdown";
-import { collectMarkdownBlockRanges, duplicateMarkdownBlockRange, } from "../internal/codemirror/rich/block-ranges";
-import { defaultMiraDoodleDividerVariants, doodleDividersExtension, materializeDoodleDividerSeeds, } from ".";
-import { createMiraDoodleDividerRandom, resolveMiraDoodleDividerDrawing, } from "./doodle-dividers";
-const editors = [];
-afterEach(() => {
-    for (const editor of editors.splice(0)) {
-        const parent = editor.dom.parentElement;
-        editor.destroy();
-        parent?.remove();
-    }
-});
-describe("doodle divider seed materialization", () => {
-    it("adds seeds only to semantic unseeded thematic breaks", () => {
-        let seed = 1;
-        const markdown = `---
-title: Demo
----
-
-Setext heading
----
-
-| Column |
-| --- |
-| Value |
-
----
-
-> ---
-
-<!-- mira-divider:v1:000000ff -->
-***`;
-        expect(materializeDoodleDividerSeeds(markdown, {
-            createSeed: () => seed++,
-        })).toBe(`---
-title: Demo
----
-
-Setext heading
----
-
-| Column |
-| --- |
-| Value |
-
-<!-- mira-divider:v1:00000001 -->
----
-
-> <!-- mira-divider:v1:00000002 -->
-> ---
-
-<!-- mira-divider:v1:000000ff -->
-***`);
-    });
-    it("keeps existing, malformed, and orphan comments distinct", () => {
-        const markdown = `<!-- mira-divider:v1:0000000a -->
----
-
-<!-- mira-divider:v2:0000000b -->
-
-Paragraph`;
-        expect(materializeDoodleDividerSeeds(markdown, { createSeed: () => 12 })).toBe(markdown);
-    });
-});
-describe("doodle divider authoring", () => {
-    it("seeds typed rules in the original undoable transaction", () => {
-        const createSeed = vi.fn(() => 0x2a);
-        const view = createEditor("Intro\n\n", createSeed);
-        const before = view.state.doc.toString();
-        view.dispatch({
-            changes: { from: before.length, insert: "---" },
-            annotations: Transaction.userEvent.of("input.type"),
-        });
-        expect(view.state.doc.toString()).toBe("Intro\n\n<!-- mira-divider:v1:0000002a -->\n---");
-        expect(createSeed).toHaveBeenCalledWith({
-            line: 3,
-            offset: 7,
-            reason: "authoring",
-            sourcePath: "notes/dividers.md",
-        });
-        expect(undo(view)).toBe(true);
-        expect(view.state.doc.toString()).toBe(before);
-    });
-    it("seeds multiple pasted rules and preserves a pasted authored pair", () => {
-        let seed = 1;
-        const view = createEditor("", () => seed++);
-        const pasted = `Intro
-
----
-
-<!-- mira-divider:v1:000000ff -->
-***
-
-> ---`;
-        view.dispatch({
-            changes: { from: 0, insert: pasted },
-            annotations: Transaction.userEvent.of("input.paste"),
-        });
-        expect(view.state.doc.toString()).toBe(`Intro
-
-<!-- mira-divider:v1:00000001 -->
----
-
-<!-- mira-divider:v1:000000ff -->
-***
-
-> <!-- mira-divider:v1:00000002 -->
-> ---`);
-    });
-    it("does not rewrite existing bare rules on mount or unrelated edits", () => {
-        const createSeed = vi.fn(() => 1);
-        const view = createEditor("---\n\nParagraph", createSeed);
-        view.dispatch({ selection: { anchor: view.state.doc.length } });
-        view.dispatch({
-            changes: { from: view.state.doc.length, insert: "!" },
-            annotations: Transaction.userEvent.of("input.type"),
-        });
-        expect(view.state.doc.toString()).toBe("---\n\nParagraph!");
-        expect(createSeed).not.toHaveBeenCalled();
-    });
-    it("gives an editor-duplicated pair a fresh seed", () => {
-        const view = createEditor("<!-- mira-divider:v1:00000001 -->\n---\n\nParagraph\n", () => 2);
-        const divider = collectMarkdownBlockRanges(view.state)[0];
-        duplicateMarkdownBlockRange(view, divider);
-        expect(view.state.doc.toString()).toBe(`<!-- mira-divider:v1:00000001 -->
----
-
-<!-- mira-divider:v1:00000002 -->
----
-
-Paragraph
-`);
-    });
-    it("materializes existing rules through the contributed command", () => {
-        const extension = doodleDividersExtension({ createSeed: () => 9 });
-        const view = createEditor("Alpha\n\n---\n", () => 9);
-        const command = extension.commands?.find((candidate) => candidate.id === "mira-doodle-dividers-materialize");
-        if (!command)
-            throw new Error("Materialize command was not contributed");
-        const scrollTop = 18;
-        view.scrollDOM.scrollTop = scrollTop;
-        command.run({
-            view,
-            mode: "source",
-            readonly: false,
-            sourcePath: "notes/dividers.md",
-            getValue: () => view.state.doc.toString(),
-            setValue: () => undefined,
-            focus: () => view.focus(),
-            insertMarkdown: () => undefined,
-        });
-        expect(view.state.doc.toString()).toBe("Alpha\n\n<!-- mira-divider:v1:00000009 -->\n---\n");
-        expect(view.scrollDOM.scrollTop).toBe(scrollTop);
-        expect(undo(view)).toBe(true);
-        expect(view.state.doc.toString()).toBe("Alpha\n\n---\n");
-    });
-});
-describe("doodle divider rendering", () => {
-    it("enhances only a rule immediately preceded by a valid seed comment", () => {
-        const extension = doodleDividersExtension();
-        const processor = extension.postProcessors?.[0];
-        if (!processor)
-            throw new Error("Doodle postprocessor was not contributed");
-        const parent = document.createElement("div");
-        const hr = document.createElement("hr");
-        parent.append(hr);
-        const comment = {
-            type: "comment",
-            value: " mira-divider:v1:4f32a91c ",
-        };
-        const node = { type: "element", tagName: "hr" };
-        const cleanup = processor(parent.firstElementChild, node, {
-            type: "root",
-            children: [comment, node],
-        });
-        const svg = parent.querySelector(".mira-doodle-divider");
-        expect(hr.classList.contains("mira-doodle-divider__native")).toBe(true);
-        expect(hr.getAttribute("role")).toBeNull();
-        expect(svg?.getAttribute("aria-hidden")).toBe("true");
-        expect(svg?.dataset.seed).toBe("4f32a91c");
-        expect(svg?.querySelectorAll("path").length).toBeGreaterThan(0);
-        expect(parent.querySelector(".mira-doodle-divider__controls")).toBeNull();
-        expect(cleanup).toBeTypeOf("function");
-        cleanup?.();
-        expect(parent.querySelector(".mira-doodle-divider")).toBeNull();
-        expect(hr.classList.contains("mira-doodle-divider__native")).toBe(false);
-    });
-    it("falls back to the native rule for bare rules and invalid drawings", () => {
-        const bare = doodleDividersExtension().postProcessors?.[0];
-        const invalid = doodleDividersExtension({
-            variants: [{ id: "invalid", draw: () => "M NaN Infinity" }],
-        }).postProcessors?.[0];
-        if (!bare || !invalid) {
-            throw new Error("Doodle postprocessors were not contributed");
-        }
-        for (const [processor, previous] of [
-            [bare, { type: "text", value: "ordinary" }],
-            [invalid, { type: "comment", value: " mira-divider:v1:00000001 " }],
-        ]) {
-            const parent = document.createElement("div");
-            const hr = document.createElement("hr");
-            parent.append(hr);
-            const node = { type: "element", tagName: "hr" };
-            processor(hr, node, { children: [previous, node] });
-            expect(hr.className).toBe("");
-            expect(parent.children).toHaveLength(1);
-        }
-    });
-    it("keeps path generation stable and independent from palette changes", () => {
-        const first = resolveMiraDoodleDividerDrawing(0x4f32a91c);
-        const second = resolveMiraDoodleDividerDrawing(0x4f32a91c, {
-            palette: ["red", "blue"],
-        });
-        expect(second?.variant.id).toBe(first?.variant.id);
-        expect(second?.paths).toEqual(first?.paths);
-        expect(resolveMiraDoodleDividerDrawing(1, { variants: [] })).toBeNull();
-        expect(resolveMiraDoodleDividerDrawing(1, { palette: [] })).toBeNull();
-    });
-    it("freezes a deterministic golden path for every v1 variant", () => {
-        const paths = defaultMiraDoodleDividerVariants.map((entry) => ({
-            id: entry.id,
-            path: entry.draw({
-                seed: 0x12345678,
-                width: 1000,
-                height: 32,
-                random: createMiraDoodleDividerRandom(0x12345678),
-            }),
-        }));
-        expect(paths.map(({ id }) => id)).toEqual([
-            "scribble",
-            "waves",
-            "loop",
-            "zigzag",
-            "kink",
-            "swoop",
-            "notch",
-            "plain",
-        ]);
-        expect(paths.every(({ path }) => !String(path).match(/NaN|Infinity/u))).toBe(true);
-        expect(paths.map(({ path }) => stableHash(String(path)))).toEqual([
-            1800713089, 582965354, 1904425823, 2348662072, 1740792941, 1779022722,
-            395463394, 1422833353,
-        ]);
-    });
-    it("keeps the long divider tails close to horizontal", () => {
-        const paths = defaultMiraDoodleDividerVariants.slice(0, -1).map((entry) => String(entry.draw({
-            seed: 0x12345678,
-            width: 1000,
-            height: 32,
-            random: createMiraDoodleDividerRandom(0x12345678),
-        })));
-        for (const path of paths) {
-            const tail = path.match(/C [\d.]+ ([\d.]+) 748 ([\d.]+) 994 ([\d.]+)$/u);
-            expect(tail, path).not.toBeNull();
-            const controlY = Number(tail?.[1]);
-            const secondControlY = Number(tail?.[2]);
-            const endY = Number(tail?.[3]);
-            expect(Math.abs(controlY - secondControlY)).toBeLessThan(0.01);
-            expect(Math.abs(controlY - endY)).toBeLessThan(1.5);
-        }
-    });
-});
-function createEditor(markdown, createSeed) {
-    const extension = doodleDividersExtension({ createSeed });
-    const parent = document.createElement("div");
-    document.body.append(parent);
-    const view = new EditorView({
-        state: EditorState.create({
-            doc: markdown,
-            extensions: [
-                history(),
-                createMiraMarkdownLanguage(),
-                extension.codeMirror?.({
-                    mode: "source",
-                    readonly: false,
-                    sourcePath: "notes/dividers.md",
-                }) ?? [],
-            ],
-        }),
-        parent,
-    });
-    editors.push(view);
-    return view;
-}
-function stableHash(value) {
-    let hash = 2_166_136_261;
-    for (let index = 0; index < value.length; index += 1) {
-        hash ^= value.charCodeAt(index);
-        hash = Math.imul(hash, 16_777_619);
-    }
-    return hash >>> 0;
-}

package/dist/extensions/index.test.d.ts

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

package/dist/extensions/index.test.d.ts.map

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