phormat 0.0.5

package/dist/editor/plugins/links-images/parse-image-layout.d.ts

@@ -0,0 +1,28 @@
+export type ImageFloatAlign = 'left' | 'center' | 'right';
+export type ImageLayoutFields = {
+    displayWidth: number | 'full' | null;
+    floatAlign: ImageFloatAlign | null;
+};
+export type ParsedImageLabel = ImageLayoutFields & {
+    /** Alt text after suffix removal and outer trim. */
+    alt: string;
+    /** Index of `|` starting a valid format suffix in the raw label, or null. */
+    suffixPipeIndex: number | null;
+    /** True when a suffix-like tail after `|` was present but did not match grammar. */
+    malformedSuffix: boolean;
+};
+/** Split inline image bracket label into alt text and layout fields. */
+export declare function parseImageLabelLayout(label: string): ParsedImageLabel;
+/** Canonical `|suffix` for serialize from model fields. */
+export declare function serializeImageLayoutSuffix(displayWidth: number | 'full' | null | undefined, floatAlign: ImageFloatAlign | null | undefined): string;
+/** Map an index in the unescaped bracket label to a source offset inside `[…]`. */
+export declare function sourceOffsetInBracketLabel(source: string, labelStart: number, unescapedIndex: number): number;
+/** Exclusive source offset immediately after the closing `]` of a bracket label. */
+export declare function afterBracketLabelContent(source: string, labelStart: number): number | null;
+export type ImageLayoutCss = {
+    wrapperClass: string;
+    imgClass: string;
+    imgStyle: string | undefined;
+};
+/** Block-on-own-line layout classes for suffixed images (v1). */
+export declare function imageLayoutCss(displayWidth: number | 'full' | null | undefined, floatAlign: ImageFloatAlign | null | undefined): ImageLayoutCss;

package/dist/editor/plugins/links-images/parse-image-layout.js

