npm - @thi.ng/hiccup-markdown - Versions diffs - 2.1.48 → 3.0.0 - Mend

@thi.ng/hiccup-markdown 2.1.48 → 3.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

package/parse.js CHANGED Viewed

@@ -1,223 +1,533 @@
+// thing:no-export
 import { peek } from "@thi.ng/arrays/peek";
-import { alts } from "@thi.ng/fsm/alts";
-import { fsm } from "@thi.ng/fsm/fsm";
-import { not } from "@thi.ng/fsm/not";
-import { whitespace } from "@thi.ng/fsm/range";
-import { repeat } from "@thi.ng/fsm/repeat";
-import { seq } from "@thi.ng/fsm/seq";
-import { str } from "@thi.ng/fsm/str";
-import { untilStr } from "@thi.ng/fsm/until";
-import { comp } from "@thi.ng/transducers/comp";
-import { filter } from "@thi.ng/transducers/filter";
+import { isArray } from "@thi.ng/checks/is-array";
+import { isPlainObject } from "@thi.ng/checks/is-plain-object";
+import { isPrimitive } from "@thi.ng/checks/is-primitive";
+import { isString } from "@thi.ng/checks/is-string";
+import { DEFAULT, defmulti } from "@thi.ng/defmulti";
+import { EMOJI } from "@thi.ng/emoji/emoji";
+import { defContext } from "@thi.ng/parse/context";
+import { defGrammar } from "@thi.ng/parse/grammar";
+import { escapeEntities } from "@thi.ng/strings/entities";
+import { slugifyGH } from "@thi.ng/strings/slugify";
+export const GRAMMAR = defGrammar(`
+DNL1: <DNL>+ => discard ;
+DNL2: <NL>{2,} ;
+lbr: '\\\\'! <NL>! ;
+esc: '\\\\'! ( '<' | '[' | '_' | '*' | '\`' | '~' | ':' ) ;
+inlinedelim: ( "![" | '[' | "**" | '_' | '\`' | '<' | '\\\\' | "~~" | " :" | <lbr> ) ;
+delim: ( <inlinedelim> | <DNL2> ) ;
+delim1: ( <inlinedelim> | <NL> ) ;
+body: .(?-<delim>!) => join ;
+body1: .(?-<delim1>!) => join ;
+wikiref: "[["! .(?+"]]"!) => join ;
+fnref: "[^"! <label> ;
+fnote: <LSTART> "[^"! <fnlabel> <WS1> <para> ;
+fnlabel: .(?+"]:"!) => join ;
+label: .(?+']'!) => join ;
+target: .(?+')'!) => join ;
+link: '['! <linklabel> '('! <target> ;
+linkref: '['! <linklabel> '['! <label> ;
+linkdef: <LSTART> '['! <label> ':'! <WS1> <ldtarget> ;
+ldtarget: .(?+<DNL1>) => join ;
+linklabel: (<img> | <bold> | <italic> | <strike> | <code> | <emoji> | <linkbody>)* ']'! ;
+linkdelim: ( "![" | '[' | "**" | '_' | "~~" | '\`' | ']') ;
+linkbody: .(?-<linkdelim>!) => join ;
+img: "!["! <label> '('! <target> ;
+bold: "**"! (<wikiref> | <img> | <fnref> | <linkref> | <link> | <italic> | <strike> | <code> | <emoji> | <body1>)* "**"! ;
+italic: '_'! (<wikiref> | <img> | <fnref> | <linkref> | <link> | <bold> | <strike> | <code> | <emoji> | <body1>)* '_'! ;
+strike: "~~"! (<wikiref> | <img> | <fnref> | <linkref> | <link> | <bold> | <italic> | <code> | <emoji> | <body1>)* "~~"! ;
+code: '\`'! .(?+'\`'!) => join ;
+kbd: "<kbd>"! .(?+"</kbd>"!) => join ;
+emoji: ' '? ':'! (<ALPHA_NUM> | '+' | '-')(?+':'!) => join ;
+para: (<wikiref> | <img> | <fnref> | <linkref> | <link> | <bold> | <italic> | <strike> | <code> | <kbd> | <emoji> | <lbr> | <esc> | <body>)* <DNL2>! ;
+hdlevel: '#'+ => count ;
+hd: <LSTART> <hdlevel> <WS0>
+    (<wikiref> | <img> | <fnref> | <link> | <bold> | <italic> | <strike> | <code> | <emoji> | <body1> )* <DNL1> ;
+lilevel: ' '* => count ;
+uint: <DIGIT>+ => int ;
+ulid: <DNL> <WS0> '-'! ;
+olid: <DNL> <WS0> <DIGIT>+! '.'! ;
+lidelim: ( <delim> | <ulid> | <olid> ) ;
+libody: .(?-<lidelim>!) => join ;
+todo: '['! [ xX] ']'! <WS1> => hoistR ;
+ulitem: <LSTART> <lilevel> "- "! <todo>?
+        (<wikiref> | <img> | <fnref> | <link> | <bold> | <italic> | <strike> | <code> | <emoji> | <libody> )* <DNL> ;
+olitem: <LSTART> <lilevel> <uint> ". "! <todo>?
+        (<wikiref> | <img> | <fnref> | <link> | <bold> | <italic> | <strike> | <code> | <emoji> | <libody> )* <DNL> ;
+list: (<ulitem> | <olitem>)+ <DNL1> ;
+cbdelim: <LSTART> "\`\`\`"! ;
+codeblock: <cbdelim>! <codemeta> <codebody> <DNL1> ;
+codemeta: .(?+<NL>!) => join ;
+codebody: .(?+<cbdelim>) => join ;
+customdelim: <LSTART> ":::"! ;
+customblock: <customdelim>! <custommeta> <custombody> <DNL1> ;
+custommeta: .(?+<NL>!) => join ;
+custombody: .(?+<customdelim>) => join ;
+metablock: <LSTART> "{{{"! <metabody> <DNL1> ;
+metabody: .(?+<metaend>!) => join ;
+metaend: "}}}" <LEND> ;
+bqlevel: '>'+ => count ;
+bqline: <LSTART> <bqlevel> ' '?!
+        (<wikiref> | <img> | <fnref> | <link> | <bold> | <italic> | <strike> | <code> | <emoji> | <bqlbr> | <body1>)* <DNL> ;
+bqlbr: '\\\\'!(?-<DNL>) ;
+bquote: <bqline>+ <DNL1> ;
+tdelim: (<inlinedelim> | '|' ) ;
+tbody: .(?-<tdelim>!) => join ;
+tcell: <WS0> (<wikiref> | <img> | <fnref> | <link> | <bold> | <italic> | <strike> | <code> | <emoji> | <tbody> )* '|'! ;
+trow: <LSTART> '|'! <tcell>(?+<DNL>) ;
+table: <trow>+ <DNL1> ;
+hr: "--" '-'+ <DNL1> => join ;
+main: <WS0> (<hd> | <list> | <bquote> | <codeblock> | <customblock> | <metablock> | <table> | <hr> | <fnote> | <linkdef> | <para>)* ;
+`);
+export const DEFAULT_TAG_TRANSFORMS = {
+    bold: (_, body) => ["strong", {}, ...body],
+    blockquote: (_, body, meta) => ["blockquote", withMeta({}, meta), ...body],
+    br: () => ["br", {}],
+    code: (_, body) => ["code", {}, body],
+    codeblock: (_, lang, __head, body, meta) => [
+        "pre",
+        withMeta({ data: { lang }, __head }, meta),
+        ["code", {}, body],
+    ],
+    custom: (_, type, __head, body, meta) => [
+        "custom",
+        withMeta({ type, __head }, meta),
+        body,
+    ],
+    emoji: (_, id) => EMOJI[id] || id,
+    footnote: (_, id, body, meta) => [
+        "li",
+        withMeta({ id: `fn-${id}` }, meta),
+        ["sup", {}, `[${id}] `],
+        ...body,
+        " ",
+        ["a", { href: `#fnref-${id}` }, "↩︎"],
+    ],
+    footnoteRef: (_, id) => [
+        "sup",
+        {},
+        ["a", { id: `fnref-${id}`, href: `#fn-${id}` }, `[${id}]`],
+    ],
+    footnoteWrapper: (_, notes) => [
+        "ul",
+        { id: "footnotes" },
+        ...Object.keys(notes)
+            .sort()
+            .map((id) => notes[id]),
+    ],
+    heading: (_, level, id, body, meta) => [
+        level > 6 ? "p" : `h${level}`,
+        withMeta({ id }, meta),
+        ...body,
+    ],
+    hr: (_, __length, meta) => ["hr", withMeta({ __length }, meta)],
+    img: (_, alt, src, title) => ["img", { src, alt, title }],
+    italic: (_, body) => ["em", {}, ...body],
+    kbd: (_, key) => ["kbd", {}, key],
+    link: (_, href, title, body) => ["a", { href, title }, ...body],
+    linkRef: (ctx, refID, body) => [
+        "a",
+        {
+            href: () => ctx.linkRefs[refID]?.[0],
+            title: () => ctx.linkRefs[refID]?.[1],
+        },
+        ...body,
+    ],
+    meta: (_, body) => body,
+    olitem: (_, attribs, index, body) => [
+        "li",
+        { ...attribs, __index: index },
+        ...body,
+    ],
+    ol: (_, items, meta) => ["ol", withMeta({}, meta), ...items],
+    para: (_, body, meta) => ["p", withMeta({}, meta), ...body],
+    strike: (_, body) => ["s", {}, ...body],
+    table: (_, __align, head, rows, meta) => [
+        "table",
+        withMeta({ __align }, meta),
+        ["thead", {}, head],
+        ["tbody", {}, ...rows],
+    ],
+    tableCell: (_, body) => ["td", {}, ...body],
+    tableHead: (_, body) => ["th", {}, ...body],
+    tableRow: (_, __, cells) => ["tr", {}, ...cells],
+    ul: (_, items, meta) => ["ul", withMeta({}, meta), ...items],
+    ulitem: (_, attribs, body) => ["li", attribs, ...body],
+    wikiref: (_, id, label) => [
+        "a",
+        { class: "wikiref", href: encodeURI(id.replace(/\s+/g, "_")) },
+        label || id,
+    ],
+};
+export class ParseError extends Error {
+    constructor(state) {
+        super(state
+            ? `stopped line: ${state.l}, col: ${state.c} (pos: ${state.p})`
+            : undefined);
+        this.state = state;
+    }
+}
 /**
- * Parser state IDs
+ * Parses given Markdown source string into a tree structure defined by given
+ * {@link TagTransforms}.
+ *
+ * @remarks
+ * The tag transforms are optional and the default implementations can be
+ * overwritten on tag-by-tag basis. The default transforms yield a simple hiccup
+ * tree (aka each tag will be an array in the form: `["tagname", {...},
+ * ...body]`).
+ *
+ * See [thi.ng/hiccup](https://thi.ng/hiccup) and related packages for further
+ * details.
+ *
+ * @param src
+ * @param opts
  */
