@lapismd/mira 0.0.1

package/dist/preview/editable-markdown-preview/serialized-writer.d.ts

@@ -0,0 +1,36 @@
+export type SerializedMarkdownWriterState = {
+    dirty: boolean;
+    saving: boolean;
+    error: Error | null;
+    value: string;
+    persistedValue: string;
+};
+type Options = {
+    value: string;
+    write: (value: string) => void | Promise<void>;
+    delay?: number;
+    onStateChange?: (state: SerializedMarkdownWriterState) => void;
+};
+export declare class SerializedMarkdownWriter {
+    private readonly write;
+    private readonly delay;
+    private readonly onStateChange?;
+    private timer;
+    private flushPromise;
+    private value;
+    private persistedValue;
+    private saving;
+    private error;
+    constructor(options: Options);
+    get state(): SerializedMarkdownWriterState;
+    update(value: string): void;
+    replaceExternal(value: string): boolean;
+    flush(): Promise<boolean>;
+    destroy(): void;
+    private schedule;
+    private flushLatest;
+    private clearTimer;
+    private emit;
+}
+export {};
+//# sourceMappingURL=serialized-writer.d.ts.map

package/dist/preview/editable-markdown-preview/serialized-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialized-writer.d.ts","sourceRoot":"","sources":["../../../src/preview/editable-markdown-preview/serialized-writer.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,6BAA6B,GAAG;IAC1C,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,6BAA6B,KAAK,IAAI,CAAC;CAChE,CAAC;AAEF,qBAAa,wBAAwB;IACnC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAmB;IAEzC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAE/B,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAC,CAA2B;IAE1D,OAAO,CAAC,KAAK,CAA8C;IAE3D,OAAO,CAAC,YAAY,CAAiC;IAErD,OAAO,CAAC,KAAK,CAAS;IAEtB,OAAO,CAAC,cAAc,CAAS;IAE/B,OAAO,CAAC,MAAM,CAAS;IAEvB,OAAO,CAAC,KAAK,CAAsB;gBAEvB,OAAO,EAAE,OAAO;IAS5B,IAAI,KAAK,IAAI,6BAA6B,CAQzC;IAED,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAO3B,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAYjC,KAAK,IAAI,OAAO,CAAC,OAAO,CAAC;IAkB/B,OAAO,IAAI,IAAI;IAOf,OAAO,CAAC,QAAQ;YAYF,WAAW;IA0BzB,OAAO,CAAC,UAAU;IAOlB,OAAO,CAAC,IAAI;CAGb"}

package/dist/preview/editable-markdown-preview/serialized-writer.js

@@ -0,0 +1,109 @@
+export class SerializedMarkdownWriter {
+    write;
+    delay;
+    onStateChange;
+    timer = null;
+    flushPromise = null;
+    value;
+    persistedValue;
+    saving = false;
+    error = null;
+    constructor(options) {
+        this.value = options.value;
+        this.persistedValue = options.value;
+        this.write = options.write;
+        this.delay = options.delay ?? 500;
+        this.onStateChange = options.onStateChange;
+        this.emit();
+    }
+    get state() {
+        return {
+            dirty: this.value !== this.persistedValue,
+            saving: this.saving,
+            error: this.error,
+            value: this.value,
+            persistedValue: this.persistedValue,
+        };
+    }
+    update(value) {
+        this.value = value;
+        this.error = null;
+        this.schedule();
+        this.emit();
+    }
+    replaceExternal(value) {
+        if (this.state.dirty || this.saving) {
+            return false;
+        }
+        this.value = value;
+        this.persistedValue = value;
+        this.error = null;
+        this.emit();
+        return true;
+    }
+    async flush() {
+        this.clearTimer();
+        if (this.flushPromise) {
+            const saved = await this.flushPromise;
+            if (!saved) {
+                return false;
+            }
+            return this.state.dirty ? this.flush() : true;
+        }
+        this.flushPromise = this.flushLatest();
+        try {
+            return await this.flushPromise;
+        }
+        finally {
+            this.flushPromise = null;
+        }
+    }
+    destroy() {
+        this.clearTimer();
+        if (this.state.dirty) {
+            void this.flush();
+        }
+    }
+    schedule() {
+        this.clearTimer();
+        if (!this.state.dirty) {
+            return;
+        }
+        this.timer = setTimeout(() => {
+            this.timer = null;
+            void this.flush();
+        }, this.delay);
+    }
+    async flushLatest() {
+        while (this.value !== this.persistedValue) {
+            const snapshot = this.value;
+            this.saving = true;
+            this.error = null;
+            this.emit();
+            try {
+                await this.write(snapshot);
+            }
+            catch (cause) {
+                this.saving = false;
+                this.error =
+                    cause instanceof Error ? cause : new Error("Unable to save Markdown");
+                this.emit();
+                return false;
+            }
+            this.persistedValue = snapshot;
+            this.saving = false;
+            this.error = null;
+            this.emit();
+        }
+        return true;
+    }
+    clearTimer() {
+        if (this.timer !== null) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+    }
+    emit() {
+        this.onStateChange?.(this.state);
+    }
+}

