@cube-drone/marquee-parser 0.1.0

package/dist/blocks.js

@@ -0,0 +1,329 @@
+// Line-oriented block parser: a faithful port of rust/parser/src/blocks.rs.
+// Where this file and that file disagree, one of them has a conformance bug.
+import { isName, nameLen, parseAttrs, utf8Len } from "./attrs.js";
+import { parseInlines } from "./inlines.js";
+export const MAX_LIST_DEPTH = 16;
+export const MAX_QUOTE_DEPTH = 16;
+export const MAX_DIRECTIVE_DEPTH = 8;
+export const MAX_TARGET_BYTES = 4096;
+function peek(cur) {
+    return cur.lines[cur.pos];
+}
+export function parseBlocks(body) {
+    const lines = body.split("\n");
+    // A final newline terminates the last line rather than creating an empty
+    // one (otherwise every trailing newline leaks a blank into fences).
+    if (lines.length > 0 && lines[lines.length - 1] === "") {
+        lines.pop();
+    }
+    const cur = { lines, pos: 0 };
+    return parseContainer(cur, { dirDepth: 0, listDepth: 0, quoteDepth: 0 }, null);
+}
+/**
+ * Parse blocks until the container ends. `openDir` is the name of the
+ * directive whose body this is (null at document level and inside
+ * blockquotes / list items, which are fresh containers).
+ */
+function parseContainer(cur, ctx, openDir) {
+    const out = [];
+    for (;;) {
+        const line = peek(cur);
+        if (line === undefined) {
+            break;
+        }
+        if (isBlank(line)) {
+            cur.pos += 1;
+            continue;
+        }
+        // Directive open / close / error lines.
+        if (line.startsWith(":::")) {
+            cur.pos += 1;
+            const dir = classifyDirective(line);
+            if (dir.kind === "close") {
+                if (openDir !== null && dir.name === null) {
+                    return out;
+                }
+                if (openDir !== null && dir.name === openDir) {
+                    return out;
+                }
+                out.push(invalid(openDir !== null ? "mismatched_close" : "stray_close"));
+            }
+            else if (dir.kind === "open") {
+                if (ctx.dirDepth >= MAX_DIRECTIVE_DEPTH) {
+                    out.push(invalid("depth_exceeded"));
+                    continue;
+                }
+                const attrs = parseAttrs(dir.attrsSrc);
+                if (!attrs.ok) {
+                    out.push(invalid(attrs.reason));
+                }
+                else {
+                    const children = dir.leaf
+                        ? []
+                        : parseContainer(cur, { ...ctx, dirDepth: ctx.dirDepth + 1 }, dir.name);
+                    out.push({ type: "directive", name: dir.name, attrs: attrs.attrs, children });
+                }
+            }
+            else {
+                out.push(invalid(dir.reason));
+            }
+            continue;
+        }
+        // Comment block: consecutive `%%` lines, raw content.
+        if (line.startsWith("%%")) {
+            const texts = [];
+            for (let l = peek(cur); l !== undefined && l.startsWith("%%"); l = peek(cur)) {
+                const rest = l.slice(2);
+                texts.push(rest.startsWith(" ") ? rest.slice(1) : rest);
+                cur.pos += 1;
+            }
+            out.push({ type: "comment", text: texts.join("\n") });
+            continue;
+        }
+        const heading = headingLine(line);
+        if (heading !== null) {
+            cur.pos += 1;
+            out.push({
+                type: "heading",
+                level: heading.level,
+                children: parseInlines(trimSpaceTab(heading.content)),
+            });
+            continue;
+        }
+        const fence = fenceOpen(line);
+        if (fence !== null) {
+            cur.pos += 1;
+            const content = [];
+            for (let l = peek(cur); l !== undefined; l = peek(cur)) {
+                cur.pos += 1;
+                if (fenceClose(l, fence.len)) {
+                    break;
+                }
+                content.push(l);
+            }
+            const text = content.join("\n");
+            out.push(fence.info === null
+                ? { type: "code_block", text }
+                : { type: "code_block", info: fence.info, text });
+            continue;
+        }
+        if (line.startsWith(">") && ctx.quoteDepth < MAX_QUOTE_DEPTH) {
+            const innerLines = [];
+            for (let l = peek(cur); l !== undefined && l.startsWith(">"); l = peek(cur)) {
+                const rest = l.slice(1);
+                innerLines.push(rest.startsWith(" ") ? rest.slice(1) : rest);
+                cur.pos += 1;
+            }
+            const sub = { lines: innerLines, pos: 0 };
+            out.push({
+                type: "blockquote",
+                children: parseContainer(sub, { ...ctx, quoteDepth: ctx.quoteDepth + 1 }, null),
+            });
+            continue;
+        }
+        if (line.replace(/[ \t]+$/, "") === "---") {
+            cur.pos += 1;
+            out.push({ type: "thematic_break" });
+            continue;
+        }
+        if (ctx.listDepth < MAX_LIST_DEPTH) {
+            const m = marker(line);
+            if (m !== null) {
+                out.push(parseList(cur, ctx, m));
+                continue;
+            }
+        }
+        // Paragraph: plain lines until blank / container end / block start.
+        const plines = [line];
+        cur.pos += 1;
+        for (let l = peek(cur); l !== undefined; l = peek(cur)) {
+            if (isBlank(l) || isBlockStart(l, ctx)) {
+                break;
+            }
+            plines.push(l);
+            cur.pos += 1;
+        }
+        if (plines.length === 1) {
+            const target = turbolink(plines[0]);
+            if (target !== null) {
+                out.push({ type: "turbolink", target });
+                continue;
+            }
+        }
+        out.push({ type: "paragraph", children: parseInlines(plines.join("\n")) });
+    }
+    return out;
+}
+function invalid(reason) {
+    return { type: "invalid_directive", reason, children: [] };
+}
+function isBlank(line) {
+    return /^[ \t]*$/.test(line);
+}
+function indentOf(line) {
+    let i = 0;
+    while (i < line.length && line[i] === " ") {
+        i += 1;
+    }
+    return i;
+}
+function trimSpaceTab(s) {
+    return s.replace(/^[ \t]+|[ \t]+$/g, "");
+}
+/** Would this line start a non-paragraph block in this context? (Used both
+ * by the dispatcher and to end paragraphs: any block construct interrupts.) */
+function isBlockStart(line, ctx) {
+    return (line.startsWith(":::") ||
+        line.startsWith("%%") ||
+        headingLine(line) !== null ||
+        fenceOpen(line) !== null ||
+        (line.startsWith(">") && ctx.quoteDepth < MAX_QUOTE_DEPTH) ||
+        line.replace(/[ \t]+$/, "") === "---" ||
+        (ctx.listDepth < MAX_LIST_DEPTH && marker(line) !== null));
+}
+function headingLine(line) {
+    let n = 0;
+    while (n < line.length && line[n] === "#") {
+        n += 1;
+    }
+    if (n >= 1 && n <= 8 && line[n] === " ") {
+        return { level: n, content: line.slice(n + 1) };
+    }
+    return null;
+}
+function fenceOpen(line) {
+    let n = 0;
+    while (n < line.length && line[n] === "`") {
+        n += 1;
+    }
+    if (n < 3) {
+        return null;
+    }
+    const info = trimSpaceTab(line.slice(n));
+    return { len: n, info: info === "" ? null : info };
+}
+function fenceClose(line, openLen) {
+    const t = line.replace(/[ \t]+$/, "");
+    return t.length >= openLen && /^`+$/.test(t);
+}
+function marker(line) {
+    const indent = indentOf(line);
+    const rest = line.slice(indent);
+    if (rest.length >= 2 && "-*+".includes(rest[0]) && rest[1] === " ") {
+        return { indent, ordered: false, contentIdx: indent + 2 };
+    }
+    const m = /^([0-9]+)\. /.exec(rest);
+    if (m !== null) {
+        return { indent, ordered: true, contentIdx: indent + m[1].length + 2 };
+    }
+    return null;
+}
+/** One list of one kind. A same-column marker of the other kind ends this
+ * list (the dispatcher immediately starts the next one). */
+function parseList(cur, ctx, first) {
+    const ordered = first.ordered;
+    const items = [];
+    let buf = [peek(cur).slice(first.contentIdx)];
+    cur.pos += 1;
+    for (;;) {
+        const line = peek(cur);
+        if (line === undefined) {
+            break;
+        }
+        if (isBlank(line)) {
+            // The list continues past blanks only into indented content or a
+            // same-kind column-0/1 marker; anything else ends it here.
+            let j = cur.pos + 1;
+            while (j < cur.lines.length && isBlank(cur.lines[j])) {
+                j += 1;
+            }
+            const next = cur.lines[j];
+            let continues = false;
+            if (next !== undefined) {
+                if (indentOf(next) >= 2) {
+                    continues = true;
+                }
+                else {
+                    const m = marker(next);
+                    continues = m !== null && m.ordered === ordered && m.indent < 2;
+                }
+            }
+            if (!continues) {
+                break;
+            }
+            buf.push("");
+            cur.pos += 1;
+            continue;
+        }
+        if (indentOf(line) >= 2) {
+            // Content (or a deeper marker) inside the current item; strip the
+            // content column. Off-grid extra spaces ride along (floor rule).
+            buf.push(line.slice(2));
+            cur.pos += 1;
+            continue;
+        }
+        // Column 0 or 1 (floors to 0).
+        const m = marker(line);
+        if (m !== null && m.ordered === ordered) {
+            items.push(finishItem(buf, ctx));
+            buf = [line.slice(m.contentIdx)];
+            cur.pos += 1;
+            continue;
+        }
+        break; // column-0 block, or a kind switch
+    }
+    items.push(finishItem(buf, ctx));
+    return { type: "list", ordered, children: items };
+}
+function finishItem(buf, ctx) {
+    const sub = { lines: buf, pos: 0 };
+    return {
+        type: "list_item",
+        children: parseContainer(sub, { ...ctx, listDepth: ctx.listDepth + 1 }, null),
+    };
+}
+function classifyDirective(line) {
+    const rest = line.slice(3).replace(/[ \t]+$/, "");
+    if (rest === "") {
+        return { kind: "close", name: null };
+    }
+    if (rest.startsWith(" ") || rest.startsWith("\t")) {
+        // `::: name` - a named close.
+        const name = trimSpaceTab(rest);
+        return isName(name)
+            ? { kind: "close", name }
+            : { kind: "bad", reason: "bad_name" };
+    }
+    // Open line. The leaf closer token is stripped before attribute parsing.
+    const leaf = rest.endsWith(":::");
+    const body = leaf ? rest.slice(0, -3) : rest;
+    const nlen = nameLen(body);
+    if (nlen === 0) {
+        return { kind: "bad", reason: "bad_name" };
+    }
+    const after = body.slice(nlen);
+    if (!(after === "" || after.startsWith(" ") || after.startsWith("\t"))) {
+        return { kind: "bad", reason: "bad_name" };
+    }
+    return { kind: "open", name: body.slice(0, nlen), attrsSrc: after, leaf };
+}
+/**
+ * A paragraph that is exactly one authority-form absolute URI is a
+ * turbolink. Every bare word is a valid relative URI reference, so the
+ * sugar demands `scheme://`; everything else uses `:::turbolink`.
+ */
+function turbolink(line) {
+    const t = trimSpaceTab(line);
+    if (t === "" || utf8Len(t) > MAX_TARGET_BYTES) {
+        return null;
+    }
+    if (t.includes(" ") || t.includes("\t")) {
+        return null;
+    }
+    const m = /^[A-Za-z][A-Za-z0-9+.-]*/.exec(t);
+    if (m === null) {
+        return null;
+    }
+    const after = t.slice(m[0].length);
+    return after.startsWith("://") && after.length > 3 ? t : null;
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import type { Node } from "./ast.ts";
+export type { Attrs, Node, Reason } from "./ast.ts";
+export declare class UnsupportedVersionError extends Error {
+    readonly version: number;
+    constructor(version: number);
+}
+export declare function parse(input: string): Node;

package/dist/index.js

@@ -0,0 +1,38 @@
+// Reference parser for the Marquee markup language (TypeScript).
+//
+// Parse is total: any byte sequence yields a document. The one refusal is an
+// unknown dialect version (SPEC.md, "Conformance"), surfaced as a thrown
+// error rather than a guessed parse.
+import { parseBlocks } from "./blocks.js";
+export class UnsupportedVersionError extends Error {
+    version;
+    constructor(version) {
+        super(`unsupported marquee version ${version}`);
+        this.name = "UnsupportedVersionError";
+        this.version = version;
+    }
+}
+const U64_MAX = 2n ** 64n - 1n;
+export function parse(input) {
+    // Front-door normalization: \r\n and \r become \n before anything else.
+    const normalized = input.replaceAll("\r\n", "\n").replaceAll("\r", "\n");
+    const [version, body] = stripVersion(normalized);
+    if (version !== 0) {
+        throw new UnsupportedVersionError(version);
+    }
+    return { type: "document", version, children: parseBlocks(body) };
+}
+/** The in-band version declaration: line 1, exactly `#!marquee <integer>`.
+ * The default is version 0, forever. */
+function stripVersion(s) {
+    const nl = s.indexOf("\n");
+    const first = nl === -1 ? s : s.slice(0, nl);
+    const m = /^#!marquee ([0-9]+)$/.exec(first);
+    // Digits past u64 are not a version (mirrors the Rust parse failing):
+    // the line is prose.
+    if (m !== null && BigInt(m[1]) <= U64_MAX) {
+        const body = s.slice(first.length);
+        return [Number(m[1]), body.startsWith("\n") ? body.slice(1) : body];
+    }
+    return [0, s];
+}

package/dist/inlines.d.ts

@@ -0,0 +1,4 @@
+import type { Node } from "./ast.ts";
+export declare const MAX_INLINE_DEPTH = 16;
+export declare const MAX_EMOJI_SLUG_BYTES = 64;
+export declare function parseInlines(text: string): Node[];