-var State;
-(function (State) {
-    State[State["BLOCKQUOTE"] = 0] = "BLOCKQUOTE";
-    State[State["CODE"] = 1] = "CODE";
-    State[State["CODEBLOCK"] = 2] = "CODEBLOCK";
-    State[State["EMPHASIS"] = 3] = "EMPHASIS";
-    State[State["END_BLOCKQUOTE"] = 4] = "END_BLOCKQUOTE";
-    State[State["END_LI"] = 5] = "END_LI";
-    State[State["END_PARA"] = 6] = "END_PARA";
-    State[State["END_HEADING"] = 7] = "END_HEADING";
-    State[State["END_TABLE"] = 8] = "END_TABLE";
-    State[State["HEADING"] = 9] = "HEADING";
-    State[State["IMG"] = 10] = "IMG";
-    State[State["LINK"] = 11] = "LINK";
-    State[State["LI"] = 12] = "LI";
-    State[State["PARA"] = 13] = "PARA";
-    State[State["START"] = 14] = "START";
-    State[State["START_CODEBLOCK"] = 15] = "START_CODEBLOCK";
-    State[State["STRIKE"] = 16] = "STRIKE";
-    State[State["STRONG"] = 17] = "STRONG";
-    State[State["TABLE"] = 18] = "TABLE";
-})(State || (State = {}));
+export const parse = (src, { tags, opts, linkRefs, logger, } = {}) => {
+    const parseCtx = parseRaw(src, opts?.retain);
+    const mdCtx = defTransformContext(tags, opts, linkRefs, logger);
+    const result = [];
+    transformScope(parseCtx.root, mdCtx, result);
+    return {
+        result,
+        ctx: mdCtx,
+        complete: !!parseCtx.done,
+        state: parseCtx.state,
+    };
+};
 /**
- * Default hiccup element factories
+ * 1st stage of the parsing (with out result transformations). This calls the
+ * `main` rule of the provided parse {@link GRAMMAR} and returns a parse
+ * context, incl. the raw abstract syntax tree of the parsed document. If
+ * parsing failed entirely (due to invalid input), throws a {@link ParseError}.
+ *
+ * @remarks
+ * Note: Even if the function returns a result, parsing might only have
+ * partially successful (can be checked via the [`.done`
+ * flag](https://docs.thi.ng/umbrella/parse/classes/ParseContext.html#done)).
+ *
+ * This function is only for advanced use. Mostly you'll probably want to use
+ * the main {@link parse} function instead.
+ *
+ * @param src
+ * @param retain
  */
