@rathkit/rte-core 0.1.0-alpha.3 → 0.1.0-alpha.5

package/dist/markdown/parse.js

@@ -0,0 +1,586 @@
+import { NOTE_ID } from "../model.js";
+import { noteIds } from "../notes.js";
+import { asChildren } from "../path.js";
+import { NOTE_LABEL, parseInline, refLabel, unescape } from "./inline.js";
+const MAX_DEPTH = 24;
+const leading = (line) => {
+    let n = 0;
+    while (n < line.length && line.charCodeAt(n) === 32)
+        n++;
+    return n;
+};
+const isBlank = (line) => line.trim() === "";
+function expandTabs(line) {
+    if (!line.includes("\t"))
+        return line;
+    let col = 0, i = 0, out = "";
+    for (; i < line.length; i++) {
+        const c = line[i];
+        if (c === " ") {
+            out += c;
+            col++;
+        }
+        else if (c === "\t") {
+            const n = 4 - (col % 4);
+            out += " ".repeat(n);
+            col += n;
+        }
+        else
+            break;
+    }
+    return out + line.slice(i);
+}
+function isFence(line) {
+    const indent = leading(line);
+    if (indent > 3)
+        return undefined;
+    const ch = line[indent];
+    if (ch !== "`" && ch !== "~")
+        return undefined;
+    let len = 0;
+    while (line[indent + len] === ch)
+        len++;
+    if (len < 3)
+        return undefined;
+    const info = line.slice(indent + len);
+    if (ch === "`" && info.includes("`"))
+        return undefined;
+    return { ch, len, indent, info: info.trim() };
+}
+function isRule(line) {
+    const indent = leading(line);
+    if (indent > 3)
+        return false;
+    const ch = line[indent];
+    if (ch !== "*" && ch !== "-" && ch !== "_")
+        return false;
+    let count = 0;
+    for (let i = indent; i < line.length; i++) {
+        const c = line[i];
+        if (c === ch)
+            count++;
+        else if (c !== " " && c !== "\t")
+            return false;
+    }
+    return count >= 3;
+}
+function atx(line) {
+    const indent = leading(line);
+    if (indent > 3)
+        return undefined;
+    let level = 0;
+    while (line[indent + level] === "#")
+        level++;
+    if (level < 1 || level > 6)
+        return undefined;
+    const rest = line.slice(indent + level);
+    if (rest !== "" && rest[0] !== " " && rest[0] !== "\t")
+        return undefined;
+    let text = rest.trim();
+    let end = text.length;
+    while (end > 0 && text[end - 1] === "#")
+        end--;
+    if (end < text.length && (end === 0 || text[end - 1] === " " || text[end - 1] === "\t"))
+        text = text.slice(0, end).trimEnd();
+    return { level: level, text };
+}
+function marker(line) {
+    const indent = leading(line);
+    if (indent > 3)
+        return undefined;
+    let p = indent;
+    let type;
+    let char;
+    let number = 0;
+    const c = line[p];
+    if (c === "-" || c === "+" || c === "*") {
+        type = "ul";
+        char = c;
+        p++;
+    }
+    else {
+        let d = 0;
+        while (p < line.length && line.charCodeAt(p) >= 48 && line.charCodeAt(p) <= 57 && d < 10) {
+            number = number * 10 + (line.charCodeAt(p) - 48);
+            p++;
+            d++;
+        }
+        if (d === 0 || d > 9)
+            return undefined;
+        const delim = line[p];
+        if (delim !== "." && delim !== ")")
+            return undefined;
+        type = "ol";
+        char = delim;
+        p++;
+    }
+    const width = p - indent;
+    const after = line[p];
+    if (after !== undefined && after !== " " && after !== "\t")
+        return undefined;
+    const rest = line.slice(p);
+    const empty = rest.trim() === "";
+    const spaces = leading(rest);
+    const gap = empty || spaces > 4 ? 1 : spaces;
+    return { type, char, number, indent, width, contentIndent: indent + width + gap, empty };
+}
+function interrupts(line, next) {
+    if (atx(line) || isFence(line) || isRule(line))
+        return true;
+    if (leading(line) <= 3 && line.trimStart().startsWith(">"))
+        return true;
+    const m = marker(line);
+    if (m && !m.empty && (m.type === "ul" || m.number === 1))
+        return true;
+    return next !== undefined && tableAt(line, next) !== undefined;
+}
+function setextLevel(line) {
+    const indent = leading(line);
+    if (indent > 3)
+        return undefined;
+    const ch = line[indent];
+    if (ch !== "=" && ch !== "-")
+        return undefined;
+    let i = indent;
+    while (line[i] === ch)
+        i++;
+    if (line.slice(i).trim() !== "")
+        return undefined;
+    return ch === "=" ? 1 : 2;
+}
+function cellsOf(line) {
+    let text = line.trim();
+    if (text.startsWith("|"))
+        text = text.slice(1);
+    if (text.endsWith("|") && !text.endsWith("\\|"))
+        text = text.slice(0, -1);
+    const cells = [];
+    let cell = "";
+    for (let i = 0; i < text.length; i++) {
+        const c = text[i];
+        if (c === "\\" && text[i + 1] === "|") {
+            cell += "\\|";
+            i++;
+        }
+        else if (c === "|") {
+            cells.push(cell.trim());
+            cell = "";
+        }
+        else
+            cell += c;
+    }
+    cells.push(cell.trim());
+    return cells;
+}
+function alignOf(cell) {
+    const t = cell.trim();
+    if (t.length === 0)
+        return null;
+    const left = t.startsWith(":"), right = t.endsWith(":");
+    const dashes = t.slice(left ? 1 : 0, right ? -1 : undefined);
+    if (dashes === "" || /[^-]/.test(dashes))
+        return null;
+    return left && right ? "center" : right ? "right" : left ? "left" : undefined;
+}
+function tableAt(header, delimiter) {
+    if (!header.includes("|") || !delimiter.includes("-"))
+        return undefined;
+    const head = cellsOf(header);
+    const marks = cellsOf(delimiter);
+    if (head.length !== marks.length || head.length < 1)
+        return undefined;
+    const aligns = [];
+    for (const m of marks) {
+        const a = alignOf(m);
+        if (a === null)
+            return undefined;
+        aligns.push(a);
+    }
+    if (head.length === 1 && !header.trim().startsWith("|") && !header.trim().endsWith("|"))
+        return undefined;
+    return { head, aligns };
+}
+class FenceState {
+    open = null;
+    feed(line) {
+        const f = isFence(line);
+        if (this.open) {
+            if (f && f.ch === this.open.ch && f.len >= this.open.len && f.info === "")
+                this.open = null;
+        }
+        else if (f)
+            this.open = { ch: f.ch, len: f.len };
+    }
+}
+const continuesParagraph = (previous, fence) => previous !== undefined && fence.open === null && !isBlank(previous) && !atx(previous) && !isRule(previous) && !setextLevel(previous) && leading(previous) < 4;
+function refDef(line) {
+    const indent = leading(line);
+    if (indent > 3 || line[indent] !== "[")
+        return undefined;
+    let i = indent + 1;
+    const from = i;
+    while (i < line.length && line[i] !== "]" && line[i] !== "[" && i - from < 1000) {
+        if (line[i] === "\\")
+            i++;
+        i++;
+    }
+    if (line[i] !== "]" || line[i + 1] !== ":")
+        return undefined;
+    const label = line.slice(from, i);
+    if (label.trim() === "")
+        return undefined;
+    i += 2;
+    while (line[i] === " " || line[i] === "\t")
+        i++;
+    let dest;
+    if (line[i] === "<") {
+        const end = line.indexOf(">", i + 1);
+        if (end === -1 || /[\s<]/.test(line.slice(i + 1, end)))
+            return undefined;
+        dest = line.slice(i + 1, end);
+        i = end + 1;
+    }
+    else {
+        const start = i;
+        while (i < line.length && line[i] !== " " && line[i] !== "\t")
+            i++;
+        dest = line.slice(start, i);
+    }
+    if (dest === "")
+        return undefined;
+    while (line[i] === " " || line[i] === "\t")
+        i++;
+    if (i < line.length) {
+        const open = line[i];
+        const close = open === "(" ? ")" : open;
+        if ((open !== '"' && open !== "'" && open !== "(") || line[i - 1] === undefined || i === 0 || (line[i - 1] !== " " && line[i - 1] !== "\t"))
+            return undefined;
+        const end = line.lastIndexOf(close);
+        if (end <= i || line.slice(end + 1).trim() !== "")
+            return undefined;
+    }
+    return { label, dest: unescape(dest) };
+}
+function collectRefs(lines) {
+    const refs = new Map();
+    const keys = new Map();
+    const fence = new FenceState();
+    let inParagraph = false;
+    for (const raw of lines) {
+        let line = raw;
+        for (;;) {
+            const quoted = leading(line) <= 3 && line.trimStart().startsWith(">");
+            if (!quoted)
+                break;
+            line = line.trimStart().slice(1);
+            if (line.startsWith(" "))
+                line = line.slice(1);
+        }
+        fence.feed(line);
+        if (fence.open) {
+            inParagraph = false;
+            continue;
+        }
+        const note = inParagraph || quotedLine(raw) ? undefined : noteDef(line);
+        if (note) {
+            const key = refLabel(note.label);
+            if (!keys.has(key))
+                keys.set(key, noteIdFor(note.label, keys));
+            inParagraph = false;
+            continue;
+        }
+        const def = inParagraph ? undefined : refDef(line);
+        if (def) {
+            const key = refLabel(def.label);
+            if (!refs.has(key))
+                refs.set(key, { dest: def.dest });
+        }
+        inParagraph = !def && continuesParagraph(line, fence);
+    }
+    return { refs, keys };
+}
+const quotedLine = (line) => leading(line) <= 3 && line.trimStart().startsWith(">");
+function noteDef(line) {
+    const m = /^ {0,3}\[\^([^\]\s[]{1,64})\]:[ \t]*(.*)$/.exec(line);
+    return m && NOTE_LABEL.test(m[1]) ? { label: m[1], rest: m[2] } : undefined;
+}
+function noteIdFor(label, taken) {
+    const base = label.replace(/[^\w-]/g, "").slice(0, 32);
+    const used = new Set(taken.values());
+    for (let n = 0;; n++) {
+        const id = base !== "" && n === 0 ? base : `n${taken.size + n + 1}`;
+        if (NOTE_ID.test(id) && !used.has(id))
+            return id;
+    }
+}
+function paragraph(text, options, align) {
+    const content = parseInline(text.trim(), options);
+    if (content.length === 0)
+        return undefined;
+    return { type: "p", content, ...(align ? { align } : {}) };
+}
+function listItem(lines, depth, options) {
+    let checked;
+    const first = lines[0] ?? "";
+    const task = /^\[([ xX])\](?:[ \t]|$)/.exec(first);
+    if (task) {
+        checked = task[1] !== " ";
+        lines = [first.slice(task[0].length), ...lines.slice(1)];
+    }
+    return { ...itemOf(parseBlocks(lines, depth + 1, options)), ...(checked !== undefined ? { checked } : {}) };
+}
+function itemOf(blocks) {
+    let content = [];
+    const children = [];
+    let leading = true;
+    blocks.forEach((b, i) => {
+        if (leading && b.type === "p" && (i === 0 || content.length > 0)) {
+            content = i === 0 ? [...b.content] : [...content, { type: "br", paragraph: true }, ...b.content];
+            return;
+        }
+        leading = false;
+        children.push(...asChildren([b]));
+    });
+    return { content, children };
+}
+function parseList(lines, start, depth, options) {
+    const first = marker(lines[start]);
+    const items = [];
+    let i = start;
+    while (i < lines.length) {
+        const m = marker(lines[i]);
+        if (!m || m.type !== first.type || m.char !== first.char)
+            break;
+        if (isRule(lines[i]))
+            break;
+        const body = [lines[i].slice(m.contentIndent < lines[i].length ? m.contentIndent : lines[i].length)];
+        if (m.empty)
+            body[0] = "";
+        i++;
+        let blanks = 0;
+        const fenced = new FenceState();
+        fenced.feed(body[0] ?? "");
+        while (i < lines.length) {
+            const line = lines[i];
+            if (isBlank(line)) {
+                blanks++;
+                i++;
+                continue;
+            }
+            const ind = leading(line);
+            if (ind >= m.contentIndent) {
+                for (let b = 0; b < blanks; b++)
+                    body.push("");
+                blanks = 0;
+                body.push(line.slice(m.contentIndent));
+                fenced.feed(line.slice(m.contentIndent));
+                i++;
+                continue;
+            }
+            if (blanks === 0 && !marker(line) && !interrupts(line, lines[i + 1]) && continuesParagraph(body[body.length - 1], fenced)) {
+                body.push(line.trimStart());
+                i++;
+                continue;
+            }
+            break;
+        }
+        items.push(listItem(body, depth, options));
+        const nextMarker = i < lines.length ? marker(lines[i]) : undefined;
+        if (!nextMarker || nextMarker.type !== first.type || nextMarker.char !== first.char)
+            break;
+    }
+    const list = { type: first.type, items, ...(first.type === "ol" && first.number !== 1 ? { start: first.number } : {}) };
+    return { list, next: i };
+}
+function parseBlocks(lines, depth, options) {
+    const out = [];
+    if (depth >= MAX_DEPTH) {
+        const p = paragraph(lines.join("\n"), options);
+        return p ? [p] : [];
+    }
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        if (isBlank(line)) {
+            i++;
+            continue;
+        }
+        const fence = isFence(line);
+        if (fence) {
+            const body = [];
+            i++;
+            while (i < lines.length) {
+                const l = lines[i];
+                const close = isFence(l);
+                if (close && close.ch === fence.ch && close.len >= fence.len && close.info === "") {
+                    i++;
+                    break;
+                }
+                body.push(l.slice(Math.min(leading(l), fence.indent)));
+                i++;
+            }
+            out.push({ type: "pre", text: body.join("\n") });
+            continue;
+        }
+        const heading = atx(line);
+        if (heading) {
+            const content = parseInline(heading.text, options);
+            out.push({ type: "h", level: heading.level, content });
+            i++;
+            continue;
+        }
+        if (isRule(line)) {
+            out.push({ type: "hr" });
+            i++;
+            continue;
+        }
+        if (leading(line) <= 3 && line.trimStart().startsWith(">")) {
+            const inner = [];
+            const fenced = new FenceState();
+            while (i < lines.length) {
+                const l = lines[i];
+                if (leading(l) <= 3 && l.trimStart().startsWith(">")) {
+                    const t = l.trimStart().slice(1);
+                    const content = t.startsWith(" ") ? t.slice(1) : t;
+                    inner.push(content);
+                    fenced.feed(content);
+                    i++;
+                }
+                else if (!isBlank(l) && !interrupts(l, lines[i + 1]) && continuesParagraph(inner[inner.length - 1], fenced)) {
+                    inner.push(l.trimStart());
+                    i++;
+                }
+                else
+                    break;
+            }
+            const quoted = parseBlocks(inner, depth + 1, options);
+            if (quoted.length > 0)
+                out.push({ type: "quote", blocks: quoted });
+            continue;
+        }
+        const m = marker(line);
+        if (m) {
+            const { list, next } = parseList(lines, i, depth, options);
+            out.push(list);
+            i = next;
+            continue;
+        }
+        const table = i + 1 < lines.length ? tableAt(line, lines[i + 1]) : undefined;
+        if (table) {
+            const cell = (text, header, col) => {
+                const p = paragraph(text, options, table.aligns[col]);
+                return { header, colspan: 1, rowspan: 1, blocks: p ? [p] : [{ type: "p", content: [] }] };
+            };
+            const rows = [table.head.map((t, c) => cell(t, true, c))];
+            i += 2;
+            while (i < lines.length && !isBlank(lines[i]) && !interrupts(lines[i], undefined)) {
+                const cells = cellsOf(lines[i]);
+                rows.push(table.head.map((_, c) => cell(cells[c] ?? "", false, c)));
+                i++;
+            }
+            out.push({ type: "table", rows });
+            continue;
+        }
+        const note = options.notes ? noteDef(line) : undefined;
+        const key = note ? refLabel(note.label) : "";
+        if (note && options.notes?.keys.has(key)) {
+            const body = [note.rest];
+            const fenced = new FenceState();
+            fenced.feed(note.rest);
+            i++;
+            while (i < lines.length) {
+                const l = lines[i];
+                if (isBlank(l)) {
+                    let j = i;
+                    while (j < lines.length && isBlank(lines[j]))
+                        j++;
+                    if (j >= lines.length || leading(lines[j]) < 4)
+                        break;
+                    for (; i < j; i++)
+                        body.push("");
+                    continue;
+                }
+                if (leading(l) >= 4) {
+                    body.push(l.slice(4));
+                    fenced.feed(l.slice(4));
+                    i++;
+                    continue;
+                }
+                if (!noteDef(l) && !interrupts(l, lines[i + 1]) && continuesParagraph(body[body.length - 1], fenced)) {
+                    body.push(l.trimStart());
+                    i++;
+                    continue;
+                }
+                break;
+            }
+            if (!options.notes.items.has(key))
+                options.notes.items.set(key, itemOf(parseBlocks(body, depth + 1, { ...options, notes: undefined })));
+            continue;
+        }
+        if (leading(line) < 4 && refDef(line)) {
+            i++;
+            continue;
+        }
+        if (leading(line) >= 4) {
+            const body = [];
+            while (i < lines.length && (isBlank(lines[i]) || leading(lines[i]) >= 4)) {
+                body.push(lines[i].slice(Math.min(4, leading(lines[i]))));
+                i++;
+            }
+            while (body.length > 0 && isBlank(body[body.length - 1]))
+                body.pop();
+            out.push({ type: "pre", text: body.join("\n") });
+            continue;
+        }
+        const text = [line];
+        i++;
+        let level;
+        while (i < lines.length) {
+            const l = lines[i];
+            level = setextLevel(l);
+            if (level) {
+                i++;
+                break;
+            }
+            if (isBlank(l) || interrupts(l, lines[i + 1]))
+                break;
+            text.push(l);
+            i++;
+        }
+        if (level) {
+            out.push({ type: "h", level, content: parseInline(text.map((t) => t.trim()).join("\n"), options) });
+        }
+        else {
+            const p = paragraph(text.map((t) => t.trimStart()).join("\n"), options);
+            if (p)
+                out.push(p);
+        }
+    }
+    return out;
+}
+export function parseMarkdown(source, options = {}) {
+    const text = source.replace(/\r\n?|\u2028|\u2029/g, "\n").replace(/\0/g, "�");
+    const lines = text.split("\n").map(expandTabs);
+    const { refs, keys } = collectRefs(lines);
+    const used = new Map();
+    const items = new Map();
+    const count = new Map();
+    const notes = {
+        keys, items, used,
+        use(key) {
+            const base = keys.get(key);
+            if (base === undefined)
+                return undefined;
+            const n = (count.get(key) ?? 0) + 1;
+            count.set(key, n);
+            const id = n === 1 ? base : `${base.slice(0, 34)}-${n}`;
+            used.set(id, key);
+            return id;
+        },
+    };
+    const blocks = parseBlocks(lines, 0, { ...options, refs, notes: keys.size > 0 ? notes : undefined });
+    if (used.size === 0)
+        return blocks;
+    const order = noteIds({ blocks });
+    return [...blocks, { type: "ol", notes: true, items: order.map((id) => ({ ...(items.get(used.get(id)) ?? { content: [], children: [] }), id })) }];
+}

