micro-models-agent 2.16.1 → 2.17.1

package/dist/assets/smd.js

@@ -1,1665 +1,29 @@
-/*
-Streaming Markdown Parser and Renderer
-MIT License
-Copyright 2024 Damian Tarnawski
-https://github.com/thetarnav/streaming-markdown
-*/
-
-export const
-    DOCUMENT        =  1,
-    PARAGRAPH       =  2,
-    HEADING_1       =  3,
-    HEADING_2       =  4,
-    HEADING_3       =  5,
-    HEADING_4       =  6,
-    HEADING_5       =  7,
-    HEADING_6       =  8,
-    CODE_BLOCK      =  9,
-    CODE_FENCE      = 10,
-    CODE_INLINE     = 11,
-    ITALIC_AST      = 12,
-    ITALIC_UND      = 13,
-    STRONG_AST      = 14,
-    STRONG_UND      = 15,
-    STRIKE          = 16,
-    LINK            = 17,
-    RAW_URL         = 18,
-    IMAGE           = 19,
-    BLOCKQUOTE      = 20,
-    LINE_BREAK      = 21,
-    RULE            = 22,
-    LIST_UNORDERED  = 23,
-    LIST_ORDERED    = 24,
-    LIST_ITEM       = 25,
-    CHECKBOX        = 26,
-    TABLE           = 27,
-    TABLE_ROW       = 28,
-    TABLE_CELL      = 29,
-    EQUATION_BLOCK  = 30,
-    EQUATION_INLINE = 31,
-    NEWLINE         = 101,
-    MAYBE_URL       = 102,
-    MAYBE_TASK      = 103,
-    MAYBE_BR        = 104,
-    MAYBE_EQ_BLOCK  = 105
-
-/** @enum {(typeof Token)[keyof typeof Token]} */
-export const Token = /** @type {const} */({
-    Document:       DOCUMENT,
-    Blockquote:     BLOCKQUOTE,
-    Paragraph:      PARAGRAPH,
-    Heading_1:      HEADING_1,
-    Heading_2:      HEADING_2,
-    Heading_3:      HEADING_3,
-    Heading_4:      HEADING_4,
-    Heading_5:      HEADING_5,
-    Heading_6:      HEADING_6,
-    Code_Block:     CODE_BLOCK,
-    Code_Fence:     CODE_FENCE,
-    Code_Inline:    CODE_INLINE,
-    Italic_Ast:     ITALIC_AST,
-    Italic_Und:     ITALIC_UND,
-    Strong_Ast:     STRONG_AST,
-    Strong_Und:     STRONG_UND,
-    Strike:         STRIKE,
-    Link:           LINK,
-    Raw_URL:        RAW_URL,
-    Image:          IMAGE,
-    Line_Break:     LINE_BREAK,
-    Rule:           RULE,
-    List_Unordered: LIST_UNORDERED,
-    List_Ordered:   LIST_ORDERED,
-    List_Item:      LIST_ITEM,
-    Checkbox:       CHECKBOX,
-    Table:          TABLE,
-    Table_Row:      TABLE_ROW,
-    Table_Cell:     TABLE_CELL,
-    Equation_Block: EQUATION_BLOCK,
-    Equation_Inline:EQUATION_INLINE,
-})
-
-/**
- * @param   {Token} type
- * @returns {string    } */
-export function token_to_string(type) {
-    switch (type) {
-    case DOCUMENT:       return "Document"
-    case BLOCKQUOTE:     return "Blockquote"
-    case PARAGRAPH:      return "Paragraph"
-    case HEADING_1:      return "Heading_1"
-    case HEADING_2:      return "Heading_2"
-    case HEADING_3:      return "Heading_3"
-    case HEADING_4:      return "Heading_4"
-    case HEADING_5:      return "Heading_5"
-    case HEADING_6:      return "Heading_6"
-    case CODE_BLOCK:     return "Code_Block"
-    case CODE_FENCE:     return "Code_Fence"
-    case CODE_INLINE:    return "Code_Inline"
-    case ITALIC_AST:     return "Italic_Ast"
-    case ITALIC_UND:     return "Italic_Und"
-    case STRONG_AST:     return "Strong_Ast"
-    case STRONG_UND:     return "Strong_Und"
-    case STRIKE:         return "Strike"
-    case LINK:           return "Link"
-    case RAW_URL:        return "Raw URL"
-    case IMAGE:          return "Image"
-    case LINE_BREAK:     return "Line_Break"
-    case RULE:           return "Rule"
-    case LIST_UNORDERED: return "List_Unordered"
-    case LIST_ORDERED:   return "List_Ordered"
-    case LIST_ITEM:      return "List_Item"
-    case CHECKBOX:       return "Checkbox"
-    case TABLE:          return "Table"
-    case TABLE_ROW:      return "Table_Row"
-    case TABLE_CELL:     return "Table_Cell"
-    case EQUATION_BLOCK: return "Equation_Block"
-    case EQUATION_INLINE:return "Equation_Inline"
-    }
-}
-
-export const
-    HREF    = 1,
-    SRC     = 2,
-    LANG    = 4,
-    CHECKED = 8,
-    START   = 16
-
-/** @enum {(typeof Attr)[keyof typeof Attr]} */
-export const Attr = /** @type {const} */({
-    Href   : HREF,
-    Src    : SRC,
-    Lang   : LANG,
-    Checked: CHECKED,
-    Start  : START,
-})
-
-/**
- * @param   {Attr} type
- * @returns {string    } */
-export function attr_to_html_attr(type) {
-    switch (type) {
-    case HREF:    return "href"
-    case SRC :    return "src"
-    case LANG:    return "class"
-    case CHECKED: return "checked"
-    case START:   return "start"
-    }
-}
-
-/**
- * @param   {number} level
- * @returns {Token } */
-export const level_to_heading = (level) => {
-    switch (level) {
-    case 1:  return HEADING_1
-    case 2:  return HEADING_2
-    case 3:  return HEADING_3
-    case 4:  return HEADING_4
-    case 5:  return HEADING_5
-    default: return HEADING_6
-    }
-}
-export const heading_from_level = level_to_heading
-
-/**
- * @param   {Token} token
- * @returns {number} */
-export const heading_to_level = (token) => {
-    switch (token) {
-    case HEADING_1: return 1
-    case HEADING_2: return 2
-    case HEADING_3: return 3
-    case HEADING_4: return 4
-    case HEADING_5: return 5
-    case HEADING_6: return 6
-    default:        return 0
-    }
-}
-
-/**
- * @typedef  {object      } Parser
- * @property {Any_Renderer} renderer        - {@link Renderer} interface
- * @property {string      } text            - Text to be added to the last token in the next flush
- * @property {string      } pending         - Characters for identifying tokens
- * @property {Uint32Array } tokens          - Current token and it's parents (a slice of a tree)
- * @property {number      } len             - Number of tokens in types without root
- * @property {number      } token           - Last token in the tree
- * @property {Uint8Array  } spaces
- * @property {string      } indent
- * @property {number      } indent_len
- * @property {number      } fence_end       - For {@link Token.Code_Fence} parsing
- * @property {number      } fence_start
- * @property {number      } blockquote_idx  - For Blockquote parsing
- * @property {string      } hr_char         - For horizontal rule parsing
- * @property {number      } hr_chars        - For horizontal rule parsing
- * @property {number      } table_state
- */
-
-const TOKEN_ARRAY_CAP = 24
-
-/**
- * Makes a new Parser object.
- * @param   {Any_Renderer} renderer
- * @returns {Parser      } */
-export function parser(renderer) {
-    const tokens = new Uint32Array(TOKEN_ARRAY_CAP)
-    tokens[0] = DOCUMENT
-    return {
-        renderer   : renderer,
-        text       : "",
-        pending    : "",
-        tokens     : tokens,
-        len        : 0,
-        token      : DOCUMENT,
-        fence_end: 0,
-        blockquote_idx: 0,
-        hr_char    : '',
-        hr_chars   : 0,
-        fence_start: 0,
-        spaces     : new Uint8Array(TOKEN_ARRAY_CAP),
-        indent     : "",
-        indent_len : 0,
-        table_state: 0,
-    }
-}
-
-/**
- * Finish rendering the markdown - flushes any remaining text.
- * @param   {Parser} p
- * @returns {void  } */
-export function parser_end(p) {
-    if (p.pending.length > 0) {
-        parser_write(p, "\n")
-    }
-}
-
-/**
- * @param   {Parser} p
- * @returns {void  } */
-function add_text(p) {
-    if (p.text.length === 0) return
-    console.assert(p.len > 0, "Never adding text to root")
-    p.renderer.add_text(p.renderer.data, p.text)
-    p.text = ""
-}
-
-/**
- * @param   {Parser} p
- * @returns {void  } */
-function ensure_paragraph(p) {
-    switch (p.token) {
-    case LINE_BREAK:
-    case DOCUMENT:
-    case BLOCKQUOTE:
-    case LIST_ORDERED:
-    case LIST_UNORDERED:
-        add_token(p, PARAGRAPH)
-    }
-}
-
-/**
- * @param   {Parser} p
- * @param   {string} text
- * @returns {void  } */
-function push_text(p, text) {
-    ensure_paragraph(p)
-    p.text += text
-}
-
-/**
- * @param   {Parser} p
- * @returns {void  } */
-function end_token(p) {
-    console.assert(p.len > 0, "No nodes to end")
-    p.len -= 1
-    p.token = /** @type {Token} */ (p.tokens[p.len])
-    p.renderer.end_token(p.renderer.data)
-}
-
-/**
- * @param   {Parser} p
- * @param   {Token } token
- * @returns {void  } */
-function add_token(p, token) {
-    /*
-     If a list doesn't start with a list item
-     it means that there was a newline after the list:
-
-     1. foo
-     2. bar
-     <empty line>
-     <not_a_list_item> <- new token
-    */
-    if ((p.tokens[p.len] === LIST_ORDERED || p.tokens[p.len] === LIST_UNORDERED) &&
-        token !== LIST_ITEM
-    ) {
-        end_token(p)
-    }
-
-    p.len += 1
-    p.tokens[p.len] = token
-    p.token = token
-    p.renderer.add_token(p.renderer.data, token)
-}
-
-/**
- * @param   {Parser} p
- * @param   {number} token
- * @param   {number} start_idx
- * @returns {number} */
-function idx_of_token(p, token, start_idx) {
-    while (start_idx <= p.len) {
-        if (p.tokens[start_idx] === token) {
-            return start_idx
-        }
-        start_idx += 1
-    }
-    return -1
-}
-
-/**
- * End tokens until the parser has the given length.
- * @param   {Parser} p
- * @param   {number} len
- * @returns {void  } */
-function end_tokens_to_len(p, len) {
-
-    // TODO: specific token state should be reset only when the token ends
-    p.fence_start = 0
-
-    while (p.len > len) {
-        end_token(p)
-    }
-}
-
-/**
- * @param   {Parser} p
- * @param   {number} indent
- * @returns {number} */
-function end_tokens_to_indent(p, indent) {
-
-    let idx = 0
-    for (let i = 0; i <= p.len; i += 1) {
-        indent -= p.spaces[i]
-        if (indent < 0) {
-            break   
-        }
-        switch (p.tokens[i]) {
-        case CODE_BLOCK:
-        case CODE_FENCE:
-        case BLOCKQUOTE:
-        case LIST_ITEM:
-            idx = i
-            break
-        }
-    }
-
-    while (p.len > idx) {end_token(p)}
-    
-    return indent
-}
-
-/**
- * @param   {Parser } p
- * @param   {Token  } list_token
- * @returns {boolean} added a new list */
-function continue_or_add_list(p, list_token) {
-    /* will create a new list inside the last item
-       if the amount of spaces is greater than the last one (with prefix)
-       1. foo
-          - bar      <- new nested ul
-             - baz   <- new nested ul
-          12. qux    <- cannot be nested in "baz" or "bar",
-                        so it's a new list in "foo"
-    */
-    let list_idx = -1
-    let item_idx = -1
-
-    for (let i = p.blockquote_idx+1; i <= p.len; i += 1) {
-        if (p.tokens[i] === LIST_ITEM) {
-            if (p.indent_len < p.spaces[i]) {
-                item_idx = -1
-                break
-            }
-            item_idx = i
-        } else if (p.tokens[i] === list_token) {
-            list_idx = i
-        }
-    }
-
-    if (item_idx === -1) {
-        if (list_idx === -1) {
-            end_tokens_to_len(p, p.blockquote_idx)
-            add_token(p, list_token)
-            return true
-        }
-        end_tokens_to_len(p, list_idx)
-        return false
-    }
-    end_tokens_to_len(p, item_idx)
-    add_token(p, list_token)
-    return true
-}
-
-/**
- * Create a new list
- * or continue the last one
- * @param   {Parser } p
- * @param   {number } prefix_length
- * @returns {void   } */
-function add_list_item(p, prefix_length) {
-    add_token(p, LIST_ITEM)
-    p.spaces[p.len] = p.indent_len + prefix_length
-    clear_root_pending(p)
-    p.token = MAYBE_TASK
-}
-
-/**
- * @param   {Parser} p
- * @returns {void  } */
-function clear_root_pending(p) {
-    p.indent = ""
-    p.indent_len = 0
-    p.pending = ""
-}
-
-/**
- * @param   {number} charcode
- * @returns {boolean} */
-function is_digit(charcode) {
-    switch (charcode) {
-    case 48: case 49: case 50: case 51: case 52:
-    case 53: case 54: case 55: case 56: case 57:
-        return true
-    default:
-        return false
-    }
-}
-
-/**
- * @param   {number} charcode
- * @returns {boolean} */
-function is_delimeter(charcode) {
-    switch (charcode) {
-    //   " "      ":"      ";"      ")"      ","      "!"      "."      "?"      "]"      "\n"
-    case 32: case 58: case 59: case 41: case 44: case 33: case 46: case 63: case 93: case 10: 
-        return true
-    default:
-        return false
-    }
-}
-
-/**
- * @param   {number} charcode
- * @returns {boolean} */
-function is_delimeter_or_number(charcode) {
-    return is_digit(charcode) || is_delimeter(charcode)
-}
-
-/**
- * @param   {number} charcode
- * @returns {boolean} */
-function is_alnum(charcode) {
-    return is_digit(charcode)                 || // 0-9
-           (charcode >= 65 && charcode <= 90) || // A-Z
-           (charcode >= 97 && charcode <= 122)   // a-z
-}
-
-/**
- * Parse and render another chunk of markdown.
- * @param   {Parser} p
- * @param   {string} chunk
- * @returns {void  } */
-export function parser_write(p, chunk) {
-    for (const char of chunk) {
-
-        /*
-         Handle newlines
-        */
-        if (p.token === NEWLINE) {
-            switch (char) {
-            case ' ':
-                p.indent_len += 1
-                continue
-            case '\t':
-                p.indent_len += 4
-                continue
-            }
-            
-            let indent = end_tokens_to_indent(p, p.indent_len)
-            
-            p.indent_len = 0
-            p.token = p.tokens[p.len]
-
-            if (indent > 0) {
-                parser_write(p, " ".repeat(indent))
-            }
-        }
-
-        const pending_with_char = p.pending + char
-
-        /*
-        Token specific checks
-        */
-        switch (p.token) {
-        case LINE_BREAK:
-        case DOCUMENT:
-        case BLOCKQUOTE:
-        case LIST_ORDERED:
-        case LIST_UNORDERED:
-            console.assert(p.text.length === 0, "Root should not have any text")
-
-            switch (p.pending[0]) {
-            case undefined:
-                p.pending = char
-                continue
-            case ' ':
-                console.assert(p.pending.length === 1)
-                p.pending = char
-                p.indent += ' '
-                p.indent_len += 1
-                continue
-            case '\t':
-                console.assert(p.pending.length === 1)
-                p.pending = char
-                p.indent += '\t'
-                p.indent_len += 4
-                continue
-            case '\n':
-                console.assert(p.pending.length === 1)
-                /*
-                 Lists can have an empty line in between items:
-                 1. foo
-                 <empty>
-                 2. bar
-                */
-                if (p.tokens[p.len] === LIST_ITEM && p.token === LINE_BREAK) {
-                    end_token(p)
-                    clear_root_pending(p)
-                    p.pending = char
-                    continue
-                }
-                /*
-                 Exit out of tokens
-                 And ignore newlines in root
-                */
-                end_tokens_to_len(p, p.blockquote_idx)
-                clear_root_pending(p)
-                p.blockquote_idx = 0
-                p.fence_start = 0
-                p.pending = char
-                continue
-            /* Heading */
-            case '#':
-                switch (char) {
-                case '#':
-                    if (p.pending.length < 6) {
-                        p.pending = pending_with_char
-                        continue
-                    }
-                    break // fail
-                case ' ':
-                    end_tokens_to_indent(p, p.indent_len)
-                    add_token(p, heading_from_level(p.pending.length))
-                    clear_root_pending(p)
-                    continue
-                }
-                break // fail
-            /* Blockquote */
-            case '>': {
-                const next_blockquote_idx = idx_of_token(p, BLOCKQUOTE, p.blockquote_idx+1)
-
-                /*
-                Only when there is no blockquote to the right of blockquote_idx
-                a new blockquote can be created
-                */
-                if (next_blockquote_idx === -1) {
-                    end_tokens_to_len(p, p.blockquote_idx)
-                    p.blockquote_idx += 1
-                    p.fence_start = 0
-                    add_token(p, BLOCKQUOTE)
-                } else {
-                    p.blockquote_idx = next_blockquote_idx
-                }
-
-                clear_root_pending(p)
-                p.pending = char
-                continue
-            }
-            /* Horizontal Rule
-               "-- - --- - --"
-            */
-            case '-':
-            case '*':
-            case '_':
-                if (p.hr_chars === 0) {
-                    console.assert(p.pending.length === 1, "Pending should be one character")
-                    p.hr_chars = 1
-                    p.hr_char = p.pending
-                }
-
-                if (p.hr_chars > 0) {
-                    switch (char) {
-                    case p.hr_char:
-                        p.hr_chars += 1
-                        p.pending = pending_with_char
-                        continue
-                    case ' ':
-                        p.pending = pending_with_char
-                        continue
-                    case '\n':
-                        if (p.hr_chars < 3) break
-                        end_tokens_to_indent(p, p.indent_len)
-                        p.renderer.add_token(p.renderer.data, RULE)
-                        p.renderer.end_token(p.renderer.data)
-                        clear_root_pending(p)
-                        p.hr_chars = 0
-                        continue
-                    }
-
-                    p.hr_chars = 0
-                }
-
-                /* Unordered list
-                /  * foo
-                /  * *bar*
-                /  * **baz**
-                /*/
-                if ('_' !== p.pending[0] &&
-                    ' ' === p.pending[1]
-                ) {
-                    continue_or_add_list(p, LIST_UNORDERED)
-                    add_list_item(p, 2)
-                    parser_write(p, pending_with_char.slice(2))
-                    continue
-                }
-
-                break // fail
-            /* Code Fence */
-            case '`':
-                /*  ``?
-                      ^
-                */
-                if (p.pending.length < 3) {
-                    if ('`' === char) {
-                        p.pending = pending_with_char
-                        p.fence_start = pending_with_char.length
-                        continue
-                    }
-                    p.fence_start = 0
-                    break // fail
-                }
-
-                switch (char) {
-                case '`':
-                    /*  ````?
-                           ^
-                    */
-                    if (p.pending.length === p.fence_start) {
-                        p.pending = pending_with_char
-                        p.fence_start = pending_with_char.length
-                    }
-                    /*  ```code`
-                               ^
-                    */
-                    else {
-                        add_token(p, PARAGRAPH)
-                        clear_root_pending(p)
-                        p.fence_start = 0
-                        parser_write(p, pending_with_char)
-                    }
-                    continue
-                case '\n': {
-                    /*  ```lang\n
-                                ^
-                    */
-                    end_tokens_to_indent(p, p.indent_len)
-        
-                    add_token(p, CODE_FENCE)
-                    if (p.pending.length > p.fence_start) {
-                        p.renderer.set_attr(p.renderer.data, LANG, p.pending.slice(p.fence_start))
-                    }
-                    clear_root_pending(p)
-                    p.token = NEWLINE
-                    continue
-                }
-                default:
-                    /*  ```lang\n
-                            ^
-                    */
-                    p.pending = pending_with_char
-                    continue
-                }
-            /*
-            List Unordered for '+'
-            The other list types are handled with HORIZONTAL_RULE
-            */
-            case '+':
-                if (' ' !== char) break // fail
-
-                continue_or_add_list(p, LIST_UNORDERED)
-                add_list_item(p, 2)
-                continue
-            /* List Ordered */
-            case '0': case '1': case '2': case '3': case '4':
-            case '5': case '6': case '7': case '8': case '9':
-                /*
-                12. foo
-                   ^
-                */
-                if ('.' === p.pending[p.pending.length-1]) {
-                    if (' ' !== char) break // fail
-
-                    if (continue_or_add_list(p, LIST_ORDERED) && p.pending !== "1.") {
-                        p.renderer.set_attr(p.renderer.data, START, p.pending.slice(0, -1))
-                    }
-                    add_list_item(p, p.pending.length+1)
-                    continue
-                } else {
-                    const char_code = char.charCodeAt(0)
-                    if (46 === char_code || // '.'
-                        is_digit(char_code) // 0-9
-                    ) {
-                        p.pending = pending_with_char
-                        continue
-                    }
-                }
-                break // fail
-            /* Table */
-            case '|':
-                end_tokens_to_len(p, p.blockquote_idx)
-
-                add_token(p, TABLE)
-                add_token(p, TABLE_ROW)
-
-                p.pending = ""
-                parser_write(p, char)
-
-                continue
-            }
-
-            let to_write = pending_with_char
-
-            /* Add a line break and continue in previous token */
-            if (p.token === LINE_BREAK) {
-                p.token = p.tokens[p.len]
-                p.renderer.add_token(p.renderer.data, LINE_BREAK)
-                p.renderer.end_token(p.renderer.data)
-            }
-            /* Code Block */
-            else if (p.indent_len >= 4) {
-                /*
-                Case where there are additional spaces
-                after the indent that makes the code block
-                _________________________
-                       code
-                ^^^^----indent
-                    ^^^-part of code
-                _________________________
-                 \t   code
-                ^^-----indent
-                   ^^^-part of code
-                */
-                let code_start = 0
-                for (; code_start < 4; code_start += 1) {
-                    if (p.indent[code_start] === '\t') {
-                        code_start = code_start+1
-                        break
-                    }
-                }
-                to_write = p.indent.slice(code_start) + pending_with_char
-                add_token(p, CODE_BLOCK)
-            }
-            /* Paragraph */
-            else {
-                add_token(p, PARAGRAPH)
-            }
-
-            clear_root_pending(p)
-            parser_write(p, to_write)
-            continue
-        case TABLE:
-            if (p.table_state === 1) {
-                switch (char) {
-                case '-':
-                case ' ':
-                case '|':
-                case ':':
-                    p.pending = pending_with_char
-                    continue
-                case '\n':
-                    p.table_state = 2
-                    p.pending = ""
-                    continue
-                default:
-                    end_token(p)
-                    p.table_state = 0
-                    break
-                }
-            } else {
-                switch (p.pending) {
-                case "|":
-                    add_token(p, TABLE_ROW)
-                    p.pending = ""
-                    parser_write(p, char)
-                    continue
-                case "\n":
-                    end_token(p)
-                    p.pending = ""
-                    p.table_state = 0
-                    parser_write(p, char)
-                    continue
-                }
-            }
-            break
-        case TABLE_ROW:
-            switch (p.pending) {
-            case "":
-                break
-            case "|":
-                add_token(p, TABLE_CELL)
-                end_token(p)
-                p.pending = ""
-                parser_write(p, char)
-                continue
-            case "\n":
-                end_token(p)
-                p.table_state = Math.min(p.table_state+1, 2)
-                p.pending = ""
-                parser_write(p, char)
-                continue
-            default:
-                add_token(p, TABLE_CELL)
-                parser_write(p, char)
-                continue
-            }
-            break
-        case TABLE_CELL:
-            if (p.pending === "|") {
-                add_text(p)
-                end_token(p)
-                p.pending = ""
-                parser_write(p, char)
-                continue
-            }
-            break
-        case CODE_BLOCK:
-            switch (pending_with_char) {
-            case "\n    ":
-            case "\n   \t":
-            case "\n  \t":
-            case "\n \t":
-            case "\n\t":
-                p.text += "\n"
-                p.pending = ""
-                continue
-            case "\n":
-            case "\n ":
-            case "\n  ":
-            case "\n   ":
-                p.pending = pending_with_char
-                continue
-            default:
-                if (p.pending.length !== 0) {
-                    add_text(p)
-                    end_token(p)
-                    p.pending = char
-                } else {
-                    p.text += char
-                }
-                continue
-            }
-        case CODE_FENCE:
-            switch (char) {
-            case '`':
-                /*  ```\n<code>\n``??
-                |                 ^
-                */
-                p.pending = pending_with_char
-                continue
-            case '\n':
-                /*  ```\n<code>\n```\n
-                |                    ^
-                */
-                if (pending_with_char.length === p.fence_start + p.fence_end + 1) {
-                    add_text(p)
-                    end_token(p)
-                    p.pending = ""
-                    p.fence_start = 0
-                    p.fence_end = 0
-                    p.token = NEWLINE
-                    continue
-                }
-                p.token = NEWLINE
-                break
-            case ' ':
-                /*  ```\n<code>\n ??
-                |                ^  (space after newline is allowed)
-                */
-                if (p.pending[0] === '\n') {
-                    p.pending = pending_with_char
-                    p.fence_end += 1
-                    continue
-                }
-                break
-            }
-            // any other char
-            p.text   += p.pending
-            p.pending = char
-            p.fence_end = 1
-            continue
-        case CODE_INLINE:
-            switch (char) {
-            case '`':
-                if (pending_with_char.length ===
-                    p.fence_start + Number(p.pending[0] === ' ') // 0 or 1 for space
-                ) {
-                    add_text(p)
-                    end_token(p)
-                    p.pending = ""
-                    p.fence_start = 0
-                } else {
-                    p.pending = pending_with_char
-                }
-                continue
-            case '\n':
-                p.text += p.pending
-                p.pending = ""
-                p.token = LINE_BREAK
-                p.blockquote_idx = 0
-                add_text(p)
-                continue
-            /* Trim space before ` */
-            case ' ':
-                p.text += p.pending
-                p.pending = char
-                continue
-            default:
-                p.text += pending_with_char
-                p.pending = ""
-                continue
-            }
-        /* Checkboxes */
-        case MAYBE_TASK:
-            switch (p.pending.length) {
-            case 0:
-                if ('[' !== char) break // fail
-                p.pending = pending_with_char
-                continue
-            case 1:
-                if (' ' !== char && 'x' !== char) break // fail
-                p.pending = pending_with_char
-                continue
-            case 2:
-                if (']' !== char) break // fail
-                p.pending = pending_with_char
-                continue
-            case 3:
-                if (' ' !== char) break // fail
-                p.renderer.add_token(p.renderer.data, CHECKBOX)
-                if ('x' === p.pending[1]) {
-                    p.renderer.set_attr(p.renderer.data, CHECKED, "")
-                }
-                p.renderer.end_token(p.renderer.data)
-                p.pending = " "
-                continue
-            }
-
-            p.token = p.tokens[p.len]
-            p.pending = ""
-            parser_write(p, pending_with_char)
-            continue
-        case STRONG_AST:
-        case STRONG_UND: {
-            /** @type {string} */ let symbol = '*'
-            /** @type {Token } */ let italic = ITALIC_AST
-            if (p.token === STRONG_UND) {
-                symbol = '_'
-                italic = ITALIC_UND
-            }
-
-            if (symbol === p.pending) {
-                add_text(p)
-                /* **Bold**
-                          ^
-                */
-                if (symbol === char) {
-                    end_token(p)
-                    p.pending = ""
-                    continue
-                }
-                /* **Bold*Bold->Em*
-                          ^
-                */
-                add_token(p, italic)
-                p.pending = char
-                continue
-            }
-
-            break
-        }
-        case ITALIC_AST:
-        case ITALIC_UND: {
-            /** @type {string} */ let symbol = '*'
-            /** @type {Token } */ let strong = STRONG_AST
-            if (p.token === ITALIC_UND) {
-                symbol = '_'
-                strong = STRONG_UND
-            }
-
-            switch (p.pending) {
-            case symbol:
-                if (symbol === char) {
-                    /* Decide between ***bold>em**em* and **bold*bold>em***
-                                                 ^                       ^
-                       With the help of the next character
-                    */
-                    if (p.tokens[p.len-1] === strong) {
-                        p.pending = pending_with_char
-                    }
-                    /* *em**bold
-                           ^
-                    */
-                    else {
-                        add_text(p)
-                        add_token(p, strong)
-                        p.pending = ""
-                    }
-                }
-                /* *em*foo
-                       ^
-                */
-                else {
-                    add_text(p)
-                    end_token(p)
-                    p.pending = char
-                }
-                continue
-            case symbol+symbol:
-                const italic = p.token
-                add_text(p)
-                end_token(p)
-                end_token(p)
-                /* ***bold>em**em* or **bold*bold>em***
-                               ^                      ^
-                */
-                if (symbol !== char) {
-                    add_token(p, italic)
-                    p.pending = char
-                } else {
-                    p.pending = ""
-                }
-                continue
-            }
-            break
-        }
-        case STRIKE:
-            if ("~~" === pending_with_char) {
-                add_text(p)
-                end_token(p)
-                p.pending = ""
-                continue
-            }
-            break
-        case MAYBE_EQ_BLOCK:
-            /*
-             \[?  or  $$?
-               ^        ^
-            */
-            if (char === '\n') {
-                add_text(p)
-                add_token(p, EQUATION_BLOCK)
-                p.pending = ""
-            } else {
-                p.token = p.tokens[p.len]
-                if (p.pending[0] === '\\') {
-                    p.text += '['
-                } else {
-                    p.text += '$$'
-                }
-                p.pending = ""
-                parser_write(p, char)
-            }
-            continue
-        case EQUATION_BLOCK:
-            if ("\\]" === pending_with_char || "$$" === pending_with_char) {
-                add_text(p)
-                end_token(p)
-                p.pending = ""
-                continue
-            }
-            break
-        case EQUATION_INLINE:
-            if ("\\)" === pending_with_char || "$" === p.pending[0]) {
-                add_text(p)
-                end_token(p)
-
-                if(char === ')'){
-                    p.pending = ""
-                } else {
-                    p.pending = char
-                }
-                continue
-            }
-            break
-        /* Raw URLs */
-        case MAYBE_URL:
-            if ("http://"  === pending_with_char ||
-                "https://" === pending_with_char
-            ) {
-                add_text(p)
-                add_token(p, RAW_URL)
-                p.pending = pending_with_char
-                p.text    = pending_with_char
-            }
-            else
-            if ("http:/" [p.pending.length] === char ||
-                "https:/"[p.pending.length] === char
-            ) {
-                p.pending = pending_with_char
-            }
-            else {
-                p.token = p.tokens[p.len]
-                parser_write(p, char)
-            }
-            continue
-        case LINK:
-        case IMAGE:
-            if ("]" === p.pending) {
-                /*
-                [Link](url)
-                     ^
-                */
-                add_text(p)
-                if ('(' === char) {
-                    p.pending = pending_with_char
-                } else {
-                    end_token(p)
-                    p.pending = char
-                }
-                continue
-            }
-            if (']' === p.pending[0] &&
-                '(' === p.pending[1]
-            ) {
-                /*
-                [Link](url)
-                          ^
-                */
-                if (')' === char) {
-                    const type = p.token === LINK ? HREF : SRC
-                    const url = p.pending.slice(2)
-                    p.renderer.set_attr(p.renderer.data, type, url)
-                    end_token(p)
-                    p.pending = ""
-                } else {
-                    p.pending += char
-                }
-                continue
-            }
-            break
-        case RAW_URL:
-            /* http://example.com?
-                                 ^
-            */
-            if (' ' === char ||
-                '\n'=== char ||
-                '\\'=== char
-            ) {
-                p.renderer.set_attr(p.renderer.data, HREF, p.pending)
-                add_text(p)
-                end_token(p)
-                p.pending = char
-            } else {
-                p.text   += char
-                p.pending = pending_with_char
-            }
-            continue
-        case MAYBE_BR:
-            if (pending_with_char.startsWith("<br")) {
-                if (/* "<br" */
-                    pending_with_char.length === 3 ||
-                    /* "<br " */
-                    char === ' ' ||
-                    /* "<br/" | "<br /" */
-                    char === '/' && (pending_with_char.length === 4 ||
-                                     p.pending[p.pending.length-1] === ' ')
-                ) {
-                    p.pending = pending_with_char
-                    continue
-                }
-
-                /* "<br>" | "<br/>" */
-                if (char === '>') {
-                    add_text(p)
-                    p.token = p.tokens[p.len]
-                    p.renderer.add_token(p.renderer.data, LINE_BREAK)
-                    p.renderer.end_token(p.renderer.data)
-                    p.pending = ""
-                    continue
-                }
-            }
-            // Fail
-            p.token = p.tokens[p.len]
-            p.text += '<'
-            p.pending = p.pending.slice(1)
-            parser_write(p, char)
-            continue
-        }
-
-        /*
-        Common checks
-        */
-        switch (p.pending[0]) {
-        /* Escape character */
-        case '\\':
-            if (p.token === IMAGE ||
-                p.token === EQUATION_BLOCK ||
-                p.token === EQUATION_INLINE)
-                break
-
-            switch (char) {
-            case '(':
-                add_text(p)
-                add_token(p, EQUATION_INLINE)
-                p.pending = ""
-                continue
-            case '[':
-                p.token = MAYBE_EQ_BLOCK
-                p.pending = pending_with_char
-                continue
-            case '\n':
-                // Escaped newline has the same affect as unescaped one
-                p.pending = char
-                continue
-            default:
-                let charcode = char.charCodeAt(0)
-                p.pending = ""
-                p.text += is_digit(charcode)                 || // 0-9
-                          (charcode >= 65 && charcode <= 90) || // A-Z
-                          (charcode >= 97 && charcode <= 122)   // a-z
-                            ? pending_with_char
-                            : char
-                continue
-            }
-        /* Newline */
-        case '\n':
-            switch (p.token) {
-            case IMAGE:
-            case EQUATION_BLOCK:
-            case EQUATION_INLINE:
-                break
-            case HEADING_1:
-            case HEADING_2:
-            case HEADING_3:
-            case HEADING_4:
-            case HEADING_5:
-            case HEADING_6:
-                add_text(p)
-                end_tokens_to_len(p, p.blockquote_idx)
-                p.blockquote_idx = 0
-                p.pending = char
-                continue
-            default:
-                add_text(p)
-                p.pending = char
-                p.token = LINE_BREAK
-                p.blockquote_idx = 0
-                continue
-            }
-            break
-        /* <br> */
-        case '<':
-            if (p.token !== IMAGE &&
-                p.token !== EQUATION_BLOCK &&
-                p.token !== EQUATION_INLINE
-            ) {
-                add_text(p)
-                p.pending = pending_with_char
-                p.token = MAYBE_BR
-                continue
-            }
-            break
-        /* `Code Inline` */
-        case '`':
-            if (p.token === IMAGE) break
-
-            if ('`' === char) {
-                p.fence_start += 1
-                p.pending = pending_with_char
-            } else {
-                p.fence_start += 1 // started at 0, and first wasn't counted
-                add_text(p)
-                add_token(p, CODE_INLINE)
-                p.text = ' ' === char || '\n' === char ? "" : char // trim leading space
-                p.pending = ""
-            }
-            continue
-        case '_':
-        case '*': {
-            if (p.token === IMAGE ||
-                p.token === EQUATION_BLOCK ||
-                p.token === EQUATION_INLINE ||
-                p.token === STRONG_AST)
-             break
-
-            /** @type {Token} */ let italic = ITALIC_AST
-            /** @type {Token} */ let strong = STRONG_AST
-            const symbol = p.pending[0]
-            if ('_' === symbol) {
-                italic = ITALIC_UND
-                strong = STRONG_UND
-            }
-
-            if (p.pending.length === 1) {
-                /* **Strong**
-                    ^
-                */
-                if (symbol === char) {
-                    p.pending = pending_with_char
-                    continue
-                }
-                /* *Em*
-                    ^
-                */
-                if (' ' !== char && '\n' !== char) {
-                    add_text(p)
-                    add_token(p, italic)
-                    p.pending = char
-                    continue
-                }
-            } else {
-                /* ***Strong->Em***
-                     ^
-                */
-                if (symbol === char) {
-                    add_text(p)
-                    add_token(p, strong)
-                    add_token(p, italic)
-                    p.pending = ""
-                    continue
-                }
-                /* **Strong**
-                     ^
-                */
-                if (' ' !== char && '\n' !== char) {
-                    add_text(p)
-                    add_token(p, strong)
-                    p.pending = char
-                    continue
-                }
-            }
-
-            break
-        }
-        case '~':
-            if (p.token !== IMAGE &&
-                p.token !== STRIKE
-            ) {
-                if ("~" === p.pending) {
-                    /* ~~Strike~~
-                        ^
-                    */
-                    if ('~' === char) {
-                        p.pending = pending_with_char
-                        continue
-                    }
-                } else {
-                    /* ~~Strike~~
-                    |    ^
-                    */
-                    if (' ' !== char && '\n' !== char) {
-                        add_text(p)
-                        add_token(p, STRIKE)
-                        p.pending = char
-                        continue
-                    }
-                }
-            }
-            break
-        /* $eq$ | $$eq$$ */
-        case '$':
-            if (p.token !== IMAGE &&
-                p.token !== STRIKE &&
-                "$" === p.pending
-            ) {
-                /* $$EQUATION_BLOCK$$
-                    ^
-                */
-                if ('$' === char) {
-                    p.token = MAYBE_EQ_BLOCK
-                    p.pending = pending_with_char
-                    continue
-                }
-                /* $123
-                    ^
-                */
-                else if (is_delimeter_or_number(char.charCodeAt(0))) {
-                    break
-                }
-                /* $EQUATION_INLINE$
-                    ^
-                */
-                else {
-                    add_text(p)
-                    add_token(p, EQUATION_INLINE)
-                    p.pending = char
-                    continue
-                }
-            }
-            break
-        /* [Image](url) */
-        case '[':
-            if (p.token !== IMAGE &&
-                p.token !== LINK &&
-                p.token !== EQUATION_BLOCK &&
-                p.token !== EQUATION_INLINE &&
-                ']' !== char
-            ) {
-                add_text(p)
-                add_token(p, LINK)
-                p.pending = char
-                continue
-            }
-            break
-        /* ![Image](url) */
-        case '!':
-            if (!(p.token === IMAGE) &&
-                '[' === char
-            ) {
-                add_text(p)
-                add_token(p, IMAGE)
-                p.pending = ""
-                continue
-            }
-            break
-        /* Trim spaces */
-        case ' ':
-            if (p.pending.length === 1 && ' ' === char) {
-                continue
-            }
-            break
-        }
-
-        /* foo http://...
-        |      ^
-        */
-        if (p.token !== IMAGE &&
-            p.token !== LINK &&
-            p.token !== EQUATION_BLOCK &&
-            p.token !== EQUATION_INLINE &&
-            'h' === char &&
-           (" " === p.pending ||
-            ""  === p.pending)
-        ) {
-            p.text   += p.pending
-            p.pending = char
-
-            p.token = MAYBE_URL
-            continue
-        }
-
-        /*
-        No check hit
-        */
-        p.text += p.pending
-        p.pending = char
-    }
-
-    add_text(p)
-}
-
-
-/**
- * @template T
- * @callback Renderer_Add_Token
- * @param   {T    } data
- * @param   {Token} type
- * @returns {void } */
-
-/**
- * @template T
- * @callback Renderer_End_Token
- * @param   {T    } data
- * @returns {void } */
-
-/**
- * @template T
- * @callback Renderer_Add_Text
- * @param   {T     } data
- * @param   {string} text
- * @returns {void  } */
-
-/**
- * @template T
- * @callback Renderer_Set_Attr
- * @param   {T     } data
- * @param   {Attr  } type
- * @param   {string} value
- * @returns {void  } */
-
-/**
- * The renderer interface.
- * @template T
- * @typedef  {object               } Renderer
- * @property {T                    } data      User data object. Available as first param in callbacks.
- * @property {Renderer_Add_Token<T>} add_token When the tokens starts.
- * @property {Renderer_End_Token<T>} end_token When the token ends.
- * @property {Renderer_Add_Text <T>} add_text  To append text to current token. Can be called multiple times or none.
- * @property {Renderer_Set_Attr <T>} set_attr  Set additional attributes of current token eg. the link url.
- */
-
-/** @typedef {Renderer<any>} Any_Renderer */
-
-
-/**
- * @typedef  {object} Default_Renderer_Data
- * @property {HTMLElement[]} nodes
- * @property {number       } index
- *
- * @typedef {Renderer          <Default_Renderer_Data>} Default_Renderer
- * @typedef {Renderer_Add_Token<Default_Renderer_Data>} Default_Renderer_Add_Token
- * @typedef {Renderer_End_Token<Default_Renderer_Data>} Default_Renderer_End_Token
- * @typedef {Renderer_Add_Text <Default_Renderer_Data>} Default_Renderer_Add_Text
- * @typedef {Renderer_Set_Attr <Default_Renderer_Data>} Default_Renderer_Set_Attr
- */
-
-/**
- * @param   {HTMLElement     } root
- * @returns {Default_Renderer} */
-export function default_renderer(root) {
-    return {
-        add_token: default_add_token,
-        end_token: default_end_token,
-        add_text:  default_add_text,
-        set_attr:  default_set_attr,
-        data    : {
-            nodes: /**@type {*}*/([root,,,,,]),
-            index: 0,
-        },
-    }
-}
-
-/** @type {Default_Renderer_Add_Token} */
-export function default_add_token(data, type) {
-
-    /**@type {Element}*/ let parent = data.nodes[data.index]
-
-    /**@type {HTMLElement}*/ let slot
-
-    switch (type) {
-    case DOCUMENT: return // document is provided
-    case BLOCKQUOTE:    slot = document.createElement("blockquote");break
-    case PARAGRAPH:     slot = document.createElement("p")         ;break
-    case LINE_BREAK:    slot = document.createElement("br")        ;break
-    case RULE:          slot = document.createElement("hr")        ;break
-    case HEADING_1:     slot = document.createElement("h1")        ;break
-    case HEADING_2:     slot = document.createElement("h2")        ;break
-    case HEADING_3:     slot = document.createElement("h3")        ;break
-    case HEADING_4:     slot = document.createElement("h4")        ;break
-    case HEADING_5:     slot = document.createElement("h5")        ;break
-    case HEADING_6:     slot = document.createElement("h6")        ;break
-    case ITALIC_AST:
-    case ITALIC_UND:    slot = document.createElement("em")        ;break
-    case STRONG_AST:
-    case STRONG_UND:    slot = document.createElement("strong")    ;break
-    case STRIKE:        slot = document.createElement("s")         ;break
-    case CODE_INLINE:   slot = document.createElement("code")      ;break
-    case RAW_URL:
-    case LINK:          slot = document.createElement("a")         ;break
-    case IMAGE:         slot = document.createElement("img")       ;break
-    case LIST_UNORDERED:slot = document.createElement("ul")        ;break
-    case LIST_ORDERED:  slot = document.createElement("ol")        ;break
-    case LIST_ITEM:     slot = document.createElement("li")        ;break
-    case CHECKBOX:
-        let checkbox = slot = document.createElement("input")
-        checkbox.type = "checkbox"
-        checkbox.disabled = true
-        break
-    case CODE_BLOCK:
-    case CODE_FENCE:
-        parent = parent.appendChild(document.createElement("pre"))
-        slot   = document.createElement("code")
-        break
-    case TABLE:
-        slot = document.createElement("table")
-        break
-    case TABLE_ROW:
-        switch (parent.children.length) {
-        case 0:
-            parent = parent.appendChild(document.createElement("thead"))
-            break
-        case 1:
-            parent = parent.appendChild(document.createElement("tbody"))
-            break
-        default:
-            parent = parent.children[1]
-        }
-        slot = document.createElement("tr")
-        break
-    case TABLE_CELL:
-        slot = document.createElement(parent.parentElement?.tagName === "THEAD" ? "th" : "td")
-        break
-    case EQUATION_BLOCK:  slot = document.createElement("equation-block"); break
-    case EQUATION_INLINE: slot = document.createElement("equation-inline"); break
-    }
-
-    data.nodes[++data.index] = parent.appendChild(slot)
-}
-
-/** @type {Default_Renderer_End_Token} */
-export function default_end_token(data) {
-    data.index -= 1
-}
-
-/** @type {Default_Renderer_Add_Text} */
-export function default_add_text(data, text) {
-    data.nodes[data.index].appendChild(document.createTextNode(text))
-}
-
-/** @type {Default_Renderer_Set_Attr} */
-export function default_set_attr(data, type, value) {
-    data.nodes[data.index].setAttribute(attr_to_html_attr(type), value)
-}
-
-
-/**
- * @typedef {undefined} Logger_Renderer_Data
- *
- * @typedef {Renderer          <Logger_Renderer_Data>} Logger_Renderer
- * @typedef {Renderer_Add_Token<Logger_Renderer_Data>} Logger_Renderer_Add_Token
- * @typedef {Renderer_End_Token<Logger_Renderer_Data>} Logger_Renderer_End_Token
- * @typedef {Renderer_Add_Text <Logger_Renderer_Data>} Logger_Renderer_Add_Text
- * @typedef {Renderer_Set_Attr <Logger_Renderer_Data>} Logger_Renderer_Set_Attr
- */
-
-/** @returns {Logger_Renderer} */
-export function logger_renderer() {
-    return {
-        data:      undefined,
-        add_token: logger_add_token,
-        end_token: logger_end_token,
-        add_text:  logger_add_text,
-        set_attr:  logger_set_attr,
-    }
-}
-
-/** @type {Logger_Renderer_Add_Token} */
-export function logger_add_token(data, type) {
-    console.log("add_token:", token_to_string(type))
-}
-
-/** @type {Logger_Renderer_End_Token} */
-export function logger_end_token(data) {
-    console.log("end_token")
-}
-
-/** @type {Logger_Renderer_Add_Text} */
-export function logger_add_text(data, text) {
-    console.log('add_text: "%s"', text)
-}
-
-/** @type {Logger_Renderer_Set_Attr} */
-export function logger_set_attr(data, type, value) {
-    console.log('set_attr: %s="%s"', attr_to_html_attr(type), value)
-}
+export const DOCUMENT=1,PARAGRAPH=2,HEADING_1=3,HEADING_2=4,HEADING_3=5,HEADING_4=6,HEADING_5=7,HEADING_6=8,CODE_BLOCK=9,CODE_FENCE=10,CODE_INLINE=11,ITALIC_AST=12,ITALIC_UND=13,STRONG_AST=14,STRONG_UND=15,STRIKE=16,LINK=17,RAW_URL=18,IMAGE=19,BLOCKQUOTE=20,LINE_BREAK=21,RULE=22,LIST_UNORDERED=23,LIST_ORDERED=24,LIST_ITEM=25,CHECKBOX=26,TABLE=27,TABLE_ROW=28,TABLE_CELL=29,EQUATION_BLOCK=30,EQUATION_INLINE=31,NEWLINE=101,MAYBE_URL=102,MAYBE_TASK=103,MAYBE_BR=104,MAYBE_EQ_BLOCK=105,Token={Document:1,Blockquote:20,Paragraph:2,Heading_1:3,Heading_2:4,Heading_3:5,Heading_4:6,Heading_5:7,Heading_6:8,Code_Block:9,Code_Fence:10,Code_Inline:11,Italic_Ast:12,Italic_Und:13,Strong_Ast:14,Strong_Und:15,Strike:16,Link:17,Raw_URL:18,Image:19,Line_Break:21,Rule:22,List_Unordered:23,List_Ordered:24,List_Item:25,Checkbox:26,Table:27,Table_Row:28,Table_Cell:29,Equation_Block:30,Equation_Inline:31};export function token_to_string(e){switch(e){case 1:return"Document";case 20:return"Blockquote";case 2:return"Paragraph";case 3:return"Heading_1";case 4:return"Heading_2";case 5:return"Heading_3";case 6:return"Heading_4";case 7:return"Heading_5";case 8:return"Heading_6";case 9:return"Code_Block";case 10:return"Code_Fence";case 11:return"Code_Inline";case 12:return"Italic_Ast";case 13:return"Italic_Und";case 14:return"Strong_Ast";case 15:return"Strong_Und";case 16:return"Strike";case 17:return"Link";case 18:return"Raw URL";case 19:return"Image";case 21:return"Line_Break";case 22:return"Rule";case 23:return"List_Unordered";case 24:return"List_Ordered";case 25:return"List_Item";case 26:return"Checkbox";case 27:return"Table";case 28:return"Table_Row";case 29:return"Table_Cell";case 30:return"Equation_Block";case 31:return"Equation_Inline"}}export const HREF=1,SRC=2,LANG=4,CHECKED=8,START=16,Attr={Href:HREF,Src:SRC,Lang:LANG,Checked:CHECKED,Start:START};export function attr_to_html_attr(e){switch(e){case HREF:return"href";case SRC:return"src";case LANG:return"class";case CHECKED:return"checked";case START:return"start"}}export const level_to_heading=e=>{switch(e){case 1:return 3;case 2:return 4;case 3:return 5;case 4:return 6;case 5:return 7;default:return 8}},heading_from_level=level_to_heading,heading_to_level=e=>{switch(e){case 3:return 1;case 4:return 2;case 5:return 3;case 6:return 4;case 7:return 5;case 8:return 6;default:return 0}};const A=24;export function parser(e){const c=new Uint32Array(A);return c[0]=1,{renderer:e,text:"",pending:"",tokens:c,len:0,token:1,fence_end:0,blockquote_idx:0,hr_char:"",hr_chars:0,fence_start:0,spaces:new Uint8Array(A),indent:"",indent_len:0,table_state:0}}export function parser_end(e){e.pending.length>0&&parser_write(e,`
+`)}function a(e){e.text.length!==0&&(console.assert(e.len>0,"Never adding text to root"),e.renderer.add_text(e.renderer.data,e.text),e.text="")}function N(e){switch(e.token){case 21:case 1:case 20:case 24:case 23:i(e,2)}}function O(e,c){N(e),e.text+=c}function o(e){console.assert(e.len>0,"No nodes to end"),e.len-=1,e.token=e.tokens[e.len],e.renderer.end_token(e.renderer.data)}function i(e,c){(e.tokens[e.len]===24||e.tokens[e.len]===23)&&c!==25&&o(e),e.len+=1,e.tokens[e.len]=c,e.token=c,e.renderer.add_token(e.renderer.data,c)}function L(e,c,n){for(;n<=e.len;){if(e.tokens[n]===c)return n;n+=1}return-1}function E(e,c){for(e.fence_start=0;e.len>c;)o(e)}function l(e,c){let n=0;for(let t=0;t<=e.len&&(c-=e.spaces[t],!(c<0));t+=1)switch(e.tokens[t]){case 9:case 10:case 20:case 25:n=t;break}for(;e.len>n;)o(e);return c}function I(e,c){let n=-1,t=-1;for(let s=e.blockquote_idx+1;s<=e.len;s+=1)if(e.tokens[s]===25){if(e.indent_len<e.spaces[s]){t=-1;break}t=s}else e.tokens[s]===c&&(n=s);return t===-1?n===-1?(E(e,e.blockquote_idx),i(e,c),!0):(E(e,n),!1):(E(e,t),i(e,c),!0)}function g(e,c){i(e,25),e.spaces[e.len]=e.indent_len+c,_(e),e.token=103}function _(e){e.indent="",e.indent_len=0,e.pending=""}function u(e){switch(e){case 48:case 49:case 50:case 51:case 52:case 53:case 54:case 55:case 56:case 57:return!0;default:return!1}}function f(e){switch(e){case 32:case 58:case 59:case 41:case 44:case 33:case 46:case 63:case 93:case 10:return!0;default:return!1}}function T(e){return u(e)||f(e)}function R(e){return u(e)||e>=65&&e<=90||e>=97&&e<=122}export function parser_write(e,c){for(const n of c){if(e.token===101){switch(n){case" ":e.indent_len+=1;continue;case"	":e.indent_len+=4;continue}let s=l(e,e.indent_len);e.indent_len=0,e.token=e.tokens[e.len],s>0&&parser_write(e," ".repeat(s))}const t=e.pending+n;switch(e.token){case 21:case 1:case 20:case 24:case 23:switch(console.assert(e.text.length===0,"Root should not have any text"),e.pending[0]){case void 0:e.pending=n;continue;case" ":console.assert(e.pending.length===1),e.pending=n,e.indent+=" ",e.indent_len+=1;continue;case"	":console.assert(e.pending.length===1),e.pending=n,e.indent+="	",e.indent_len+=4;continue;case`
+`:if(console.assert(e.pending.length===1),e.tokens[e.len]===25&&e.token===21){o(e),_(e),e.pending=n;continue}E(e,e.blockquote_idx),_(e),e.blockquote_idx=0,e.fence_start=0,e.pending=n;continue;case"#":switch(n){case"#":if(e.pending.length<6){e.pending=t;continue}break;case" ":l(e,e.indent_len),i(e,heading_from_level(e.pending.length)),_(e);continue}break;case">":{const r=L(e,20,e.blockquote_idx+1);r===-1?(E(e,e.blockquote_idx),e.blockquote_idx+=1,e.fence_start=0,i(e,20)):e.blockquote_idx=r,_(e),e.pending=n;continue}case"-":case"*":case"_":if(e.hr_chars===0&&(console.assert(e.pending.length===1,"Pending should be one character"),e.hr_chars=1,e.hr_char=e.pending),e.hr_chars>0){switch(n){case e.hr_char:e.hr_chars+=1,e.pending=t;continue;case" ":e.pending=t;continue;case`
+`:if(e.hr_chars<3)break;l(e,e.indent_len),e.renderer.add_token(e.renderer.data,22),e.renderer.end_token(e.renderer.data),_(e),e.hr_chars=0;continue}e.hr_chars=0}if(e.pending[0]!=="_"&&e.pending[1]===" "){I(e,23),g(e,2),parser_write(e,t.slice(2));continue}break;case"`":if(e.pending.length<3){if(n==="`"){e.pending=t,e.fence_start=t.length;continue}e.fence_start=0;break}switch(n){case"`":e.pending.length===e.fence_start?(e.pending=t,e.fence_start=t.length):(i(e,2),_(e),e.fence_start=0,parser_write(e,t));continue;case`
+`:{l(e,e.indent_len),i(e,10),e.pending.length>e.fence_start&&e.renderer.set_attr(e.renderer.data,LANG,e.pending.slice(e.fence_start)),_(e),e.token=101;continue}default:e.pending=t;continue}case"+":if(n!==" ")break;I(e,23),g(e,2);continue;case"0":case"1":case"2":case"3":case"4":case"5":case"6":case"7":case"8":case"9":if(e.pending[e.pending.length-1]==="."){if(n!==" ")break;I(e,24)&&e.pending!=="1."&&e.renderer.set_attr(e.renderer.data,START,e.pending.slice(0,-1)),g(e,e.pending.length+1);continue}else{const r=n.charCodeAt(0);if(r===46||u(r)){e.pending=t;continue}}break;case"|":E(e,e.blockquote_idx),i(e,27),i(e,28),e.pending="",parser_write(e,n);continue}let s=t;if(e.token===21)e.token=e.tokens[e.len],e.renderer.add_token(e.renderer.data,21),e.renderer.end_token(e.renderer.data);else if(e.indent_len>=4){let r=0;for(;r<4;r+=1)if(e.indent[r]==="	"){r=r+1;break}s=e.indent.slice(r)+t,i(e,9)}else i(e,2);_(e),parser_write(e,s);continue;case 27:if(e.table_state===1)switch(n){case"-":case" ":case"|":case":":e.pending=t;continue;case`
+`:e.table_state=2,e.pending="";continue;default:o(e),e.table_state=0;break}else switch(e.pending){case"|":i(e,28),e.pending="",parser_write(e,n);continue;case`
+`:o(e),e.pending="",e.table_state=0,parser_write(e,n);continue}break;case 28:switch(e.pending){case"":break;case"|":i(e,29),o(e),e.pending="",parser_write(e,n);continue;case`
+`:o(e),e.table_state=Math.min(e.table_state+1,2),e.pending="",parser_write(e,n);continue;default:i(e,29),parser_write(e,n);continue}break;case 29:if(e.pending==="|"){a(e),o(e),e.pending="",parser_write(e,n);continue}break;case 9:switch(t){case`
+    `:case`
+   	`:case`
+  	`:case`
+ 	`:case`
+	`:e.text+=`
+`,e.pending="";continue;case`
+`:case`
+ `:case`
+  `:case`
+   `:e.pending=t;continue;default:e.pending.length!==0?(a(e),o(e),e.pending=n):e.text+=n;continue}case 10:switch(n){case"`":e.pending=t;continue;case`
+`:if(t.length===e.fence_start+e.fence_end+1){a(e),o(e),e.pending="",e.fence_start=0,e.fence_end=0,e.token=101;continue}e.token=101;break;case" ":if(e.pending[0]===`
+`){e.pending=t,e.fence_end+=1;continue}break}e.text+=e.pending,e.pending=n,e.fence_end=1;continue;case 11:switch(n){case"`":t.length===e.fence_start+ +(e.pending[0]===" ")?(a(e),o(e),e.pending="",e.fence_start=0):e.pending=t;continue;case`
+`:e.text+=e.pending,e.pending="",e.token=21,e.blockquote_idx=0,a(e);continue;case" ":e.text+=e.pending,e.pending=n;continue;default:e.text+=t,e.pending="";continue}case 103:switch(e.pending.length){case 0:if(n!=="[")break;e.pending=t;continue;case 1:if(n!==" "&&n!=="x")break;e.pending=t;continue;case 2:if(n!=="]")break;e.pending=t;continue;case 3:if(n!==" ")break;e.renderer.add_token(e.renderer.data,26),e.pending[1]==="x"&&e.renderer.set_attr(e.renderer.data,CHECKED,""),e.renderer.end_token(e.renderer.data),e.pending=" ";continue}e.token=e.tokens[e.len],e.pending="",parser_write(e,t);continue;case 14:case 15:{let r="*",d=12;if(e.token===15&&(r="_",d=13),r===e.pending){if(a(e),r===n){o(e),e.pending="";continue}i(e,d),e.pending=n;continue}break}case 12:case 13:{let r="*",d=14;switch(e.token===13&&(r="_",d=15),e.pending){case r:r===n?e.tokens[e.len-1]===d?e.pending=t:(a(e),i(e,d),e.pending=""):(a(e),o(e),e.pending=n);continue;case r+r:const k=e.token;a(e),o(e),o(e),r!==n?(i(e,k),e.pending=n):e.pending="";continue}break}case 16:if(t==="~~"){a(e),o(e),e.pending="";continue}break;case 105:n===`
+`?(a(e),i(e,30),e.pending=""):(e.token=e.tokens[e.len],e.pending[0]==="\\"?e.text+="[":e.text+="$$",e.pending="",parser_write(e,n));continue;case 30:if(t==="\\]"||t==="$$"){a(e),o(e),e.pending="";continue}break;case 31:if(t==="\\)"||e.pending[0]==="$"){a(e),o(e),n===")"?e.pending="":e.pending=n;continue}break;case 102:t==="http://"||t==="https://"?(a(e),i(e,18),e.pending=t,e.text=t):"http:/"[e.pending.length]===n||"https:/"[e.pending.length]===n?e.pending=t:(e.token=e.tokens[e.len],parser_write(e,n));continue;case 17:case 19:if(e.pending==="]"){a(e),n==="("?e.pending=t:(o(e),e.pending=n);continue}if(e.pending[0]==="]"&&e.pending[1]==="("){if(n===")"){const r=e.token===17?HREF:SRC,d=e.pending.slice(2);e.renderer.set_attr(e.renderer.data,r,d),o(e),e.pending=""}else e.pending+=n;continue}break;case 18:n===" "||n===`
+`||n==="\\"?(e.renderer.set_attr(e.renderer.data,HREF,e.pending),a(e),o(e),e.pending=n):(e.text+=n,e.pending=t);continue;case 104:if(t.startsWith("<br")){if(t.length===3||n===" "||n==="/"&&(t.length===4||e.pending[e.pending.length-1]===" ")){e.pending=t;continue}if(n===">"){a(e),e.token=e.tokens[e.len],e.renderer.add_token(e.renderer.data,21),e.renderer.end_token(e.renderer.data),e.pending="";continue}}e.token=e.tokens[e.len],e.text+="<",e.pending=e.pending.slice(1),parser_write(e,n);continue}switch(e.pending[0]){case"\\":if(e.token===19||e.token===30||e.token===31)break;switch(n){case"(":a(e),i(e,31),e.pending="";continue;case"[":e.token=105,e.pending=t;continue;case`
+`:e.pending=n;continue;default:let s=n.charCodeAt(0);e.pending="",e.text+=u(s)||s>=65&&s<=90||s>=97&&s<=122?t:n;continue}case`
+`:switch(e.token){case 19:case 30:case 31:break;case 3:case 4:case 5:case 6:case 7:case 8:a(e),E(e,e.blockquote_idx),e.blockquote_idx=0,e.pending=n;continue;default:a(e),e.pending=n,e.token=21,e.blockquote_idx=0;continue}break;case"<":if(e.token!==19&&e.token!==30&&e.token!==31){a(e),e.pending=t,e.token=104;continue}break;case"`":if(e.token===19)break;n==="`"?(e.fence_start+=1,e.pending=t):(e.fence_start+=1,a(e),i(e,11),e.text=n===" "||n===`
+`?"":n,e.pending="");continue;case"_":case"*":{if(e.token===19||e.token===30||e.token===31||e.token===14)break;let s=12,r=14;const d=e.pending[0];if(d==="_"&&(s=13,r=15),e.pending.length===1){if(d===n){e.pending=t;continue}if(n!==" "&&n!==`
+`){a(e),i(e,s),e.pending=n;continue}}else{if(d===n){a(e),i(e,r),i(e,s),e.pending="";continue}if(n!==" "&&n!==`
+`){a(e),i(e,r),e.pending=n;continue}}break}case"~":if(e.token!==19&&e.token!==16){if(e.pending==="~"){if(n==="~"){e.pending=t;continue}}else if(n!==" "&&n!==`
+`){a(e),i(e,16),e.pending=n;continue}}break;case"$":if(e.token!==19&&e.token!==16&&e.pending==="$")if(n==="$"){e.token=105,e.pending=t;continue}else{if(T(n.charCodeAt(0)))break;a(e),i(e,31),e.pending=n;continue}break;case"[":if(e.token!==19&&e.token!==17&&e.token!==30&&e.token!==31&&n!=="]"){a(e),i(e,17),e.pending=n;continue}break;case"!":if(e.token!==19&&n==="["){a(e),i(e,19),e.pending="";continue}break;case" ":if(e.pending.length===1&&n===" ")continue;break}if(e.token!==19&&e.token!==17&&e.token!==30&&e.token!==31&&n==="h"&&(e.pending===" "||e.pending==="")){e.text+=e.pending,e.pending=n,e.token=102;continue}e.text+=e.pending,e.pending=n}a(e)}export function default_renderer(e){return{add_token:default_add_token,end_token:default_end_token,add_text:default_add_text,set_attr:default_set_attr,data:{nodes:[e,,,,,],index:0}}}export function default_add_token(e,c){let n=e.nodes[e.index],t;switch(c){case 1:return;case 20:t=document.createElement("blockquote");break;case 2:t=document.createElement("p");break;case 21:t=document.createElement("br");break;case 22:t=document.createElement("hr");break;case 3:t=document.createElement("h1");break;case 4:t=document.createElement("h2");break;case 5:t=document.createElement("h3");break;case 6:t=document.createElement("h4");break;case 7:t=document.createElement("h5");break;case 8:t=document.createElement("h6");break;case 12:case 13:t=document.createElement("em");break;case 14:case 15:t=document.createElement("strong");break;case 16:t=document.createElement("s");break;case 11:t=document.createElement("code");break;case 18:case 17:t=document.createElement("a");break;case 19:t=document.createElement("img");break;case 23:t=document.createElement("ul");break;case 24:t=document.createElement("ol");break;case 25:t=document.createElement("li");break;case 26:let s=t=document.createElement("input");s.type="checkbox",s.disabled=!0;break;case 9:case 10:n=n.appendChild(document.createElement("pre")),t=document.createElement("code");break;case 27:t=document.createElement("table");break;case 28:switch(n.children.length){case 0:n=n.appendChild(document.createElement("thead"));break;case 1:n=n.appendChild(document.createElement("tbody"));break;default:n=n.children[1]}t=document.createElement("tr");break;case 29:t=document.createElement(n.parentElement?.tagName==="THEAD"?"th":"td");break;case 30:t=document.createElement("equation-block");break;case 31:t=document.createElement("equation-inline");break}e.nodes[++e.index]=n.appendChild(t)}export function default_end_token(e){e.index-=1}export function default_add_text(e,c){e.nodes[e.index].appendChild(document.createTextNode(c))}export function default_set_attr(e,c,n){e.nodes[e.index].setAttribute(attr_to_html_attr(c),n)}export function logger_renderer(){return{data:void 0,add_token:logger_add_token,end_token:logger_end_token,add_text:logger_add_text,set_attr:logger_set_attr}}export function logger_add_token(e,c){console.log("add_token:",token_to_string(c))}export function logger_end_token(e){console.log("end_token")}export function logger_add_text(e,c){console.log('add_text: "%s"',c)}export function logger_set_attr(e,c,n){console.log('set_attr: %s="%s"',attr_to_html_attr(c),n)}