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

package/dist/markdown/detect.js

@@ -0,0 +1,81 @@
+const LIMIT = 200_000;
+const LINE_LIMIT = 2_000;
+const isList = (line) => /^ {0,6}(?:[-*+]|\d{1,9}[.)])[ \t]+\S/.test(line.slice(0, 64));
+const isRow = (line) => line.includes("|") && /^[\s|:-]+$/.test(line) && line.includes("-");
+function pair(text, mark) {
+    let from = 0;
+    for (let tries = 0; tries < 50; tries++) {
+        const a = text.indexOf(mark, from);
+        if (a === -1)
+            return false;
+        const inner = a + mark.length;
+        if (!/\s/.test(text.charAt(inner)) && inner < text.length) {
+            const b = text.indexOf(mark, inner + 1);
+            if (b !== -1 && !/\s/.test(text.charAt(b - 1)) && text.slice(inner, b).indexOf("\n\n") === -1)
+                return true;
+        }
+        from = a + mark.length;
+    }
+    return false;
+}
+function link(text) {
+    let from = 0;
+    for (let tries = 0; tries < 50; tries++) {
+        const mid = text.indexOf("](", from);
+        if (mid === -1)
+            return false;
+        const open = text.lastIndexOf("[", mid);
+        const close = text.indexOf(")", mid);
+        const label = open === -1 ? "" : text.slice(open + 1, mid);
+        if (open !== -1 && close !== -1 && label !== "" && !label.includes("\n") && close - mid < 2000)
+            return true;
+        from = mid + 2;
+    }
+    return false;
+}
+export function looksLikeMarkdown(input) {
+    const text = input.length > LIMIT ? input.slice(0, LIMIT) : input;
+    const lines = text.split(/\r\n?|\n/);
+    let headings = 0, listLines = 0, tasks = 0, quotes = 0, notes = 0;
+    let fence = false, table = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].slice(0, LINE_LIMIT);
+        if (/^ {0,3}(?:`{3,}|~{3,})/.test(line))
+            fence = true;
+        else if (/^ {0,3}#{1,6}[ \t]+\S/.test(line))
+            headings++;
+        else if (/^ {0,3}>/.test(line))
+            quotes++;
+        else if (/^ {0,3}\[\^[^\]\s]{1,64}\]:[ \t]*\S/.test(line))
+            notes++;
+        else if (isList(line)) {
+            listLines++;
+            if (/^\s*(?:[-*+]|\d+[.)])[ \t]+\[[ xX]\][ \t]/.test(line))
+                tasks++;
+        }
+        else if (line.includes("|") && i + 1 < lines.length && isRow(lines[i + 1].slice(0, LINE_LIMIT)) && line.replace(/[\s|]/g, "") !== "")
+            table = true;
+    }
+    let score = 0;
+    if (fence)
+        score += 3;
+    if (table)
+        score += 3;
+    if (headings > 0)
+        score += headings > 1 ? 2 : 1;
+    if (listLines >= 2)
+        score += 2;
+    if (tasks > 0)
+        score += 2;
+    if (quotes > 0)
+        score += 1;
+    if (notes > 0)
+        score += 2;
+    if (link(text))
+        score += 2;
+    if (pair(text, "**") || pair(text, "~~"))
+        score += 2;
+    if (pair(text, "`"))
+        score += 1;
+    return score >= 2;
+}

package/dist/markdown/export.d.ts

@@ -0,0 +1,10 @@
+import type { Doc } from "../model.ts";
+/** The document as Markdown (CommonMark with the GitHub table, task item and strikethrough additions). */
+export declare function exportMarkdown(doc: Doc, options?: MarkdownExportOptions): string;
+export interface MarkdownExportOptions {
+    /**
+     * Write underline, superscript and subscript as `<u>`, `<sup>` and `<sub>`, and a line break in a table cell or heading as `<br>`. The
+     * reader here understands those tags, so they come back; other Markdown readers show them as HTML. Default false: those details are dropped.
+     */
+    readonly inlineHtml?: boolean;
+}

package/dist/markdown/export.js

@@ -0,0 +1,252 @@
+import { noteIds } from "../notes.js";
+const SPAN_ORDER = ["link", "bold", "italic", "strike"];
+const HTML_SPAN_ORDER = ["link", "bold", "italic", "underline", "strike", "sup", "sub"];
+const SPAN_MARK = {
+    bold: ["**", "**"], italic: ["*", "*"], strike: ["~~", "~~"], underline: ["<u>", "</u>"], sup: ["<sup>", "</sup>"], sub: ["<sub>", "</sub>"],
+};
+let inlineHtml = false;
+let labels = new Map();
+const spanMarks = (marks) => (inlineHtml ? HTML_SPAN_ORDER : SPAN_ORDER).flatMap((type) => marks.filter((m) => m.type === type));
+const sameSpan = (a, b) => a.type === b.type && (a.type !== "link" || (b.type === "link" && a.href === b.href));
+const hasSpan = (list, m) => list.some((x) => sameSpan(x, m));
+function destination(href) {
+    if (/[\s()<>\x00-\x1f]/.test(href))
+        return `<${href.replace(/</g, "%3C").replace(/>/g, "%3E").replace(/[\x00-\x1f]/g, (c) => encodeURIComponent(c)).replace(/\n/g, "%0A")}>`;
+    return href.replace(/\\/g, "\\\\");
+}
+function escapeText(text, inLink, table) {
+    let out = "";
+    for (let i = 0; i < text.length; i++) {
+        const c = text[i];
+        if (c === "\\" || c === "`" || c === "*" || c === "[" || c === "]" || c === "<" || c === "~")
+            out += `\\${c}`;
+        else if (c === "|" && table)
+            out += "\\|";
+        else if (c === "_") {
+            const intraword = /[\p{L}\p{N}]/u.test(text[i - 1] ?? "") && /[\p{L}\p{N}]/u.test(text[i + 1] ?? "");
+            out += intraword ? c : "\\_";
+        }
+        else if (c === "&" && /^&(?:#\d{1,7}|#[xX][0-9a-fA-F]{1,6}|[A-Za-z][A-Za-z0-9]{1,31});/.test(text.slice(i, i + 40)))
+            out += "\\&";
+        else
+            out += c;
+    }
+    if (!inLink)
+        out = out.replace(/\b(https?):\/\//gi, "$1\\://").replace(/\bwww\./gi, "www\\.");
+    return out;
+}
+function codeSpan(text) {
+    let longest = 0;
+    for (const run of text.match(/`+/g) ?? [])
+        longest = Math.max(longest, run.length);
+    const fence = "`".repeat(longest === 0 ? 1 : longest + 1);
+    const pad = text.startsWith("`") || text.endsWith("`") || (text.startsWith(" ") && text.endsWith(" ") && text.trim() !== "");
+    return pad ? `${fence} ${text} ${fence}` : `${fence}${text}${fence}`;
+}
+function inline(content, flat, table) {
+    const segments = [];
+    const runs = content.map((node) => (node.type === "text" ? { node, spans: spanMarks(node.marks), code: node.marks.some((m) => m.type === "code") } : { node, spans: [], code: false }));
+    runs.forEach((run, r) => {
+        const node = run.node;
+        if (node.type === "br") {
+            segments.push({ text: "", spans: [], code: false, br: true });
+            return;
+        }
+        if (node.type === "image") {
+            segments.push({ text: "", spans: [], code: false, image: node });
+            return;
+        }
+        if (node.type === "note") {
+            segments.push({ text: "", spans: [], code: false, raw: `[^${labels.get(node.id) ?? node.id}]` });
+            return;
+        }
+        const text = node.text;
+        if (run.code) {
+            segments.push({ text, spans: run.spans, code: true });
+            return;
+        }
+        const lead = /^\s*/.exec(text)?.[0] ?? "";
+        const trail = lead.length === text.length ? "" : /\s*$/.exec(text)?.[0] ?? "";
+        const core = text.slice(lead.length, text.length - trail.length);
+        const prev = runs[r - 1];
+        const next = runs[r + 1];
+        const shared = (other) => (other && other.node.type === "text" ? run.spans.filter((m) => hasSpan(other.spans, m)) : []);
+        if (lead)
+            segments.push({ text: lead, spans: shared(prev), code: false });
+        if (core)
+            segments.push({ text: core, spans: run.spans, code: false });
+        if (trail)
+            segments.push({ text: trail, spans: shared(next), code: false });
+    });
+    let out = "";
+    let active = [];
+    const open = (m) => { out += m.type === "link" ? "[" : SPAN_MARK[m.type][0]; };
+    const close = (m) => { out += m.type === "link" ? `](${destination(m.href)})` : SPAN_MARK[m.type][1]; };
+    const move = (target) => {
+        let keep = 0;
+        while (keep < active.length && keep < target.length && sameSpan(active[keep], target[keep]))
+            keep++;
+        for (let k = active.length - 1; k >= keep; k--)
+            close(active[k]);
+        for (let k = keep; k < target.length; k++)
+            open(target[k]);
+        active = [...target];
+    };
+    for (const seg of segments) {
+        if (seg.br) {
+            move([]);
+            out += flat ? (inlineHtml ? "<br>" : " ") : "\\\n";
+            continue;
+        }
+        if (seg.raw !== undefined) {
+            move([]);
+            out += seg.raw;
+            continue;
+        }
+        if (seg.image) {
+            move(seg.spans);
+            out += `![${escapeText(seg.image.alt ?? "", true, table)}](${destination(seg.image.src)})`;
+            continue;
+        }
+        move(seg.spans);
+        out += seg.code ? codeSpan(seg.text) : escapeText(seg.text, active.some((m) => m.type === "link"), table);
+    }
+    move([]);
+    return out;
+}
+function guardLines(text) {
+    return text.split("\n").map((line) => {
+        if (/^\s{4}/.test(line))
+            return line;
+        const numbered = /^(\d{1,9})([.)])(?=[ \t]|$)/.exec(line);
+        if (numbered)
+            return `${numbered[1]}\\${line.slice(numbered[1].length)}`;
+        if (/^(#{1,6}([ \t]|$)|>|[-+]([ \t]|$)|[-=]+[ \t]*$|~~~|---|___)/.test(line))
+            return `\\${line}`;
+        return line;
+    }).join("\n");
+}
+function alignOf(cell) {
+    const b = cell?.blocks[0];
+    return b?.type === "p" ? b.align : undefined;
+}
+function cellText(cell) {
+    const parts = [];
+    const walk = (blocks) => {
+        for (const b of blocks) {
+            if (b.type === "p" || b.type === "h")
+                parts.push(inline(b.content, true, true));
+            else if (b.type === "pre")
+                parts.push(codeSpan(b.text.replace(/\n/g, " ")));
+            else if (b.type === "quote")
+                walk(b.blocks);
+            else if (b.type === "ul" || b.type === "ol")
+                for (const item of b.items)
+                    parts.push(inline(item.content, true, true));
+        }
+    };
+    walk(cell.blocks);
+    return parts.filter((p) => p !== "").join(" ");
+}
+function table(t) {
+    const grid = [];
+    t.rows.forEach((row, r) => {
+        const line = (grid[r] ??= []);
+        let c = 0;
+        for (const cell of row) {
+            while (line[c] !== undefined)
+                c++;
+            for (let dr = 0; dr < Math.max(1, cell.rowspan); dr++) {
+                const target = (grid[r + dr] ??= []);
+                for (let dc = 0; dc < Math.max(1, cell.colspan); dc++)
+                    target[c + dc] = dr === 0 && dc === 0 ? cell : null;
+            }
+            c += Math.max(1, cell.colspan);
+        }
+    });
+    const width = Math.max(1, ...grid.map((row) => row.length));
+    const line = (row) => `| ${Array.from({ length: width }, (_, c) => { const cell = row[c]; return cell ? cellText(cell) : ""; }).join(" | ")} |`;
+    const head = grid[0] ?? [];
+    const delimiter = Array.from({ length: width }, (_, c) => {
+        const a = alignOf(head[c] ?? undefined) ?? alignOf(grid.find((row) => row[c])?.[c] ?? undefined);
+        return a === "center" ? ":---:" : a === "right" ? "---:" : a === "left" ? ":---" : "---";
+    });
+    return [line(head), `| ${delimiter.join(" | ")} |`, ...grid.slice(1).map(line)].join("\n");
+}
+const indentLines = (text, by, first) => text.split("\n").map((l, i) => (i === 0 ? first + l : l === "" ? "" : by + l)).join("\n");
+function list(l, flip) {
+    const notes = l.notes === true;
+    const start = l.type === "ol" ? Math.max(0, Math.min(l.start ?? 1, 999_999_999 - l.items.length)) : 0;
+    return l.items.map((item, i) => {
+        const mark = notes ? `[^${labels.get(item.id ?? "") ?? item.id}]:` : l.type === "ul" ? (flip ? "*" : "-") : `${start + i}${flip ? ")" : "."}`;
+        const task = notes || item.checked === undefined ? "" : item.checked ? "[x] " : "[ ] ";
+        const paragraphs = inlineSplit(item.content).map((p) => guardLines(p));
+        const body = [`${task}${paragraphs[0] ?? ""}`, ...paragraphs.slice(1)].join("\n\n");
+        let text = body;
+        let before;
+        let beforeFlip = false;
+        for (const child of item.children) {
+            const isList = child.type === "ul" || child.type === "ol";
+            const flipNext = isList && before !== undefined && before.type === child.type ? !beforeFlip : false;
+            const rendered = child.type === "ul" || child.type === "ol" ? list(child, flipNext) : render(child, false);
+            const gap = isList && (before === undefined || before.type === "ul" || before.type === "ol") ? "\n" : "\n\n";
+            text = text === "" && before === undefined ? rendered : `${text}${gap}${rendered}`;
+            before = child;
+            beforeFlip = flipNext;
+        }
+        return indentLines(text, " ".repeat(notes ? 4 : mark.length + 1), `${mark} `).replace(/^(\S+) (\n|$)/, "$1$2");
+    }).join(notes ? "\n\n" : "\n");
+}
+function inlineSplit(content) {
+    const parts = [[]];
+    for (const node of content) {
+        if (node.type === "br" && node.paragraph)
+            parts.push([]);
+        else
+            parts[parts.length - 1].push(node);
+    }
+    return parts.map((p) => inline(p, false, false));
+}
+function blocks(list_) {
+    const out = [];
+    let previous;
+    let flip = false;
+    for (const block of list_) {
+        flip = previous && (previous.type === "ul" || previous.type === "ol") && previous.type === block.type ? !flip : false;
+        const text = render(block, flip);
+        if (text !== "")
+            out.push(text);
+        previous = block;
+    }
+    return out.join("\n\n");
+}
+function render(block, flip) {
+    switch (block.type) {
+        case "p": return guardLines(inline(block.content, false, false));
+        case "h": return `${"#".repeat(block.level)} ${inline(block.content, true, false)}`.trimEnd();
+        case "ul":
+        case "ol": return list(block, flip);
+        case "dl": return block.entries.map((e) => guardLines(inline(e.content, false, false))).filter((t) => t !== "").join("\n\n");
+        case "table": return table(block);
+        case "quote": return blocks(block.blocks).split("\n").map((l) => (l === "" ? ">" : `> ${l}`)).join("\n") || ">";
+        case "pre": {
+            let longest = 0;
+            for (const run of block.text.match(/`+/g) ?? [])
+                longest = Math.max(longest, run.length);
+            const fence = "`".repeat(Math.max(3, longest + 1));
+            return block.text === "" ? `${fence}\n${fence}` : `${fence}\n${block.text}\n${fence}`;
+        }
+        case "hr": return "---";
+    }
+}
+export function exportMarkdown(doc, options = {}) {
+    inlineHtml = options.inlineHtml === true;
+    labels = new Map(noteIds(doc).map((id, i) => [id, String(i + 1)]));
+    try {
+        return blocks(doc.blocks);
+    }
+    finally {
+        inlineHtml = false;
+        labels = new Map();
+    }
+}

package/dist/markdown/index.d.ts

@@ -0,0 +1,5 @@
+export { parseMarkdown } from "./parse.ts";
+export { exportMarkdown, type MarkdownExportOptions } from "./export.ts";
+export { looksLikeMarkdown } from "./detect.ts";
+export { markdown, type MarkdownPasteOptions } from "./plugin.ts";
+export type { MarkdownOptions } from "./inline.ts";

package/dist/markdown/index.js

@@ -0,0 +1,4 @@
+export { parseMarkdown } from "./parse.js";
+export { exportMarkdown } from "./export.js";
+export { looksLikeMarkdown } from "./detect.js";
+export { markdown } from "./plugin.js";

package/dist/markdown/inline.d.ts

@@ -0,0 +1,35 @@
+import { type Inline, type ListItem } from "../model.ts";
+export interface MarkdownOptions {
+    /** URL schemes a link may use besides relative and fragment addresses. Default: http, https, mailto, tel. */
+    readonly linkSchemes?: readonly string[];
+    /** Cleans an SVG data address, or returns undefined to refuse it. Without it, SVG images are refused. */
+    readonly sanitizeSvg?: ((dataUrl: string) => string | undefined) | undefined;
+    /** Largest `data:` image address, in characters. */
+    readonly maxDataImageLength?: number;
+}
+/** Link reference definitions found in the document: `[label]: address "title"`. Keys come from `refLabel`. */
+export type Refs = ReadonlyMap<string, {
+    readonly dest: string;
+}>;
+/**
+ * The footnotes of the text being read. `keys` has a label (in `refLabel` form) for each definition found before reading begins;
+ * `use` gives the id for one more reference to a label (a label used twice gets two ids, as each reference has its own note).
+ */
+export interface NoteState {
+    readonly keys: ReadonlyMap<string, string>;
+    readonly items: Map<string, ListItem>;
+    /** Each id handed out, with the label it stands for, in the order the references were read. */
+    readonly used: Map<string, string>;
+    use(key: string): string | undefined;
+}
+/** What a footnote label may be: letters, digits, underscore, dot and dash. */
+export declare const NOTE_LABEL: RegExp;
+export interface InlineContext extends MarkdownOptions {
+    readonly refs?: Refs;
+    readonly notes?: NoteState | undefined;
+}
+/** The form of a reference label that is compared: case and runs of white space do not matter. */
+export declare const refLabel: (label: string) => string;
+export declare function parseInline(src: string, options?: InlineContext): Inline[];
+/** Backslash escapes and entities in an address or title. */
+export declare function unescape(raw: string): string;