@thi.ng/hiccup-markdown 2.1.49 → 3.0.1

package/parser.d.ts

@@ -0,0 +1,65 @@
+import type { Fn3, IObjectOf } from "@thi.ng/api";
+import type { ILogger } from "@thi.ng/logger";
+import type { ContextOpts, ParseScope } from "@thi.ng/parse";
+export declare const GRAMMAR: import("@thi.ng/parse").Language | undefined;
+export declare const parseRaw: (src: string, opts?: Partial<ContextOpts>) => {
+    result: boolean;
+    ctx: import("@thi.ng/parse").ParseContext<string>;
+};
+export interface TagTransforms {
+    bold(ctx: MDParseContext, body: string): any;
+    bquote(ctx: MDParseContext, body: any[], meta?: any): any;
+    code(ctx: MDParseContext, body: string): any;
+    codeblock(ctx: MDParseContext, lang: string, head: string, body: string, meta?: any): any;
+    custom(ctx: MDParseContext, kind: string, body: string, meta?: any): any;
+    emoji(ctx: MDParseContext, id: string): any;
+    footnote(ctx: MDParseContext, id: string, body: any[], meta?: any): any;
+    footnoteRef(ctx: MDParseContext, id: string): any;
+    footnoteWrapper(ctx: MDParseContext, notes: IObjectOf<any>): any;
+    hd(ctx: MDParseContext, level: number, body: any[], meta?: any): any;
+    hr(ctx: MDParseContext, length: number): any;
+    img(ctx: MDParseContext, src: string, alt: string): any;
+    italic(ctx: MDParseContext, body: string): any;
+    link(ctx: MDParseContext, target: string, body: any[]): any;
+    linkRef(ctx: MDParseContext, refID: string, body: any[]): any;
+    meta(ctx: MDParseContext, body: string): any;
+    ol(ctx: MDParseContext, items: any[], meta?: any): any;
+    olitem(ctx: MDParseContext, attribs: TodoAttribs, index: number, ...body: any[]): any;
+    para(ctx: MDParseContext, body: any[], meta?: any): any;
+    strike(ctx: MDParseContext, body: string): any;
+    table(ctx: MDParseContext, align: ColumnAlign[], head: any[], rows: any[], meta?: any): any;
+    tableCell(ctx: MDParseContext, body: any[]): any;
+    tableRow(ctx: MDParseContext, cells: any[]): any;
+    ul(ctx: MDParseContext, items: any[], meta?: any): any;
+    ulitem(ctx: MDParseContext, attribs: TodoAttribs, ...body: any[]): any;
+}
+export interface MDParseContext {
+    logger?: ILogger;
+    tags: TagTransforms;
+    linkRefs: IObjectOf<string>;
+    footnotes: IObjectOf<any>;
+    headings: {
+        level: number;
+        body: any[];
+    }[];
+    hasFootnotes: boolean;
+    meta?: any;
+    opts: MDParseOpts;
+}
+export interface MDParseOpts {
+    /**
+     * Line break representation in blockquotes. E.g. Use `["br",{}]` for actual
+     * line breaks.
+     *
+     * @defaultValue `" "`
+     */
+    bqLineBreak: any;
+}
+export type TodoAttribs = Partial<{
+    __todo: true;
+    __done: boolean;
+}>;
+export type ColumnAlign = "center" | "left" | "right";
+export declare const defMDContext: (tags?: Partial<TagTransforms>, opts?: Partial<MDParseOpts>) => MDParseContext;
+export declare const walk: Fn3<ParseScope<string>, MDParseContext, any[], void>;
+//# sourceMappingURL=parser.d.ts.map

package/parser.js