package/dist/markdown/plugin.d.ts

@@ -0,0 +1,20 @@
+import type { Plugin } from "../plugin.ts";
+export interface MarkdownPasteOptions {
+    /**
+     * `detect` (default): plain text that clearly looks like Markdown is read as Markdown; anything else pastes as typed.
+     * `always`: every plain-text paste is read as Markdown. `never`: the plugin does nothing.
+     */
+    readonly paste?: "detect" | "always" | "never";
+    /**
+     * What copy, cut and drag write besides the editor's HTML and plain text. `"markdown"` (default) adds the selection as
+     * `text/markdown`; `"plain"` also makes the plain text Markdown, for pasting into a text field; `"off"` adds nothing.
+     */
+    readonly copy?: "markdown" | "plain" | "off";
+    /** Write underline, superscript and subscript as inline HTML when copying (see `MarkdownExportOptions`). Default false. */
+    readonly inlineHtml?: boolean;
+    /** URL schemes a link may use besides relative and fragment addresses. Default: http, https, mailto, tel. */
+    readonly linkSchemes?: readonly string[];
+    /** Largest `data:` image address, in characters. */
+    readonly maxDataImageLength?: number;
+}
+export declare function markdown(options?: MarkdownPasteOptions): Plugin;

package/dist/markdown/plugin.js