package/dist/preview/editable-markdown-preview/serialized-writer.test.d.ts

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

package/dist/preview/editable-markdown-preview/serialized-writer.test.d.ts.map

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

package/dist/preview/editable-markdown-preview/serialized-writer.test.js

@@ -0,0 +1,59 @@
+import { describe, expect, it, vi } from "vitest";
+import { SerializedMarkdownWriter } from "./serialized-writer";
+describe("SerializedMarkdownWriter", () => {
+    it("debounces writes for 500ms", async () => {
+        vi.useFakeTimers();
+        const write = vi.fn();
+        const writer = new SerializedMarkdownWriter({ value: "old", write });
+        writer.update("one");
+        writer.update("two");
+        await vi.advanceTimersByTimeAsync(499);
+        expect(write).not.toHaveBeenCalled();
+        await vi.advanceTimersByTimeAsync(1);
+        expect(write).toHaveBeenCalledOnce();
+        expect(write).toHaveBeenCalledWith("two");
+        vi.useRealTimers();
+    });
+    it("serializes writes and flushes the latest value", async () => {
+        let releaseFirst;
+        const writes = [];
+        const write = vi.fn((value) => {
+            writes.push(value);
+            if (writes.length === 1) {
+                return new Promise((resolve) => {
+                    releaseFirst = resolve;
+                });
+            }
+        });
+        const writer = new SerializedMarkdownWriter({ value: "old", write });
+        writer.update("one");
+        const firstFlush = writer.flush();
+        await Promise.resolve();
+        writer.update("two");
+        const secondFlush = writer.flush();
+        expect(writes).toEqual(["one"]);
+        releaseFirst?.();
+        await expect(firstFlush).resolves.toBe(true);
+        await expect(secondFlush).resolves.toBe(true);
+        expect(writes).toEqual(["one", "two"]);
+        expect(writer.state.dirty).toBe(false);
+    });
+    it("preserves dirty data and rejects external replacement after failure", async () => {
+        const writer = new SerializedMarkdownWriter({
+            value: "old",
+            write: async () => {
+                throw new Error("disk full");
+            },
+        });
+        writer.update("unsaved");
+        await expect(writer.flush()).resolves.toBe(false);
+        expect(writer.state).toMatchObject({
+            dirty: true,
+            saving: false,
+            value: "unsaved",
+        });
+        expect(writer.state.error?.message).toBe("disk full");
+        expect(writer.replaceExternal("external")).toBe(false);
+        expect(writer.state.value).toBe("unsaved");
+    });
+});

package/dist/preview/editable-markdown-preview.svelte