@@ -0,0 +1,147 @@
+import { parseBracketedContent } from './parse-links-images';
+const WIDTH = '([1-9]\\d*)';
+const SUFFIX_RULES = [
+    {
+        re: new RegExp(`^\\|-1$`),
+        apply: () => ({ displayWidth: 'full', floatAlign: null })
+    },
+    {
+        re: new RegExp(`^\\|:${WIDTH}:$`),
+        apply: (m) => ({ displayWidth: Number(m[1]), floatAlign: 'center' })
+    },
+    {
+        re: new RegExp(`^\\|:${WIDTH}$`),
+        apply: (m) => ({ displayWidth: Number(m[1]), floatAlign: 'left' })
+    },
+    {
+        re: new RegExp(`^\\|${WIDTH}:$`),
+        apply: (m) => ({ displayWidth: Number(m[1]), floatAlign: 'right' })
+    },
+    {
+        re: new RegExp(`^\\|${WIDTH}$`),
+        apply: (m) => ({ displayWidth: Number(m[1]), floatAlign: null })
+    }
+];
+/** Heuristic: tail after last `|` looks like a failed format suffix attempt. */
+function looksLikeMalformedSuffixTail(tail) {
+    const t = tail.trim();
+    if (!t)
+        return false;
+    if (/^-1$/.test(t))
+        return true;
+    if (/^:?-?\d+:?$/u.test(t))
+        return true;
+    if (/^\d/u.test(t))
+        return true;
+    return false;
+}
+function trySuffixAt(label, pipeIndex) {
+    const suffix = label.slice(pipeIndex);
+    for (const rule of SUFFIX_RULES) {
+        const m = suffix.match(rule.re);
+        if (m)
+            return rule.apply(m);
+    }
+    return null;
+}
+/** Split inline image bracket label into alt text and layout fields. */
+export function parseImageLabelLayout(label) {
+    const lastPipe = label.lastIndexOf('|');
+    if (lastPipe === -1) {
+        return {
+            alt: label.trim(),
+            displayWidth: null,
+            floatAlign: null,
+            suffixPipeIndex: null,
+            malformedSuffix: false
+        };
+    }
+    for (let pipeIndex = lastPipe; pipeIndex >= 0; pipeIndex = label.lastIndexOf('|', pipeIndex - 1)) {
+        const layout = trySuffixAt(label, pipeIndex);
+        if (layout) {
+            return {
+                alt: label.slice(0, pipeIndex).trim(),
+                ...layout,
+                suffixPipeIndex: pipeIndex,
+                malformedSuffix: false
+            };
+        }
+    }
+    const malformedSuffix = looksLikeMalformedSuffixTail(label.slice(lastPipe + 1));
+    return {
+        alt: label.trim(),
+        displayWidth: null,
+        floatAlign: null,
+        suffixPipeIndex: null,
+        malformedSuffix
+    };
+}
+/** Canonical `|suffix` for serialize from model fields. */
+export function serializeImageLayoutSuffix(displayWidth, floatAlign) {
+    if (displayWidth === 'full')
+        return '|-1';
+    if (displayWidth == null || displayWidth <= 0)
+        return '';
+    if (floatAlign === 'left')
+        return `|:${displayWidth}`;
+    if (floatAlign === 'right')
+        return `|${displayWidth}:`;
+    if (floatAlign === 'center')
+        return `|:${displayWidth}:`;
+    return `|${displayWidth}`;
+}
+/** Map an index in the unescaped bracket label to a source offset inside `[…]`. */
+export function sourceOffsetInBracketLabel(source, labelStart, unescapedIndex) {
+    let u = 0;
+    let i = labelStart;
+    while (u < unescapedIndex && i < source.length) {
+        if (source[i] === '\\' && i + 1 < source.length) {
+            i += 2;
+            u++;
+            continue;
+        }
+        if (source[i] === ']')
+            break;
+        i++;
+        u++;
+    }
+    return i;
+}
+/** Exclusive source offset immediately after the closing `]` of a bracket label. */
+export function afterBracketLabelContent(source, labelStart) {
+    const parsed = parseBracketedContent(source, labelStart);
+    return parsed?.end ?? null;
+}
+/** Block-on-own-line layout classes for suffixed images (v1). */
+export function imageLayoutCss(displayWidth, floatAlign) {
+    const hasLayout = displayWidth != null;
+    if (!hasLayout) {
+        return {
+            wrapperClass: 'inline-block max-w-full align-middle',
+            imgClass: 'max-h-48 max-w-full rounded-xs object-contain',
+            imgStyle: undefined
+        };
+    }
+    const wrapperClass = 'block max-w-full';
+    let widthStyle;
+    if (displayWidth === 'full') {
+        widthStyle = 'width:100%';
+    }
+    else {
+        widthStyle = `width:${displayWidth}px`;
+    }
+    let marginStyle = '';
+    if (displayWidth !== 'full' && floatAlign === 'left')
+        marginStyle = 'margin-right:auto';
+    else if (displayWidth !== 'full' && floatAlign === 'right')
+        marginStyle = 'margin-left:auto';
+    else if (displayWidth !== 'full' && floatAlign === 'center') {
+        marginStyle = 'margin-left:auto;margin-right:auto';
+    }
+    const imgStyle = [widthStyle, marginStyle].filter(Boolean).join(';') || undefined;
+    return {
+        wrapperClass,
+        imgClass: 'max-w-full rounded-xs object-contain',
+        imgStyle
+    };
+}

package/dist/editor/plugins/links-images/parse-links-images.d.ts

@@ -0,0 +1,25 @@
+import type { LinkImageBlock } from './types';
+export type LinkRefDefinition = {
+    url: string;
+    title?: string;
+};
+/** Minimal reference label normalization (trim, lowercase ASCII, collapse whitespace). */
+export declare function normalizeLinkLabel(label: string): string;
+/** Allow relative paths, fragments, http(s), and mailto; block obvious dangerous schemes. */
+export declare function safeHref(href: string): string | null;
+type ExcludedRange = {
+    start: number;
+    end: number;
+};
+export declare function collectDefinitionsAndExcluded(source: string): {
+    defs: Map<string, LinkRefDefinition>;
+    excluded: ExcludedRange[];
+};
+/** Parse bracketed inline content until unescaped `]`; `start` is index of first char inside brackets. */
+export declare function parseBracketedContent(s: string, start: number): {
+    content: string;
+    end: number;
+} | null;
+export declare function tryParseLinkImageAt(s: string, i: number, defs: Map<string, LinkRefDefinition>, excluded: ExcludedRange[]): LinkImageBlock | null;
+export declare function parseLinksImages(source: string): LinkImageBlock[];
+export {};