@@ -0,0 +1,56 @@
+import { kindAt, getBlock } from "../path.js";
+import { exportMarkdown } from "./export.js";
+import { parseMarkdown } from "./parse.js";
+import { looksLikeMarkdown } from "./detect.js";
+export function markdown(options = {}) {
+    const mode = options.paste ?? "detect";
+    const copy = options.copy ?? "markdown";
+    return {
+        id: "rathkit.markdown",
+        api: "1",
+        setup(host) {
+            if (copy !== "off") {
+                host.copyFormat((blocks) => {
+                    const text = exportMarkdown({ blocks }, { inlineHtml: options.inlineHtml === true });
+                    return copy === "plain" ? { "text/markdown": text, "text/plain": text } : { "text/markdown": text };
+                });
+            }
+            host.command({
+                name: "markdown.copy", label: "Copy as Markdown", mutates: false,
+                run: (ctx) => {
+                    const clipboard = globalThis.navigator?.clipboard;
+                    if (!clipboard)
+                        return false;
+                    const { doc, selection } = ctx.snapshot;
+                    const blocks = host.ops.isCollapsed(selection) ? doc.blocks : host.ops.extractSelection(doc, selection);
+                    clipboard.writeText(exportMarkdown({ blocks }, { inlineHtml: options.inlineHtml === true })).catch((error) => host.editor.report({ code: "copy-failed", plugin: "rathkit.markdown", message: `Copy as Markdown failed: ${error instanceof Error ? error.message : String(error)}`, error }));
+                    return true;
+                },
+            });
+            if (mode === "never")
+                return;
+            host.pasteHandler((data) => {
+                if (data.html && data.html.trim() !== "")
+                    return undefined;
+                const text = data.text;
+                if (!text || text.trim() === "")
+                    return undefined;
+                const { doc, selection } = host.editor.snapshot;
+                const path = selection.focus.path;
+                if (kindAt(doc, path) === "pre" || getBlock(doc, path)?.type === "pre")
+                    return undefined;
+                if (text.length > (host.editor.importOptions.maxInputLength ?? Infinity))
+                    return undefined;
+                if (mode === "detect" && !looksLikeMarkdown(text))
+                    return undefined;
+                const blocks = parseMarkdown(text, {
+                    ...(options.linkSchemes ? { linkSchemes: options.linkSchemes } : {}),
+                    ...(options.maxDataImageLength !== undefined ? { maxDataImageLength: options.maxDataImageLength } : {}),
+                    sanitizeSvg: host.editor.importOptions.sanitizeSvg,
+                    relativeImages: host.editor.importOptions.pasteRelativeImages ?? false,
+                });
+                return blocks.length > 0 ? blocks : undefined;
+            });
+        },
+    };
+}