@@ -0,0 +1,195 @@
+<script lang="ts">
+  import type {
+    MiraAssetResolver,
+    MiraExtension,
+    MiraFileAdapter,
+    MiraFileRef,
+    MiraImageConfig,
+    MiraLinkResolver,
+    MiraListCallout,
+    MiraMarkdownAuthoringConfig,
+    MiraMarkdownPostProcessor,
+    MiraRendererComponents,
+  } from "@lapismd/mira/extensions";
+  import type { FrontmatterConfig } from "./components/frontmatter-utils";
+  import EditableMarkdownSurface from "./editable-markdown-preview/editable-markdown-surface.svelte";
+  import MarkdownEmbed from "./markdown-embed.svelte";
+
+  type Props = {
+    file: MiraFileRef;
+    fileAdapter: MiraFileAdapter;
+    editing?: boolean;
+    extensions?: MiraExtension[];
+    components?: MiraRendererComponents;
+    class?: string;
+    highlight?: boolean;
+    linkResolver?: MiraLinkResolver;
+    assetResolver?: MiraAssetResolver;
+    imageConfig?: MiraImageConfig;
+    authoring?: MiraMarkdownAuthoringConfig;
+    frontmatterOpen?: boolean;
+    frontmatterConfig?: FrontmatterConfig;
+    headingIds?: boolean;
+    headingIdPrefix?: string;
+    htmlPolicy?: "trusted" | "safe";
+    emoji?: boolean;
+    dialog?: boolean;
+    listCallouts?: MiraListCallout[];
+    postProcess?: MiraMarkdownPostProcessor;
+    activateOnPreviewInteraction?: boolean;
+    returnToPreviewOnBlur?: boolean;
+    focusEditorOnEdit?: boolean;
+    onEditingChange?: (editing: boolean) => void;
+    onEscape?: () => void;
+    onFrontmatterChange?: (nextYaml: string, nextValue: string) => void;
+  };
+
+  let {
+    file,
+    fileAdapter,
+    editing = $bindable(false),
+    extensions = [],
+    components = {},
+    class: className = "",
+    highlight = true,
+    linkResolver,
+    assetResolver,
+    imageConfig,
+    authoring,
+    frontmatterOpen = false,
+    frontmatterConfig,
+    headingIds = false,
+    headingIdPrefix = "",
+    htmlPolicy = "trusted",
+    emoji = false,
+    dialog = false,
+    listCallouts = [],
+    postProcess,
+    activateOnPreviewInteraction = true,
+    returnToPreviewOnBlur = true,
+    focusEditorOnEdit = true,
+    onEditingChange,
+    onEscape,
+    onFrontmatterChange,
+  }: Props = $props();
+
+  let value = $state("");
+  let loaded = $state(false);
+  let loadRevision = $state(0);
+  let surface: {
+    flush: () => Promise<boolean>;
+    exit: () => Promise<boolean>;
+  } | null = $state(null);
+  let previewOnChange:
+    | ((replacement: string, from: number, to: number) => void)
+    | undefined = $state(undefined);
+
+  const writeMarkdown = $derived(
+    fileAdapter.writeMarkdown &&
+      (file.kind === undefined || file.kind === "markdown")
+      ? (nextValue: string) => fileAdapter.writeMarkdown?.(file, nextValue)
+      : undefined,
+  );
+
+  $effect(() => {
+    const currentFile = file;
+    loadRevision;
+    if (!fileAdapter.readMarkdown) {
+      value = "";
+      loaded = true;
+      return;
+    }
+
+    let cancelled = false;
+    void Promise.resolve(fileAdapter.readMarkdown(currentFile)).then(
+      (nextValue) => {
+        if (!cancelled && nextValue !== null) {
+          value = nextValue;
+          loaded = true;
+        }
+      },
+      () => {
+        if (!cancelled) {
+          loaded = true;
+        }
+      },
+    );
+
+    return () => {
+      cancelled = true;
+    };
+  });
+
+  $effect(() => {
+    if (!fileAdapter.watchFile) {
+      return;
+    }
+    return fileAdapter.watchFile(file, () => {
+      loadRevision += 1;
+    });
+  });
+
+  export async function flush(): Promise<boolean> {
+    return (await surface?.flush()) ?? true;
+  }
+
+  export async function exit(): Promise<boolean> {
+    return (await surface?.exit()) ?? true;
+  }
+</script>
+
+{#snippet renderedPreview(markdown: string)}
+  <MarkdownEmbed
+    value={markdown}
+    sourcePath={file.path}
+    {extensions}
+    {components}
+    {highlight}
+    {linkResolver}
+    {assetResolver}
+    {fileAdapter}
+    {frontmatterOpen}
+    {frontmatterConfig}
+    {headingIds}
+    {headingIdPrefix}
+    {htmlPolicy}
+    {emoji}
+    {dialog}
+    {listCallouts}
+    {postProcess}
+    onChange={previewOnChange}
+  />
+{/snippet}
+
+{#if loaded}
+  <EditableMarkdownSurface
+    bind:this={surface}
+    {value}
+    preview={renderedPreview}
+    bind:previewOnChange
+    {writeMarkdown}
+    bind:editing
+    {extensions}
+    sourcePath={file.path}
+    {linkResolver}
+    {assetResolver}
+    {fileAdapter}
+    {imageConfig}
+    {authoring}
+    {frontmatterOpen}
+    {frontmatterConfig}
+    {activateOnPreviewInteraction}
+    {returnToPreviewOnBlur}
+    {focusEditorOnEdit}
+    class={className}
+    label={`Edit ${file.name || file.path}`}
+    onPersisted={(nextValue) => (value = nextValue)}
+    {onEditingChange}
+    {onEscape}
+    {onFrontmatterChange}
+  />
+{:else}
+  <div class={`mira-editable-markdown-preview ${className}`.trim()}>
+    <span class="mira-link-preview__empty">Loading preview…</span>
+  </div>
+{/if}

package/dist/preview/editable-markdown-preview.svelte.d.ts

@@ -0,0 +1,37 @@
+import type { MiraAssetResolver, MiraExtension, MiraFileAdapter, MiraFileRef, MiraImageConfig, MiraLinkResolver, MiraListCallout, MiraMarkdownAuthoringConfig, MiraMarkdownPostProcessor, MiraRendererComponents } from "@lapismd/mira/extensions";
+import type { FrontmatterConfig } from "./components/frontmatter-utils";
+type Props = {
+    file: MiraFileRef;
+    fileAdapter: MiraFileAdapter;
+    editing?: boolean;
+    extensions?: MiraExtension[];
+    components?: MiraRendererComponents;
+    class?: string;
+    highlight?: boolean;
+    linkResolver?: MiraLinkResolver;
+    assetResolver?: MiraAssetResolver;
+    imageConfig?: MiraImageConfig;
+    authoring?: MiraMarkdownAuthoringConfig;
+    frontmatterOpen?: boolean;
+    frontmatterConfig?: FrontmatterConfig;
+    headingIds?: boolean;
+    headingIdPrefix?: string;
+    htmlPolicy?: "trusted" | "safe";
+    emoji?: boolean;
+    dialog?: boolean;
+    listCallouts?: MiraListCallout[];
+    postProcess?: MiraMarkdownPostProcessor;
+    activateOnPreviewInteraction?: boolean;
+    returnToPreviewOnBlur?: boolean;
+    focusEditorOnEdit?: boolean;
+    onEditingChange?: (editing: boolean) => void;
+    onEscape?: () => void;
+    onFrontmatterChange?: (nextYaml: string, nextValue: string) => void;
+};
+declare const EditableMarkdownPreview: import("svelte").Component<Props, {
+    flush: () => Promise<boolean>;
+    exit: () => Promise<boolean>;
+}, "editing">;
+type EditableMarkdownPreview = ReturnType<typeof EditableMarkdownPreview>;
+export default EditableMarkdownPreview;
+//# sourceMappingURL=editable-markdown-preview.svelte.d.ts.map

package/dist/preview/editable-markdown-preview.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editable-markdown-preview.svelte.d.ts","sourceRoot":"","sources":["../../src/preview/editable-markdown-preview.svelte.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACR,iBAAiB,EACjB,aAAa,EACb,eAAe,EACf,WAAW,EACX,eAAe,EACf,gBAAgB,EAChB,eAAe,EACf,2BAA2B,EAC3B,yBAAyB,EACzB,sBAAsB,EACvB,MAAM,0BAA0B,CAAC;AACpC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AAKtE,KAAK,KAAK,GAAG;IACX,IAAI,EAAE,WAAW,CAAC;IAClB,WAAW,EAAE,eAAe,CAAC;IAC7B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,aAAa,EAAE,CAAC;IAC7B,UAAU,CAAC,EAAE,sBAAsB,CAAC;IACpC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,YAAY,CAAC,EAAE,gBAAgB,CAAC;IAChC,aAAa,CAAC,EAAE,iBAAiB,CAAC;IAClC,WAAW,CAAC,EAAE,eAAe,CAAC;IAC9B,SAAS,CAAC,EAAE,2BAA2B,CAAC;IACxC,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IACtC,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,UAAU,CAAC,EAAE,SAAS,GAAG,MAAM,CAAC;IAChC,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,YAAY,CAAC,EAAE,eAAe,EAAE,CAAC;IACjC,WAAW,CAAC,EAAE,yBAAyB,CAAC;IACxC,4BAA4B,CAAC,EAAE,OAAO,CAAC;IACvC,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,eAAe,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;IAC7C,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IACtB,mBAAmB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;CACrE,CAAC;AAoHJ,QAAA,MAAM,uBAAuB;iBArBF,OAAO,CAAC,OAAO,CAAC;gBAIjB,OAAO,CAAC,OAAO,CAAC;aAiB2B,CAAC;AACtE,KAAK,uBAAuB,GAAG,UAAU,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAC1E,eAAe,uBAAuB,CAAC"}

package/dist/preview/embed-target.d.ts

@@ -0,0 +1,13 @@
+import type { MiraTargetFragment } from "@lapismd/mira/extensions";
+export type MiraImageDetails = {
+    alt: string;
+    width?: number;
+    height?: number;
+};
+export type MiraMarkdownEmbedSelection = {
+    found: boolean;
+    markdown: string;
+};
+export declare function parseMiraImageDetails(details: string | undefined, fallbackAlt?: string): MiraImageDetails;
+export declare function selectMarkdownEmbedFragment(markdown: string, fragment?: MiraTargetFragment): MiraMarkdownEmbedSelection;
+//# sourceMappingURL=embed-target.d.ts.map

package/dist/preview/embed-target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embed-target.d.ts","sourceRoot":"","sources":["../../src/preview/embed-target.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAEnE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG;IACvC,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,WAAW,SAAK,GACf,gBAAgB,CAmBlB;AAED,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,MAAM,EAChB,QAAQ,CAAC,EAAE,kBAAkB,GAC5B,0BAA0B,CAQ5B"}

package/dist/preview/embed-target.js

@@ -0,0 +1,133 @@
+export function parseMiraImageDetails(details, fallbackAlt = "") {
+    const value = details?.trim() ?? "";
+    const segments = value.split("|");
+    const possibleSize = segments.at(-1)?.trim() ?? "";
+    const dimensions = parseDimensions(possibleSize);
+    if (!dimensions) {
+        return {
+            alt: value || fallbackAlt,
+        };
+    }
+    return {
+        alt: segments.length > 1
+            ? segments.slice(0, -1).join("|").trim()
+            : fallbackAlt,
+        ...dimensions,
+    };
+}
+export function selectMarkdownEmbedFragment(markdown, fragment) {
+    if (!fragment) {
+        return { found: true, markdown };
+    }
+    return fragment.kind === "heading"
+        ? selectHeadingSection(markdown, fragment.value)
+        : selectBlock(markdown, fragment.value);
+}
+function parseDimensions(value) {
+    const match = /^(\d+)\s*(?:x\s*(\d+))?$/iu.exec(value);
+    if (!match?.[1]) {
+        return null;
+    }
+    const width = Number.parseInt(match[1], 10);
+    const height = match[2] ? Number.parseInt(match[2], 10) : undefined;
+    if (!Number.isFinite(width) ||
+        width <= 0 ||
+        (height !== undefined && height <= 0)) {
+        return null;
+    }
+    return height === undefined ? { width } : { width, height };
+}
+function selectHeadingSection(markdown, requestedHeading) {
+    const lines = markdown.split("\n");
+    const headings = lines
+        .map((line, index) => parseHeading(line, lines[index + 1], index))
+        .filter((heading) => heading !== null);
+    const normalizedRequest = normalizeHeading(requestedHeading);
+    const requestedSlug = slugHeading(normalizedRequest);
+    const start = headings.find((heading) => normalizeHeading(heading.text) === normalizedRequest ||
+        slugHeading(heading.text) === requestedSlug);
+    if (!start) {
+        return { found: false, markdown: "" };
+    }
+    const next = headings.find((heading) => heading.line > start.line && heading.level <= start.level);
+    return {
+        found: true,
+        markdown: lines.slice(start.line, next?.line ?? lines.length).join("\n"),
+    };
+}
+function selectBlock(markdown, blockId) {
+    const normalizedId = blockId.trim();
+    if (!normalizedId) {
+        return { found: false, markdown: "" };
+    }
+    const lines = markdown.split("\n");
+    const escapedId = escapeRegExp(normalizedId);
+    const marker = new RegExp(`(?:^|\\s)\\^${escapedId}\\s*$`, "u");
+    const markerLine = lines.findIndex((line) => marker.test(line));
+    if (markerLine === -1) {
+        return { found: false, markdown: "" };
+    }
+    let from = markerLine;
+    while (from > 0 && lines[from - 1]?.trim()) {
+        from -= 1;
+    }
+    let to = markerLine + 1;
+    while (to < lines.length && lines[to]?.trim()) {
+        to += 1;
+    }
+    const selected = lines.slice(from, to);
+    const relativeMarkerLine = markerLine - from;
+    selected[relativeMarkerLine] = (selected[relativeMarkerLine] ?? "")
+        .replace(marker, "")
+        .trimEnd();
+    return {
+        found: true,
+        markdown: selected
+            .filter((line, index) => line || index !== relativeMarkerLine)
+            .join("\n"),
+    };
+}
+function parseHeading(line, nextLine, index) {
+    const atx = /^ {0,3}(#{1,6})[ \t]+(.+?)(?:[ \t]+#+[ \t]*)?$/u.exec(line);
+    if (atx?.[1] && atx[2]) {
+        return {
+            level: atx[1].length,
+            line: index,
+            text: atx[2],
+        };
+    }
+    const setext = /^ {0,3}(=+|-+)[ \t]*$/u.exec(nextLine ?? "");
+    if (line.trim() && setext?.[1]) {
+        return {
+            level: setext[1].startsWith("=") ? 1 : 2,
+            line: index,
+            text: line.trim(),
+        };
+    }
+    return null;
+}
+function normalizeHeading(value) {
+    let decoded = value.trim();
+    try {
+        decoded = decodeURIComponent(decoded);
+    }
+    catch {
+        // Keep malformed percent-encoded headings usable as literal text.
+    }
+    return decoded
+        .replace(/\[\[([^\]|]+)(?:\|([^\]]+))?\]\]/gu, (_, target, alias) => alias || target)
+        .replace(/\[([^\]]+)\]\([^)]+\)/gu, "$1")
+        .replace(/[*_~`]/gu, "")
+        .replace(/\s+/gu, " ")
+        .trim()
+        .toLocaleLowerCase();
+}
+function slugHeading(value) {
+    return normalizeHeading(value)
+        .replace(/[^\p{Letter}\p{Number}\s-]/gu, "")
+        .replace(/\s+/gu, "-")
+        .replace(/-+/gu, "-");
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}

package/dist/preview/embed-target.test.d.ts

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

package/dist/preview/embed-target.test.d.ts.map

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

package/dist/preview/embed-target.test.js

@@ -0,0 +1,78 @@
+import { describe, expect, it } from "vitest";
+import { parseMiraImageDetails, selectMarkdownEmbedFragment, } from "./embed-target";
+describe("portable embed targets", () => {
+    const markdown = [
+        "# Project",
+        "",
+        "Introduction.",
+        "",
+        "## Next Steps",
+        "",
+        "Ship the adapter.",
+        "",
+        "### Detail",
+        "",
+        "Keep this nested section.",
+        "",
+        "## Decisions",
+        "",
+        "Use target watchers.",
+        "",
+        "A portable referenced paragraph. ^decision-1",
+    ].join("\n");
+    it("selects heading sections through the next sibling heading", () => {
+        expect(selectMarkdownEmbedFragment(markdown, {
+            kind: "heading",
+            value: "Next Steps",
+        })).toEqual({
+            found: true,
+            markdown: [
+                "## Next Steps",
+                "",
+                "Ship the adapter.",
+                "",
+                "### Detail",
+                "",
+                "Keep this nested section.",
+                "",
+            ].join("\n"),
+        });
+    });
+    it("accepts heading slugs and selects block references without the marker", () => {
+        expect(selectMarkdownEmbedFragment(markdown, {
+            kind: "heading",
+            value: "next-steps",
+        }).found).toBe(true);
+        expect(selectMarkdownEmbedFragment(markdown, {
+            kind: "block",
+            value: "decision-1",
+        })).toEqual({
+            found: true,
+            markdown: "A portable referenced paragraph.",
+        });
+    });
+    it("reports missing fragments without falling back to the whole note", () => {
+        expect(selectMarkdownEmbedFragment(markdown, {
+            kind: "heading",
+            value: "Missing",
+        })).toEqual({ found: false, markdown: "" });
+    });
+});
+describe("image details", () => {
+    it("parses Lapis-style width and width-by-height suffixes", () => {
+        expect(parseMiraImageDetails("Diagram|640x360")).toEqual({
+            alt: "Diagram",
+            width: 640,
+            height: 360,
+        });
+        expect(parseMiraImageDetails("320", "diagram.png")).toEqual({
+            alt: "diagram.png",
+            width: 320,
+        });
+    });
+    it("preserves ordinary alt text", () => {
+        expect(parseMiraImageDetails("Architecture diagram")).toEqual({
+            alt: "Architecture diagram",
+        });
+    });
+});