package/dist/editor/plugins/links-images/parse-links-images.js

@@ -0,0 +1,236 @@
+/** Minimal reference label normalization (trim, lowercase ASCII, collapse whitespace). */
+export function normalizeLinkLabel(label) {
+    return label.trim().toLowerCase().replace(/\s+/g, ' ');
+}
+/** Allow relative paths, fragments, http(s), and mailto; block obvious dangerous schemes. */
+export function safeHref(href) {
+    const t = href.trim();
+    if (!t)
+        return null;
+    const lower = t.toLowerCase();
+    if (lower.startsWith('javascript:') ||
+        lower.startsWith('data:') ||
+        lower.startsWith('vbscript:')) {
+        return null;
+    }
+    if (t.startsWith('//'))
+        return null;
+    try {
+        if (!/^[a-zA-Z][a-zA-Z0-9+.-]*:/u.test(t)) {
+            return t;
+        }
+        const u = new URL(t);
+        if (u.protocol === 'http:' || u.protocol === 'https:' || u.protocol === 'mailto:') {
+            return t;
+        }
+        return null;
+    }
+    catch {
+        return !/^[a-zA-Z][a-zA-Z0-9+.-]*:/u.test(t) ? t : null;
+    }
+}
+const LINK_DEF_LINE = /^(\s{0,3})\[([^\]\r\n]+)\]:\s*(?:<([^>\s]+)>|(\S+))(?:\s+(?:"([^"]*)"|'([^']*)'|\(([^)]*)\)))?\s*$/;
+export function collectDefinitionsAndExcluded(source) {
+    const defs = new Map();
+    const excluded = [];
+    let pos = 0;
+    while (pos < source.length) {
+        const nl = source.indexOf('\n', pos);
+        const rawEnd = nl === -1 ? source.length : nl;
+        const line = source.slice(pos, rawEnd).replace(/\r$/, '');
+        const lineStart = pos;
+        const lineEnd = nl === -1 ? source.length : nl + 1;
+        const m = line.match(LINK_DEF_LINE);
+        if (m) {
+            const label = normalizeLinkLabel(m[2]);
+            const url = (m[3] ?? m[4] ?? '').trim();
+            const titleRaw = m[5] ?? m[6] ?? m[7];
+            const title = titleRaw !== undefined ? titleRaw.trim() : undefined;
+            if (label && url) {
+                defs.set(label, title ? { url, title } : { url });
+            }
+            excluded.push({ start: lineStart, end: lineEnd });
+        }
+        pos = lineEnd;
+    }
+    return { defs, excluded };
+}
+function inExcluded(i, excluded) {
+    return excluded.some((r) => i >= r.start && i < r.end);
+}
+/** Parse bracketed inline content until unescaped `]`; `start` is index of first char inside brackets. */
+export function parseBracketedContent(s, start) {
+    let i = start;
+    let out = '';
+    while (i < s.length) {
+        const c = s[i];
+        if (c === '\\' && i + 1 < s.length) {
+            out += s[i + 1];
+            i += 2;
+            continue;
+        }
+        if (c === ']') {
+            return { content: out, end: i + 1 };
+        }
+        out += c;
+        i++;
+    }
+    return null;
+}
+function skipAsciiWhitespace(s, i) {
+    let j = i;
+    while (j < s.length && (s[j] === ' ' || s[j] === '\t' || s[j] === '\n' || s[j] === '\r')) {
+        j++;
+    }
+    return j;
+}
+function parseInlineDestination(s, openParen) {
+    let i = openParen + 1;
+    const n = s.length;
+    i = skipAsciiWhitespace(s, i);
+    if (i >= n)
+        return null;
+    let href = '';
+    if (s[i] === '<') {
+        i++;
+        while (i < n && s[i] !== '>') {
+            href += s[i];
+            i++;
+        }
+        if (i >= n || s[i] !== '>')
+            return null;
+        i++;
+    }
+    else {
+        while (i < n && !/\s/.test(s[i]) && s[i] !== ')') {
+            href += s[i];
+            i++;
+        }
+    }
+    href = href.trim();
+    i = skipAsciiWhitespace(s, i);
+    let title;
+    if (i < n && (s[i] === '"' || s[i] === "'")) {
+        const q = s[i];
+        i++;
+        let t = '';
+        while (i < n && s[i] !== q) {
+            if (s[i] === '\\' && i + 1 < n) {
+                t += s[i + 1];
+                i += 2;
+                continue;
+            }
+            t += s[i];
+            i++;
+        }
+        if (i >= n || s[i] !== q)
+            return null;
+        i++;
+        title = t;
+    }
+    else if (i < n && s[i] === '(') {
+        i++;
+        let t = '';
+        let depth = 1;
+        while (i < n && depth > 0) {
+            const c = s[i];
+            if (c === '(')
+                depth++;
+            else if (c === ')')
+                depth--;
+            if (depth > 0)
+                t += c;
+            i++;
+        }
+        title = t;
+    }
+    i = skipAsciiWhitespace(s, i);
+    if (i >= n || s[i] !== ')')
+        return null;
+    return { href, title, end: i + 1 };
+}
+export function tryParseLinkImageAt(s, i, defs, excluded) {
+    if (inExcluded(i, excluded))
+        return null;
+    const image = s[i] === '!' && s[i + 1] === '[';
+    const bracketOpen = image ? i + 1 : i;
+    if (s[bracketOpen] !== '[')
+        return null;
+    const labelStart = bracketOpen + 1;
+    const labelParsed = parseBracketedContent(s, labelStart);
+    if (!labelParsed)
+        return null;
+    const { content: label, end: afterFirstBracket } = labelParsed;
+    const spanStart = image ? i : bracketOpen;
+    if (label.includes('\n') || label.includes('\r'))
+        return null;
+    const k = skipAsciiWhitespace(s, afterFirstBracket);
+    if (s[k] === '(') {
+        const dest = parseInlineDestination(s, k);
+        if (!dest)
+            return null;
+        const hrefRaw = safeHref(dest.href);
+        return {
+            kind: image ? 'image' : 'link',
+            label,
+            href: hrefRaw,
+            title: dest.title ?? null,
+            start: spanStart,
+            end: dest.end
+        };
+    }
+    if (s[k] === '[') {
+        const second = parseBracketedContent(s, k + 1);
+        if (!second)
+            return null;
+        const refKeyRaw = second.content.trim();
+        const refKey = refKeyRaw ? normalizeLinkLabel(refKeyRaw) : normalizeLinkLabel(label);
+        const def = defs.get(refKey);
+        if (!def)
+            return null;
+        const hrefRaw = safeHref(def.url);
+        return {
+            kind: image ? 'image' : 'link',
+            label,
+            href: hrefRaw,
+            title: def.title ?? null,
+            start: spanStart,
+            end: second.end
+        };
+    }
+    const shortcutKey = normalizeLinkLabel(label);
+    const def = defs.get(shortcutKey);
+    if (!def)
+        return null;
+    const hrefRaw = safeHref(def.url);
+    return {
+        kind: image ? 'image' : 'link',
+        label,
+        href: hrefRaw,
+        title: def.title ?? null,
+        start: spanStart,
+        end: afterFirstBracket
+    };
+}
+export function parseLinksImages(source) {
+    const { defs, excluded } = collectDefinitionsAndExcluded(source);
+    const out = [];
+    let i = 0;
+    while (i < source.length) {
+        if (inExcluded(i, excluded)) {
+            i++;
+            continue;
+        }
+        if (source[i] === '[' || (source[i] === '!' && source[i + 1] === '[')) {
+            const block = tryParseLinkImageAt(source, i, defs, excluded);
+            if (block) {
+                out.push(block);
+                i = block.end;
+                continue;
+            }
+        }
+        i++;
+    }
+    out.sort((a, b) => a.start - b.start || a.end - b.end);
+    return out;
+}