-const DEFAULT_TAGS = {
-    blockquote: (xs) => ["blockquote", {}, ...xs],
-    code: (body) => ["code", {}, body],
-    codeblock: (lang, body) => ["pre", { lang }, body],
-    em: (body) => ["em", {}, body],
-    heading: (level, xs) => [level < 7 ? `h${level}` : "p", {}, ...xs],
-    hr: () => ["hr", {}],
-    img: (src, alt) => ["img", { src, alt }],
-    li: (xs) => ["li", {}, ...xs],
-    link: (href, body) => ["a", { href }, body],
-    list: (type, xs) => [type, {}, ...xs],
-    paragraph: (xs) => ["p", {}, ...xs],
-    strong: (body) => ["strong", {}, body],
-    strike: (body) => ["del", {}, body],
-    table: (rows) => ["table", {}, ["tbody", {}, ...rows]],
-    td: (_, xs) => ["td", {}, ...xs],
-    tr: (_, xs) => ["tr", {}, ...xs],
-};
-const BQUOTE = ">";
-const CODE = "`";
-const CODEBLOCK = "```";
-const CODEBLOCK_END = "\n```\n";
-const EM = "_";
-const HD = "#";
-const HR = "-";
-const IMG = "![";
-const LI = "- ";
-const LINK_LABEL = "[";
-const LINK_LABEL_END = "]";
-const LINK_HREF = "(";
-const LINK_HREF_END = ")";
-const NL = "\n";
-const STRIKE = "~~";
-const STRONG = "**";
-const TD = "|";
-// state / context handling helpers
-const transition = (ctx, id) => {
-    ctx.children = [];
-    ctx.body = "";
-    return [id];
-};
-const push = (id, next) => (ctx) => {
-    ctx.stack.push({ id, children: ctx.children.concat(ctx.body) });
-    return transition(ctx, next);
+export const parseRaw = (src, retain = false) => {
+    const ctx = defContext(src + "\n\n", { retain });
+    if (!GRAMMAR.rules.main(ctx))
+        throw new ParseError(ctx.state);
+    return ctx;
 };
-const pop = (result) => (ctx, body) => {
-    const { id, children } = ctx.stack.pop();
-    children.push(result(ctx, body));
-    ctx.children = children;
-    ctx.body = "";
-    return [id];
-};
-const collectChildren = (ctx) => (ctx.children.push(ctx.body), ctx.children);
-const collect = (id) => (ctx, buf) => {
-    ctx.body += buf.join("");
-    return [id];
-};
-const collectHeading = (tag) => (ctx) => [14 /* State.START */, [tag(ctx.hd, collectChildren(ctx))]];
-const collectAndRestart = (tag) => (ctx) => [14 /* State.START */, [tag(collectChildren(ctx))]];
-const collectBlockQuote = (ctx) => (ctx.children.push(ctx.body, ["br", {}]),
-    (ctx.body = ""),
-    [0 /* State.BLOCKQUOTE */]);
-const collectCodeBlock = (tag) => (ctx, body) => [14 /* State.START */, [tag(ctx.lang, body)]];
-const collectLi = (ctx, tag) => ctx.container.push(tag(collectChildren(ctx)));
-const collectList = (type, list, item) => (ctx) => {
-    collectLi(ctx, item);
-    return [14 /* State.START */, [list(type, ctx.container)]];
+export const defTransformContext = (tags, opts, linkRefs, logger) => ({
+    footnotes: {},
+    headings: [],
+    linkRefs: linkRefs || {},
+    hasFootnotes: false,
+    logger,
+    meta: null,
+    row: 0,
+    opts: {
+        escape: false,
+        retain: false,
+        ...opts,
+    },
+    tags: { ...DEFAULT_TAG_TRANSFORMS, ...tags },
+});
+/**
+ * Polymorphic & recursive parse scope/node transformation function. Takes a
+ * single scope, context and accumulator array, then calls itself recursively
+ * for any child scopes and passes relevant data to its user defined
+ * {@link TagTransforms} handler and adds result to the accumulator array.
+ *
+ */
+export const transformScope = defmulti((x, ctx) => {
+    ctx.logger && ctx.logger.debug(x);
+    return x.id;
+}, {
+    body1: "body",
+    bqlbr: "lbr",
+    bqline: "repeat0",
+    label: "body",
+    libody: "body",
+    linkbody: "body",
+    main: "root",
+    repeat1: "repeat0",
+    tbody: "body",
+}, {
+    [DEFAULT]: (scope, ctx) => {
+        throw new Error(`unknown ID: ${scope.id}, ctx: ${JSON.stringify(ctx)}`);
+    },
+    root: ({ children }, ctx, acc) => {
+        if (!children)
+            return;
+        transformScope(children[0], ctx, acc);
+        if (ctx.hasFootnotes) {
+            __collect(acc, ctx.tags.footnoteWrapper(ctx, ctx.footnotes));
+        }
+    },
+    main: (scope, ctx, acc) => transformScope(scope.children[0], ctx, acc),
+    repeat0: (scope, ctx, acc) => scope.children && __children(ctx, scope.children, acc),
+    body: (scope, ctx, acc) => __collect(acc, __escape(ctx, scope.result)),
+    bold: (scope, ctx, acc) => __collect(acc, ctx.tags.bold(ctx, __children(ctx, scope.children))),
+    bquote: (scope, ctx, acc) => {
+        const stack = [[]];
+        const children = scope.children[0].children;
+        const $unwind = (level) => {
+            while (level < stack.length) {
+                const nested = stack.pop();
+                __collect(peek(stack), ctx.tags.blockquote(ctx, __trimBody(nested)));
+            }
+            return peek(stack);
+        };
+        for (let i = 0, n = children.length - 1; i <= n; i++) {
+            const [{ result: level }, bqline] = children[i].children;
+            let body = peek(stack);
+            if (level > stack.length) {
+                while (level > stack.length)
+                    stack.push((body = []));
+            }
+            else if (level < stack.length) {
+                body = $unwind(level);
+            }
+            else if (body.length) {
+                const prev = children[i - 1].children[1];
+                if (!bqline.children) {
+                    __collect(body, ctx.tags.br(ctx));
+                    __collect(body, ctx.tags.br(ctx));
+                }
+                else if (prev.children &&
+                    peek(prev.children).id !== "bqlbr") {
+                    body.push(" ");
+                }
+            }
+            transformScope(bqline, ctx, body);
+        }
+        __collect(acc, ctx.tags.blockquote(ctx, __trimBody($unwind(1)), ctx.meta));
+        ctx.meta = null;
+    },
+    code: (scope, ctx, acc) => __collect(acc, ctx.tags.code(ctx, __escape(ctx, scope.result))),
+    codeblock: ({ children }, ctx, acc) => {
+        const [lang, ...head] = children[0].result.split(" ");
+        const body = children[1].result.trim();
+        __collect(acc, ctx.tags.codeblock(ctx, lang, head, __escape(ctx, body), ctx.meta));
+        ctx.meta = null;
+    },
+    customblock: ({ children }, ctx, acc) => {
+        const [type, ...head] = children[0].result.split(" ");
+        __collect(acc, ctx.tags.custom(ctx, type, head, children[1].result.trim(), ctx.meta));
+        ctx.meta = null;
+    },
+    emoji: ({ result }, ctx, acc) => {
+        if (result[0] === " ") {
+            __collect(acc, " ");
+            result = result.substring(1);
+        }
+        __collect(acc, ctx.tags.emoji(ctx, result));
+    },
+    esc: (scope, ctx, acc) => acc.push(__escape(ctx, scope.children[0].result)),
+    fnote: ({ children }, ctx) => {
+        const body = [];
+        const id = children[0].result;
+        transformScope(children[1].children[0], ctx, body);
+        const res = ctx.tags.footnote(ctx, id, body, ctx.meta);
+        if (res != null) {
+            ctx.hasFootnotes = true;
+            ctx.footnotes[id] = res;
+        }
+        ctx.meta = null;
+    },
+    fnref: (scope, ctx, acc) => __collect(acc, ctx.tags.footnoteRef(ctx, scope.children[0].result)),
+    hd: ({ children }, ctx, acc) => {
+        const body = [];
+        const level = children[0].result;
+        transformScope(children[1], ctx, body);
+        ctx.headings.push({ level, body });
+        __trimBody(body);
+        __collect(acc, ctx.tags.heading(ctx, level, slugifyGH(extractBody(body).join("")), body, ctx.meta));
+        ctx.meta = null;
+    },
+    hr: (scope, ctx, acc) => {
+        __collect(acc, ctx.tags.hr(ctx, scope.result.length, ctx.meta));
+        ctx.meta = null;
+    },
+    img: ({ children }, ctx, acc) => __collect(acc, ctx.tags.img(ctx, __escape(ctx, children[0].result.trim()), ...__linkTitle(children[1].result))),
+    italic: (scope, ctx, acc) => __collect(acc, ctx.tags.italic(ctx, __children(ctx, scope.children))),
+    kbd: (scope, ctx, acc) => __collect(acc, ctx.tags.kbd(ctx, scope.result)),
+    lbr: (_, ctx, acc) => __collect(acc, ctx.tags.br(ctx)),
+    link: ({ children }, ctx, acc) => __collect(acc, ctx.tags.link(ctx, ...__linkTitle(children[1].result), __children(ctx, children[0].children))),
+    linkdef: ({ children }, ctx) => {
+        ctx.linkRefs[children[0].result] = __linkTitle(children[1].result);
+    },
+    linkref: ({ children }, ctx, acc) => __collect(acc, ctx.tags.linkRef(ctx, children[1].result, __children(ctx, children[0].children))),
+    list: (scope, ctx, acc) => {
+        const children = scope.children[0].children;
+        const stack = [
+            [children[0].id === "ulitem" ? "ul" : "ol"],
+        ];
+        const levels = [0];
+        for (let item of children) {
+            const currLevel = item.children[0].result;
+            if (currLevel > peek(levels)) {
+                const sublist = [item.id === "ulitem" ? "ul" : "ol"];
+                const parent = peek(stack);
+                parent.length > 1
+                    ? peek(parent).push(sublist)
+                    : parent.push([
+                        parent[0] === "ul" ? "ulitem" : "olitem",
+                        {},
+                        sublist,
+                    ]);
+                stack.push(sublist);
+                levels.push(currLevel);
+            }
+            else if (currLevel < peek(levels)) {
+                while (currLevel < peek(levels)) {
+                    stack.pop();
+                    levels.pop();
+                }
+            }
+            transformScope(item, ctx, peek(stack));
+        }
+        const $list = (root, isRoot = false) => ctx.tags[root[0]](ctx, root.slice(1).map($item), isRoot ? ctx.meta : null);
+        const $item = (item) => {
+            let last = item[item.length - 1];
+            if (last[0] === "ul" || last[0] === "ol")
+                item[item.length - 1] = $list(last);
+            return item[0] === "ulitem"
+                ? ctx.tags.ulitem(ctx, item[1], item.slice(2))
+                : ctx.tags.olitem(ctx, item[1], item[2], item.slice(3));
+        };
+        __collect(acc, $list(stack[0], true));
+        ctx.meta = null;
+    },
+    metablock: ({ children }, ctx) => {
+        ctx.meta = ctx.tags.meta(ctx, children[0].result.trim());
+    },
+    olitem: ({ children }, ctx, acc) => {
+        const body = [];
+        transformScope(children[3], ctx, body);
+        __collect(acc, [
+            "olitem",
+            __listItemAttribs(children[2]),
+            children[1].result,
+            ...__trimBody(body),
+        ]);
+    },
+    para: (scope, ctx, acc) => {
+        __collect(acc, ctx.tags.para(ctx, __trimBody(__children(ctx, scope.children)), ctx.meta));
+        ctx.meta = null;
+    },
+    strike: (scope, ctx, acc) => __collect(acc, ctx.tags.strike(ctx, __children(ctx, scope.children))),
+    table: (scope, ctx, acc) => {
+        const children = scope.children[0].children;
+        const head = [];
+        const rows = [];
+        ctx.row = 0;
+        transformScope(children[0], ctx, head);
+        let align;
+        if (children.length > 1) {
+            align = __columnAlignments(children[1].children[0].children);
+            for (let i = 2, n = children.length; i < n; i++) {
+                ctx.row = i - 1;
+                transformScope(children[i], ctx, rows);
+            }
+        }
+        else {
+            align = new Array(children[0].children[0].children.length).fill("left");
+        }
+        __collect(acc, ctx.tags.table(ctx, align, head[0], rows, ctx.meta));
+        ctx.meta = null;
+    },
+    tcell: ({ children }, ctx, acc) => __collect(acc, (ctx.row > 0 ? ctx.tags.tableCell : ctx.tags.tableHead)(ctx, __trimBody(__children(ctx, children)))),
+    trow: ({ children }, ctx, acc) => __collect(acc, ctx.tags.tableRow(ctx, ctx.row, __children(ctx, children[0].children))),
+    ulitem: ({ children }, ctx, acc) => {
+        const body = [];
+        transformScope(children[2], ctx, body);
+        __collect(acc, [
+            "ulitem",
+            __listItemAttribs(children[1]),
+            ...__trimBody(body),
+        ]);
+    },
+    wikiref: (scope, ctx, acc) => {
+        const [id, label] = scope.result.split("|");
+        __collect(acc, ctx.tags.wikiref(ctx, id, label));
+    },
+});
+/**
+ * Takes an attributes object and optional metadata. If `meta` is not nullish,
+ * assigns it as `__meta` key in given object. Returns object.
+ *
+ * @param target
+ * @param meta
+ */
+export const withMeta = (target, meta) => {
+    if (meta != null)
+        target.__meta = meta;
+    return target;
 };
-const collectTD = (tag) => (ctx) => {
-    ctx.children.push(ctx.body);
-    ctx.container.push(tag(peek(ctx.stack).container.length, ctx.children));
-    return transition(ctx, 18 /* State.TABLE */);
+/**
+ * Takes a hiccup tree and extracts only the primitive body values (strings,
+ * numbers, booleans) and returns them as array.
+ *
+ * @param body
+ * @param acc
+ */
+export const extractBody = (body, acc = []) => {
+    for (let x of isPlainObject(body[1]) ? body.slice(2) : body) {
+        if (isPrimitive(x))
+            acc.push(x);
+        else if (isArray(x))
+            extractBody(x, acc);
+    }
+    return acc;
 };
-const collectTR = (tag) => (ctx) => {
-    const rows = peek(ctx.stack).container;
-    rows.push(tag(rows.length, ctx.container));
-    ctx.container = [];
-    return transition(ctx, 8 /* State.END_TABLE */);
+/** @internal */
+const __collect = (acc, x) => x != null && acc.push(x);
+/** @internal */
+const __children = (ctx, children, acc = []) => {
+    for (let c of children)
+        transformScope(c, ctx, acc);
+    return acc;
 };
-const collectTable = (tag) => (ctx) => {
-    const rows = ctx.stack.pop().container;
-    rows.splice(1, 1);
-    return [14 /* State.START */, [tag(rows)]];
+/** @internal */
+const __escape = (ctx, x) => ctx.opts.escape ? escapeEntities(x) : x;
+/** @internal */
+const __listItemAttribs = (scope) => scope?.id === "todo"
+    ? {
+        __todo: true,
+        __done: scope.result === "x",
+    }
+    : {};
+/** @internal */
+const __trimBody = (body) => {
+    if (body.length === 1 && isString(body[0]))
+        body[0] = body[0].trim();
+    return body;
 };
-const collectInline = (fn) => pop((ctx, body) => fn(ctx.body + body.trim()));
-const heading = (ctx, body) => ((ctx.hd = body.length), transition(ctx, 9 /* State.HEADING */));
-const matchInline = (id) => [
-    str("![", push(id, 10 /* State.IMG */)),
-    str(LINK_LABEL, push(id, 11 /* State.LINK */)),
-    str(STRIKE, push(id, 16 /* State.STRIKE */)),
-    str(STRONG, push(id, 17 /* State.STRONG */)),
-    str(EM, push(id, 3 /* State.EMPHASIS */)),
-    str(CODE, push(id, 1 /* State.CODE */)),
-];
-const matchLink = (result) => seq([
-    untilStr(LINK_LABEL_END, (ctx, body) => ((ctx.title = body), undefined)),
-    str(LINK_HREF),
-    untilStr(LINK_HREF_END, (ctx, body) => ((ctx.href = body), undefined)),
-], pop((ctx) => result(ctx.href, ctx.title)));
-const matchPara = (id, next) => alts([
-    ...matchInline(id),
-    str(NL, (ctx) => ((ctx.body += " "), [next])),
-], collect(id));
-const newPara = (ctx, buf) => ((ctx.body = buf.join("")), (ctx.children = []), [13 /* State.PARA */]);
-const newParaInline = (next) => (ctx) => {
-    ctx.stack.push({ id: 13 /* State.PARA */, children: [] });
-    return transition(ctx, next);
+/** @internal */
+const __columnAlignments = (children) => {
+    const align = [];
+    for (let c of children) {
+        const raw = c.children[0].children[0].result.trim();
+        const isLeft = raw.startsWith(":-") ? 1 : 0;
+        const isRight = raw.endsWith("-:") ? 2 : 0;
+        align.push((["default", "left", "right", "center"][isLeft | isRight]));
+    }
+    return align;
 };
-const newParaCode = (ctx, x) => ((ctx.body = x[1]),
-    ctx.stack.push({ id: 13 /* State.PARA */, children: [] }),
-    [1 /* State.CODE */]);
-const newList = (ctx) => ((ctx.container = []), transition(ctx, 12 /* State.LI */));
-const newTable = (ctx) => (ctx.stack.push({ id: 18 /* State.TABLE */, container: [] }),
-    (ctx.container = []),
-    transition(ctx, 18 /* State.TABLE */));
-/**
- * Main parser / transducer. Defines state map with the various Markdown
- * syntax matchers and state transition handlers. The returned parser
- * itself is only used in `index.ts`.
- */
-export const parse = (_tags) => {
-    const tags = { ...DEFAULT_TAGS, ..._tags };
-    return comp(filter((x) => x !== "\r"), fsm({
-        [14 /* State.START */]: alts([
-            whitespace(() => [14 /* State.START */]),
-            repeat(str(HD), 1, Infinity, heading),
-            str(BQUOTE, (ctx) => transition(ctx, 0 /* State.BLOCKQUOTE */)),
-            str(LI, newList),
-            alts([
-                seq([str(CODE), not(str(CODE))], newParaCode),
-                str(CODEBLOCK, () => [15 /* State.START_CODEBLOCK */]),
-            ], undefined, (_, next) => next),
-            seq([repeat(str(HR), 3, Infinity), str(NL)], () => [
-                14 /* State.START */,
-                [tags.hr()],
-            ]),
-            str(IMG, newParaInline(10 /* State.IMG */)),
-            str(LINK_LABEL, newParaInline(11 /* State.LINK */)),
-            str(STRONG, newParaInline(17 /* State.STRONG */)),
-            str(STRIKE, newParaInline(16 /* State.STRIKE */)),
-            str(EM, newParaInline(3 /* State.EMPHASIS */)),
-            str(TD, newTable),
-        ], newPara),
-        [13 /* State.PARA */]: matchPara(13 /* State.PARA */, 6 /* State.END_PARA */),
-        [6 /* State.END_PARA */]: alts([
-            ...matchInline(13 /* State.PARA */),
-            str(NL, collectAndRestart(tags.paragraph)),
-        ], collect(13 /* State.PARA */)),
-        [0 /* State.BLOCKQUOTE */]: matchPara(0 /* State.BLOCKQUOTE */, 4 /* State.END_BLOCKQUOTE */),
-        [4 /* State.END_BLOCKQUOTE */]: alts([
-            ...matchInline(0 /* State.BLOCKQUOTE */),
-            str(BQUOTE, collectBlockQuote),
-            str(NL, collectAndRestart(tags.blockquote)),
-        ], collect(0 /* State.BLOCKQUOTE */)),
-        [9 /* State.HEADING */]: matchPara(9 /* State.HEADING */, 7 /* State.END_HEADING */),
-        [7 /* State.END_HEADING */]: alts([
-            ...matchInline(9 /* State.HEADING */),
-            str(NL, collectHeading(tags.heading)),
-        ], collect(9 /* State.HEADING */)),
-        [15 /* State.START_CODEBLOCK */]: untilStr(NL, (ctx, lang) => ((ctx.lang = lang), [2 /* State.CODEBLOCK */])),
-        [2 /* State.CODEBLOCK */]: untilStr(CODEBLOCK_END, collectCodeBlock(tags.codeblock)),
-        [12 /* State.LI */]: matchPara(12 /* State.LI */, 5 /* State.END_LI */),
-        [5 /* State.END_LI */]: alts([
-            str(NL, collectList("ul", tags.list, tags.li)),
-            str(LI, (ctx) => (collectLi(ctx, tags.li),
-                transition(ctx, 12 /* State.LI */))),
-        ], collect(12 /* State.LI */)),
-        [11 /* State.LINK */]: matchLink(tags.link),
-        [10 /* State.IMG */]: matchLink(tags.img),
-        [17 /* State.STRONG */]: untilStr(STRONG, collectInline(tags.strong)),
-        [16 /* State.STRIKE */]: untilStr(STRIKE, collectInline(tags.strike)),
-        [3 /* State.EMPHASIS */]: untilStr(EM, collectInline(tags.em)),
-        [1 /* State.CODE */]: untilStr(CODE, collectInline(tags.code)),
-        [18 /* State.TABLE */]: alts([
-            ...matchInline(18 /* State.TABLE */),
-            str(TD, collectTD(tags.td)),
-            str(NL, collectTR(tags.tr)),
-        ], collect(18 /* State.TABLE */)),
-        [8 /* State.END_TABLE */]: alts([
-            str(NL, collectTable(tags.table)),
-            str(TD, () => [18 /* State.TABLE */]),
-        ]),
-    }, { stack: [] }, 14 /* State.START */));
+const __linkTitle = (src) => {
+    const match = /\s"(.+)"$/.exec(src);
+    return match ? [src.substring(0, match.index), match[1]] : [src, undefined];
 };