@@ -0,0 +1,379 @@
+// thing:no-export
+import { peek } from "@thi.ng/arrays/peek";
+import { delay } from "@thi.ng/compose/delay";
+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";
+export const GRAMMAR = defGrammar(`
+DNL1: <DNL>+ => discard ;
+DNL2: <NL>{2,} ;
+inlinedelim: ( "![" | '[' | "**" | '_' | "~~" | '\`' | " :" ) ;
+delim: ( <inlinedelim> | <DNL2> ) ;
+delim1: ( <inlinedelim> | <NL> ) ;
+body: .(?-<delim>!) => join ;
+body1: .(?-<delim1>!) => join ;
+
+ref: "[["! .(?+"]]"!) => join ;
+fnref: "[^"! <label> ;
+fnote: <LSTART> "[^"! <fnlabel> <WS1> <para> ;
+fnlabel: .(?+"]:"!) => join ;
+label: .(?+']'!) => join ;
+target: .(?+')'!) => join ;
+link: '['! <label> '('! <target> ;
+linkref: '['! <label> '['! <label> ;
+linkdef: <LSTART> '['! <label> ':'! <WS1> <ldtarget> ;
+ldtarget: .(?+<DNL1>) => join ;
+img: "!["! <label> '('! <target> ;
+bold: "**"! .(?+"**"!) => join ;
+italic: "_"! .(?+"_"!) => join ;
+code: '\`'! .(?+'\`'!) => join ;
+strike: "~~"! .(?+"~~"!) => join ;
+emoji: ' '? ':'! <ALPHA_NUM>(?+':'!) => join ;
+para: (<ref> | <img> | <fnref> | <linkref> | <link> | <bold> | <italic> | <strike> | <code> | <emoji> | <body>)* <DNL2>! ;
+
+hdlevel: '#'+ => count ;
+hd: <LSTART> <hdlevel> <WS0>
+    (<ref> | <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>?
+        (<ref> | <img> | <fnref> | <link> | <bold> | <italic> | <strike> | <code> | <emoji> | <libody> )* <DNL> ;
+olitem: <LSTART> <lilevel> <uint> ". "! <todo>?
+        (<ref> | <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> ;
+
+bqline: <LSTART> "> "!
+        (<ref> | <img> | <fnref> | <link> | <bold> | <italic> | <strike> | <code> | <emoji> | <body1>)* <DNL> ;
+bquote: <bqline>+ <DNL1> ;
+
+tdelim: (<inlinedelim> | '|' ) ;
+tbody: .(?-<tdelim>!) => join ;
+tcell: <WS0> (<ref> | <img> | <fnref> | <link> | <bold> | <italic> | <strike> | <code> | <emoji> | <tbody> )* '|'! ;
+trow: <LSTART> '|'! <tcell>(?+<DNL>) ;
+table: <trow>+ <DNL1> ;
+
+hr: "--" ('-'(?-<NL>!))* <DNL1> => join ;
+
+main: <WS0> (<hd> | <list> | <bquote> | <codeblock> | <customblock> | <metablock> | <table> | <hr> | <fnote> | <linkdef> | <para>)* ;
+`);
+export const parseRaw = (src, opts) => {
+    const ctx = defContext(src, opts);
+    return { result: GRAMMAR.rules.main(ctx), ctx };
+};
+export const defMDContext = (tags, opts) => ({
+    footnotes: {},
+    headings: [],
+    linkRefs: {},
+    hasFootnotes: false,
+    meta: null,
+    opts: {
+        bqLineBreak: " ",
+        ...opts,
+    },
+    tags: {
+        bold: (_, body) => ["strong", {}, body],
+        bquote: (_, body, meta) => [
+            "blockquote",
+            __withMeta({}, meta),
+            ...body,
+        ],
+        code: (_, body) => ["code", {}, body],
+        codeblock: (_, lang, __head, body, meta) => [
+            "pre",
+            __withMeta({ data: { lang }, __head }, meta),
+            ["code", {}, body],
+        ],
+        custom: (_, kind, body, meta) => [kind, __withMeta({}, 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]),
+        ],
+        hd: (_, level, body, meta) => [
+            level < 7 ? `h${level}` : "p",
+            __withMeta({}, meta),
+            ...body,
+        ],
+        hr: (_, __length) => ["hr", { __length }],
+        img: (_, src, alt) => ["img", { src, alt }],
+        italic: (_, body) => ["em", {}, body],
+        link: (_, href, body) => ["a", { href }, ...body],
+        linkRef: (ctx, refID, body) => [
+            "a",
+            { href: delay(() => ctx.linkRefs[refID]) },
+            ...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],
+        tableRow: (_, cells) => ["tr", {}, ...cells],
+        ul: (_, items, meta) => ["ul", __withMeta({}, meta), ...items],
+        ulitem: (_, attribs, body) => ["li", attribs, ...body],
+        ...tags,
+    },
+});
+export const walk = defmulti((x, ctx) => {
+    ctx.logger && ctx.logger.debug(x);
+    return x.id;
+}, {
+    body1: "body",
+    bqline: "repeat0",
+    label: "body",
+    libody: "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) => {
+        walk(children[0], ctx, acc);
+        if (ctx.hasFootnotes) {
+            __collect(acc, ctx.tags.footnoteWrapper(ctx, ctx.footnotes));
+        }
+    },
+    main: ({ children }, ctx, acc) => walk(children[0], ctx, acc),
+    repeat0: ({ children }, ctx, acc) => {
+        for (let c of children)
+            walk(c, ctx, acc);
+    },
+    body: ({ result }, _, acc) => __collect(acc, result),
+    bold: ({ result }, ctx, acc) => __collect(acc, ctx.tags.bold(ctx, result)),
+    bquote: (scope, ctx, acc) => {
+        const body = [];
+        const children = scope.children[0].children;
+        for (let i = 0, n = children.length - 1; i <= n; i++) {
+            walk(children[i].children[0], ctx, body);
+            if (i < n)
+                body.push(ctx.opts.bqLineBreak);
+        }
+        __collect(acc, ctx.tags.bquote(ctx, body, ctx.meta));
+        ctx.meta = null;
+    },
+    code: ({ result }, ctx, acc) => __collect(acc, ctx.tags.code(ctx, result)),
+    codeblock: ({ children }, ctx, acc) => {
+        const [lang, ...head] = children[0].result.split(" ");
+        __collect(acc, ctx.tags.codeblock(ctx, lang, head, children[1].result.trim(), ctx.meta));
+        ctx.meta = null;
+    },
+    customblock: ({ children }, ctx, acc) => {
+        __collect(acc, ctx.tags.custom(children[0].result, 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));
+    },
+    fnote: ({ children }, ctx) => {
+        const body = [];
+        const id = children[0].result;
+        walk(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: ({ children }, ctx, acc) => __collect(acc, ctx.tags.footnoteRef(ctx, children[0].result)),
+    hd: ({ children }, ctx, acc) => {
+        const body = [];
+        const level = children[0].result;
+        walk(children[1], ctx, body);
+        ctx.headings.push({ level, body });
+        __collect(acc, ctx.tags.hd(ctx, level, body, ctx.meta));
+        ctx.meta = null;
+    },
+    hr: ({ result }, ctx, acc) => __collect(acc, ctx.tags.hr(ctx, result.length)),
+    img: ({ children }, ctx, acc) => __collect(acc, ctx.tags.img(ctx, children[1].result, children[0].result)),
+    italic: ({ result }, ctx, acc) => __collect(acc, ctx.tags.italic(ctx, result)),
+    link: ({ children }, ctx, acc) => {
+        const body = [];
+        walk(children[0], ctx, body);
+        __collect(acc, ctx.tags.link(ctx, children[1].result, body));
+    },
+    linkdef: ({ children }, ctx) => {
+        ctx.linkRefs[children[0].result] = children[1].result;
+    },
+    linkref: ({ children }, ctx, acc) => {
+        const body = [];
+        walk(children[0], ctx, body);
+        __collect(acc, ctx.tags.linkRef(ctx, children[1].result, body));
+    },
+    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();
+                }
+            }
+            walk(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 = [];
+        walk(children[3], ctx, body);
+        __collect(acc, [
+            "olitem",
+            __listItemAttribs(children[2]),
+            children[1].result,
+            ...body,
+        ]);
+    },
+    para: ({ children }, ctx, acc) => {
+        const body = [];
+        for (let c of children)
+            walk(c, ctx, body);
+        __collect(acc, ctx.tags.para(ctx, body, ctx.meta));
+        ctx.meta = null;
+    },
+    strike: ({ result }, ctx, acc) => __collect(acc, ctx.tags.strike(ctx, result)),
+    table: (scope, ctx, acc) => {
+        const children = scope.children[0].children;
+        const head = [];
+        const rows = [];
+        walk(children[0], ctx, head);
+        let align = [];
+        if (children.length > 1) {
+            for (let c of children[1].children[0].children) {
+                const raw = (c.children[0].children[0].result.trim());
+                align.push(raw.startsWith(":-")
+                    ? raw.endsWith("-:")
+                        ? "center"
+                        : "left"
+                    : raw.endsWith("-:")
+                        ? "right"
+                        : "left");
+            }
+            for (let c of children.slice(2))
+                walk(c, 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) => {
+        const body = [];
+        for (let c of children)
+            walk(c, ctx, body);
+        __collect(acc, ctx.tags.tableCell(ctx, body));
+    },
+    trow: ({ children }, ctx, acc) => {
+        const cols = [];
+        for (let c of children[0].children)
+            walk(c, ctx, cols);
+        __collect(acc, ctx.tags.tableRow(ctx, cols));
+    },
+    ulitem: ({ children }, ctx, acc) => {
+        const body = [];
+        walk(children[2], ctx, body);
+        __collect(acc, [
+            "ulitem",
+            __listItemAttribs(children[1]),
+            ...body,
+        ]);
+    },
+});
+const __collect = (acc, x) => x != null && acc.push(x);
+const __withMeta = (target, meta) => {
+    if (meta != null) {
+        target.__meta = meta;
+    }
+    return target;
+};
+const __listItemAttribs = (scope) => scope?.id === "todo"
+    ? {
+        __todo: true,
+        __done: scope.result === "x",
+    }
+    : {};

package/serialize.d.ts

@@ -3,8 +3,9 @@ interface SerializeState {
     sep: string;
     id?: number;
     pre?: boolean;
+    blockquote?: boolean;
 }
 export declare const serialize: (tree: any, ctx: any) => string;
-export declare const serializeElement: import("@thi.ng/defmulti/api").MultiFn3<any, any, SerializeState, string>;
+export declare const serializeElement: import("@thi.ng/defmulti").MultiFn3<any, any, SerializeState, string>;
 export {};
 //# sourceMappingURL=serialize.d.ts.map

package/serialize.js

@@ -10,8 +10,10 @@ import { wrap } from "@thi.ng/strings/wrap";
 import { Border } from "@thi.ng/text-canvas/api";
 import { formatCanvas } from "@thi.ng/text-canvas/format";
 import { tableCanvas } from "@thi.ng/text-canvas/table";
-export const serialize = (tree, ctx) => _serialize(tree, ctx, { indent: 0, sep: "" }).replace(/\n{3,}/g, "\n\n");
-const _serialize = (tree, ctx, state) => {
+export const serialize = (tree, ctx) => __serialize(tree, ctx, { indent: 0, sep: "" })
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+const __serialize = (tree, ctx, state) => {
     if (tree == null)
         return "";
     if (Array.isArray(tree)) {
@@ -20,10 +22,10 @@ const _serialize = (tree, ctx, state) => {
         }
         let tag = tree[0];
         if (isFunction(tag)) {
-            return _serialize(tag.apply(null, [ctx, ...tree.slice(1)]), ctx, state);
+            return __serialize(tag.apply(null, [ctx, ...tree.slice(1)]), ctx, state);
         }
         if (implementsFunction(tag, "render")) {
-            return _serialize(tag.render.apply(null, [ctx, ...tree.slice(1)]), ctx, state);
+            return __serialize(tag.render.apply(null, [ctx, ...tree.slice(1)]), ctx, state);
         }
         if (isString(tag)) {
             tree = normalize(tree);
@@ -35,63 +37,68 @@ const _serialize = (tree, ctx, state) => {
             return serializeElement(tree, ctx, state);
         }
         if (isNotStringAndIterable(tree)) {
-            return serializeIter(tree, ctx, state);
+            return __serializeIter(tree, ctx, state);
         }
         illegalArgs(`invalid tree node: ${tree}`);
     }
     if (isFunction(tree)) {
-        return _serialize(tree(ctx), ctx, state);
+        return __serialize(tree(ctx), ctx, state);
     }
     if (implementsFunction(tree, "toHiccup")) {
-        return _serialize(tree.toHiccup(ctx), ctx, state);
+        return __serialize(tree.toHiccup(ctx), ctx, state);
     }
     if (implementsFunction(tree, "deref")) {
-        return _serialize(tree.deref(), ctx, state);
+        return __serialize(tree.deref(), ctx, state);
     }
     if (isNotStringAndIterable(tree)) {
-        return serializeIter(tree, ctx, state);
+        return __serializeIter(tree, ctx, state);
     }
     return tree.toString();
 };
-const serializeIter = (iter, ctx, state) => {
+const __serializeIter = (iter, ctx, state) => {
     if (!iter)
         return "";
     const res = [];
     for (let i of iter) {
-        res.push(_serialize(i, ctx, state));
+        res.push(__serialize(i, ctx, state));
     }
     return res.join(state.sep);
 };
-const header = (level) => (el, ctx, state) => repeat("#", level) + " " + body(el, ctx, state) + "\n\n";
-const body = (el, ctx, state) => serializeIter(el[2], ctx, state);
+const __heading = (level) => (el, ctx, state) => `\n${repeat("#", level)} ${__body(el, ctx, state)}\n`;
+const __body = (el, ctx, state) => __serializeIter(el[2], ctx, state);
+const __resolve = (x) => (isFunction(x) ? x() : x);
 export const serializeElement = defmulti((el) => el[0], {
     th: "strong",
 }, {
-    [DEFAULT]: body,
-    h1: header(1),
-    h2: header(2),
-    h3: header(3),
-    h4: header(4),
-    h5: header(5),
-    h6: header(6),
-    p: (el, ctx, state) => `\n${body(el, ctx, state)}\n`,
+    [DEFAULT]: __body,
+    h1: __heading(1),
+    h2: __heading(2),
+    h3: __heading(3),
+    h4: __heading(4),
+    h5: __heading(5),
+    h6: __heading(6),
+    p: (el, ctx, state) => `\n${__body(el, ctx, state)}\n`,
     img: (el) => `![${el[1].alt || ""}](${el[1].src})`,
-    a: (el, ctx, state) => `[${body(el, ctx, state)}](${el[1].href})`,
-    em: (el, ctx, state) => `_${body(el, ctx, state)}_`,
-    strong: (el, ctx, state) => `**${body(el, ctx, state)}**`,
-    pre: (el, ctx, state) => `\n\`\`\`${el[1].lang || ""}\n${body(el, ctx, {
+    a: (el, ctx, state) => {
+        let { href, title } = el[1];
+        title = __resolve(title);
+        return `[${__body(el, ctx, state)}](${__resolve(href)}${title ? ` "${title}"` : ""})`;
+    },
+    em: (el, ctx, state) => `_${__body(el, ctx, state)}_`,
+    strong: (el, ctx, state) => `**${__body(el, ctx, state)}**`,
+    pre: (el, ctx, state) => `\n\`\`\`${el[1].lang || ""}\n${__body(el, ctx, {
         ...state,
         pre: true,
         sep: "\n",
     })}\n\`\`\`\n`,
-    code: (el, ctx, state) => state.pre ? el[2][0] : `\`${body(el, ctx, state)}\``,
+    code: (el, ctx, state) => state.pre ? el[2][0] : `\`${__body(el, ctx, state)}\``,
     ul: (el, ctx, state) => {
         const cstate = {
             ...state,
             indent: state.indent + 4,
             sep: "\n",
         };
-        return wrap(state.indent === 0 ? "\n" : "")(body(el, ctx, cstate));
+        return wrap(state.indent === 0 ? "\n" : "")(__body(el, ctx, cstate));
     },
     ol: (el, ctx, state) => {
         const cstate = {
@@ -100,14 +107,18 @@ export const serializeElement = defmulti((el) => el[0], {
             id: 0,
             sep: "\n",
         };
-        return wrap(state.indent === 0 ? "\n" : "")(body(el, ctx, cstate));
+        return wrap(state.indent === 0 ? "\n" : "")(__body(el, ctx, cstate));
     },
     li: (el, ctx, state) => repeat(" ", state.indent - 4) +
         (state.id != null ? ++state.id + "." : "-") +
         " " +
-        body(el, ctx, { ...state, sep: "" }),
-    blockquote: (el, ctx, state) => `\n> ${body(el, ctx, state)}\n`,
-    br: () => "\\\n",
+        __body(el, ctx, { ...state, sep: "" }),
+    blockquote: (el, ctx, state) => `\n${repeat(">", state.indent + 1)} ${__body(el, ctx, {
+        ...state,
+        indent: state.indent + 1,
+        blockquote: true,
+    })}\n`,
+    br: (_, __, state) => state.blockquote ? `\\\n${repeat(">", state.indent)} ` : "\\\n",
     hr: () => "\n---\n",
     table: (el, ctx, state) => {
         let caption = "";
@@ -129,7 +140,7 @@ export const serializeElement = defmulti((el) => el[0], {
                     tbody = rows(child[2]);
                     break;
                 case "caption":
-                    caption = body(child, ctx, state);
+                    caption = __body(child, ctx, state);
                     break;
                 default:
                 // TODO output warning?