package/dist/editor/plugins/links-images/resolve-asset-url.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Resolves a relative asset URL against a base for DOM loading (e.g. Tauri `asset://` dirs).
+ * Markdown source keeps relative paths; preview uses the resolved absolute URL.
+ */
+export declare function resolveAssetUrlForDom(src: string, base: string): string;

package/dist/editor/plugins/links-images/resolve-asset-url.js

@@ -0,0 +1,21 @@
+/**
+ * Resolves a relative asset URL against a base for DOM loading (e.g. Tauri `asset://` dirs).
+ * Markdown source keeps relative paths; preview uses the resolved absolute URL.
+ */
+export function resolveAssetUrlForDom(src, base) {
+    const t = src.trim();
+    if (!t)
+        return t;
+    const b = base.trim();
+    if (!b)
+        return t;
+    if (/^(?:[a-z][a-z0-9+.-]*:|\/\/)/i.test(t))
+        return t;
+    try {
+        const baseForUrl = b.endsWith('/') ? b : `${b}/`;
+        return new URL(t, baseForUrl).href;
+    }
+    catch {
+        return t;
+    }
+}

package/dist/editor/plugins/links-images/types.d.ts

@@ -0,0 +1,11 @@
+export type LinkImageBlock = {
+    kind: 'link' | 'image';
+    /** Link text or image alt (unescaped). */
+    label: string;
+    href: string | null;
+    title?: string | null;
+    /** Inclusive start offset in source. */
+    start: number;
+    /** Exclusive end offset in source. */
+    end: number;
+};

package/dist/editor/plugins/links-images/types.js

@@ -0,0 +1 @@
+export {};

package/dist/editor/plugins/mention/MentionRenderer.svelte

@@ -0,0 +1,18 @@
+<script module lang="ts">
+	import type { MentionBlock } from './types';
+
+	export { mentionRenderer };
+</script>
+
+{#snippet mentionRenderer(block: MentionBlock)}
+	<p class="mb-4 text-sm text-option-cyan/95">
+		<span class="font-medium text-option-cyan">Mention</span>
+		{#if block.kind === 'page'}
+			<span class="text-txt-secondary"> page </span>
+			<code class="font-mono text-txt-primary">{block.pageTitle}</code>
+		{:else}
+			<span class="text-txt-secondary"> @</span>
+			<code class="font-mono text-txt-primary">{block.name}</code>
+		{/if}
+	</p>
+{/snippet}

package/dist/editor/plugins/mention/MentionRenderer.svelte.d.ts

@@ -0,0 +1,21 @@
+import type { MentionBlock } from './types';
+declare const mentionRenderer: (block: MentionBlock) => ReturnType<import("svelte").Snippet>;
+export { mentionRenderer };
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const MentionRenderer: $$__sveltets_2_IsomorphicComponent<Record<string, never>, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type MentionRenderer = InstanceType<typeof MentionRenderer>;
+export default MentionRenderer;

package/dist/editor/plugins/mention/index.d.ts

@@ -0,0 +1,2 @@
+import type { BlockRenderAdapter } from '../types';
+export declare const mentionPlugin: BlockRenderAdapter;

package/dist/editor/plugins/mention/index.js

@@ -0,0 +1,4 @@
+export const mentionPlugin = {
+    id: 'mention',
+    name: 'Mentions'
+};

package/dist/editor/plugins/mention/parse-mentions.d.ts

@@ -0,0 +1,2 @@
+import type { MentionBlock } from './types';
+export declare function parseMentions(source: string): MentionBlock[];

package/dist/editor/plugins/mention/parse-mentions.js

@@ -0,0 +1,54 @@
+/** Avoid matching the `@` inside `user@host`. */
+function atIsMentionPrefix(source, index) {
+    if (index === 0)
+        return true;
+    const prev = source[index - 1];
+    return !/[A-Za-z0-9_]/.test(prev);
+}
+const NAME_TAIL = /^[A-Za-z0-9_]+/;
+export function parseMentions(source) {
+    const out = [];
+    let i = 0;
+    while (i < source.length) {
+        if (source[i] !== '@') {
+            i++;
+            continue;
+        }
+        if (!atIsMentionPrefix(source, i)) {
+            i++;
+            continue;
+        }
+        if (source[i + 1] === '[') {
+            const close = source.indexOf(']', i + 2);
+            if (close === -1) {
+                i++;
+                continue;
+            }
+            const pageTitle = source.slice(i + 2, close).trim();
+            if (pageTitle.length > 0) {
+                out.push({
+                    kind: 'page',
+                    pageTitle,
+                    raw: source.slice(i, close + 1),
+                    startIndex: i
+                });
+            }
+            i = close + 1;
+            continue;
+        }
+        const tail = source.slice(i + 1).match(NAME_TAIL);
+        if (!tail) {
+            i++;
+            continue;
+        }
+        const name = tail[0];
+        out.push({
+            kind: 'user',
+            name,
+            raw: `@${name}`,
+            startIndex: i
+        });
+        i += 1 + name.length;
+    }
+    return out;
+}

package/dist/editor/plugins/mention/types.d.ts

@@ -0,0 +1,14 @@
+export type MentionBlock = {
+    kind: 'page';
+    /** Inner title between `@[` and `]`. */
+    pageTitle: string;
+    /** Full slice including `@`, `[`, `]`. */
+    raw: string;
+    startIndex: number;
+} | {
+    kind: 'user';
+    name: string;
+    /** Full slice including `@`. */
+    raw: string;
+    startIndex: number;
+};

package/dist/editor/plugins/mention/types.js

@@ -0,0 +1 @@
+export {};

package/dist/editor/plugins/raw-text/RawTextRenderer.svelte

@@ -0,0 +1,19 @@
+<script module lang="ts">
+	export { rawTextRenderer };
+</script>
+
+<script lang="ts">
+	import type { RawTextBlock } from './types';
+</script>
+
+{#snippet rawTextRenderer(block: RawTextBlock)}
+	<section class="mb-4 text-txt-primary">
+		{#if block.fileName}
+			<p class="mb-2 text-xs font-medium tracking-wide text-txt-tertiary uppercase">
+				{block.fileName}
+			</p>
+		{/if}
+
+		<pre class="font-mono text-sm leading-6 break-words whitespace-pre-wrap">{block.text}</pre>
+	</section>
+{/snippet}

package/dist/editor/plugins/raw-text/RawTextRenderer.svelte.d.ts

@@ -0,0 +1,21 @@
+export { rawTextRenderer };
+import type { RawTextBlock } from './types';
+declare const rawTextRenderer: (block: RawTextBlock) => ReturnType<import("svelte").Snippet>;
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const RawTextRenderer: $$__sveltets_2_IsomorphicComponent<Record<string, never>, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type RawTextRenderer = InstanceType<typeof RawTextRenderer>;
+export default RawTextRenderer;

package/dist/editor/plugins/raw-text/index.d.ts

@@ -0,0 +1,2 @@
+import type { BlockRenderAdapter } from '../types';
+export declare const rawTextPlugin: BlockRenderAdapter;

package/dist/editor/plugins/raw-text/index.js

@@ -0,0 +1,4 @@
+export const rawTextPlugin = {
+    id: 'raw-text',
+    name: 'Raw text'
+};

package/dist/editor/plugins/raw-text/types.d.ts

@@ -0,0 +1,4 @@
+export type RawTextBlock = {
+    text: string;
+    fileName: string | null;
+};

package/dist/editor/plugins/raw-text/types.js

@@ -0,0 +1 @@
+export {};