{"version":3,"file":"index.cjs","sources":["../index.tsx","../index.cjs.tsx"],"sourcesContent":["/* @jsx h */\n/**\n * markdown-to-jsx is a fork of\n * [simple-markdown v0.2.2](https://github.com/Khan/simple-markdown)\n * from Khan Academy. Thank you Khan devs for making such an awesome\n * and extensible parsing infra... without it, half of the\n * optimizations here wouldn't be feasible. 🙏🏼\n */\nimport * as React from 'react'\n\n/**\n * Analogous to `node.type`. Please note that the values here may change at any time,\n * so do not hard code against the value directly.\n */\nexport const RuleType = {\n  blockQuote: '0',\n  breakLine: '1',\n  breakThematic: '2',\n  codeBlock: '3',\n  codeFenced: '4',\n  codeInline: '5',\n  footnote: '6',\n  footnoteReference: '7',\n  gfmTask: '8',\n  heading: '9',\n  headingSetext: '10',\n  /** only available if not `disableHTMLParsing` */\n  htmlBlock: '11',\n  htmlComment: '12',\n  /** only available if not `disableHTMLParsing` */\n  htmlSelfClosing: '13',\n  image: '14',\n  link: '15',\n  /** emits a `link` 'node', does not render directly */\n  linkAngleBraceStyleDetector: '16',\n  /** emits a `link` 'node', does not render directly */\n  linkBareUrlDetector: '17',\n  /** emits a `link` 'node', does not render directly */\n  linkMailtoDetector: '18',\n  newlineCoalescer: '19',\n  orderedList: '20',\n  paragraph: '21',\n  ref: '22',\n  refImage: '23',\n  refLink: '24',\n  table: '25',\n  tableSeparator: '26',\n  text: '27',\n  textBolded: '28',\n  textEmphasized: '29',\n  textEscaped: '30',\n  textMarked: '31',\n  textStrikethroughed: '32',\n  unorderedList: '33',\n} as const\n\nif (process.env.NODE_ENV !== 'production') {\n  Object.keys(RuleType).forEach(key => (RuleType[key] = key))\n}\n\nexport type RuleType = (typeof RuleType)[keyof typeof RuleType]\n\nconst enum Priority {\n  /**\n   * anything that must scan the tree before everything else\n   */\n  MAX,\n  /**\n   * scans for block-level constructs\n   */\n  HIGH,\n  /**\n   * inline w/ more priority than other inline\n   */\n  MED,\n  /**\n   * inline elements\n   */\n  LOW,\n  /**\n   * bare text and stuff that is considered leftovers\n   */\n  MIN,\n}\n\n/** TODO: Drop for React 16? */\nconst ATTRIBUTE_TO_JSX_PROP_MAP = [\n  'allowFullScreen',\n  'allowTransparency',\n  'autoComplete',\n  'autoFocus',\n  'autoPlay',\n  'cellPadding',\n  'cellSpacing',\n  'charSet',\n  'classId',\n  'colSpan',\n  'contentEditable',\n  'contextMenu',\n  'crossOrigin',\n  'encType',\n  'formAction',\n  'formEncType',\n  'formMethod',\n  'formNoValidate',\n  'formTarget',\n  'frameBorder',\n  'hrefLang',\n  'inputMode',\n  'keyParams',\n  'keyType',\n  'marginHeight',\n  'marginWidth',\n  'maxLength',\n  'mediaGroup',\n  'minLength',\n  'noValidate',\n  'radioGroup',\n  'readOnly',\n  'rowSpan',\n  'spellCheck',\n  'srcDoc',\n  'srcLang',\n  'srcSet',\n  'tabIndex',\n  'useMap',\n].reduce(\n  (obj, x) => {\n    obj[x.toLowerCase()] = x\n    return obj\n  },\n  { class: 'className', for: 'htmlFor' }\n)\n\nconst namedCodesToUnicode = {\n  amp: '\\u0026',\n  apos: '\\u0027',\n  gt: '\\u003e',\n  lt: '\\u003c',\n  nbsp: '\\u00a0',\n  quot: '\\u201c',\n} as const\n\nconst DO_NOT_PROCESS_HTML_ELEMENTS = ['style', 'script']\nconst ATTRIBUTES_TO_SANITIZE = [\n  'src',\n  'href',\n  'data',\n  'formAction',\n  'srcDoc',\n  'action',\n]\n\n/**\n * the attribute extractor regex looks for a valid attribute name,\n * followed by an equal sign (whitespace around the equal sign is allowed), followed\n * by one of the following:\n *\n * 1. a single quote-bounded string, e.g. 'foo'\n * 2. a double quote-bounded string, e.g. \"bar\"\n * 3. an interpolation, e.g. {something}\n *\n * JSX can be be interpolated into itself and is passed through the compiler using\n * the same options and setup as the current run.\n *\n * <Something children={<SomeOtherThing />} />\n *                      ==================\n *                              ↳ children: [<SomeOtherThing />]\n *\n * Otherwise, interpolations are handled as strings or simple booleans\n * unless HTML syntax is detected.\n *\n * <Something color={green} disabled={true} />\n *                   =====            ====\n *                     ↓                ↳ disabled: true\n *                     ↳ color: \"green\"\n *\n * Numbers are not parsed at this time due to complexities around int, float,\n * and the upcoming bigint functionality that would make handling it unwieldy.\n * Parse the string in your component as desired.\n *\n * <Something someBigNumber={123456789123456789} />\n *                           ==================\n *                                   ↳ someBigNumber: \"123456789123456789\"\n */\nconst ATTR_EXTRACTOR_R =\n  /([-A-Z0-9_:]+)(?:\\s*=\\s*(?:(?:\"((?:\\\\.|[^\"])*)\")|(?:'((?:\\\\.|[^'])*)')|(?:\\{((?:\\\\.|{[^}]*?}|[^}])*)\\})))?/gi\n\n/** TODO: Write explainers for each of these */\n\nconst AUTOLINK_MAILTO_CHECK_R = /mailto:/i\nconst BLOCK_END_R = /\\n{2,}$/\nconst BLOCKQUOTE_R = /^(\\s*>[\\s\\S]*?)(?=\\n\\n|$)/\nconst BLOCKQUOTE_TRIM_LEFT_MULTILINE_R = /^ *> ?/gm\nconst BLOCKQUOTE_ALERT_R = /^(?:\\[!([^\\]]*)\\]\\n)?([\\s\\S]*)/\nconst BREAK_LINE_R = /^ {2,}\\n/\nconst BREAK_THEMATIC_R = /^(?:( *[-*_])){3,} *(?:\\n *)+\\n/\nconst CODE_BLOCK_FENCED_R =\n  /^(?: {1,3})?(`{3,}|~{3,}) *(\\S+)? *([^\\n]*?)?\\n([\\s\\S]*?)(?:\\1\\n?|$)/\nconst CODE_BLOCK_R = /^(?: {4}[^\\n]+\\n*)+(?:\\n *)+\\n?/\nconst CODE_INLINE_R = /^(`+)((?:\\\\`|(?!\\1)`|[^`])+)\\1/\nconst CONSECUTIVE_NEWLINE_R = /^(?:\\n *)*\\n/\nconst CR_NEWLINE_R = /\\r\\n?/g\n\n/**\n * Matches footnotes on the format:\n *\n * [^key]: value\n *\n * Matches multiline footnotes\n *\n * [^key]: row\n * row\n * row\n *\n * And empty lines in indented multiline footnotes\n *\n * [^key]: indented with\n *     row\n *\n *     row\n *\n * Explanation:\n *\n * 1. Look for the starting tag, eg: [^key]\n *    ^\\[\\^([^\\]]+)]\n *\n * 2. The first line starts with a colon, and continues for the rest of the line\n *   :(.*)\n *\n * 3. Parse as many additional lines as possible. Matches new non-empty lines that doesn't begin with a new footnote definition.\n *    (\\n(?!\\[\\^).+)\n *\n * 4. ...or allows for repeated newlines if the next line begins with at least four whitespaces.\n *    (\\n+ {4,}.*)\n */\nconst FOOTNOTE_R = /^\\[\\^([^\\]]+)](:(.*)((\\n+ {4,}.*)|(\\n(?!\\[\\^).+))*)/\n\nconst FOOTNOTE_REFERENCE_R = /^\\[\\^([^\\]]+)]/\nconst FORMFEED_R = /\\f/g\nconst FRONT_MATTER_R = /^---[ \\t]*\\n(.|\\n)*\\n---[ \\t]*\\n/\nconst GFM_TASK_R = /^\\s*?\\[(x|\\s)\\]/\nconst HEADING_R = /^ *(#{1,6}) *([^\\n]+?)(?: +#*)?(?:\\n *)*(?:\\n|$)/\nconst HEADING_ATX_COMPLIANT_R =\n  /^ *(#{1,6}) +([^\\n]+?)(?: +#*)?(?:\\n *)*(?:\\n|$)/\nconst HEADING_SETEXT_R = /^([^\\n]+)\\n *(=|-){3,} *(?:\\n *)+\\n/\n\n/**\n * Explanation:\n *\n * 1. Look for a starting tag, preceded by any amount of spaces\n *    ^ *<\n *\n * 2. Capture the tag name (capture 1)\n *    ([^ >/]+)\n *\n * 3. Ignore a space after the starting tag and capture the attribute portion of the tag (capture 2)\n *     ?([^>]*)>\n *\n * 4. Ensure a matching closing tag is present in the rest of the input string\n *    (?=[\\s\\S]*<\\/\\1>)\n *\n * 5. Capture everything until the matching closing tag -- this might include additional pairs\n *    of the same tag type found in step 2 (capture 3)\n *    ((?:[\\s\\S]*?(?:<\\1[^>]*>[\\s\\S]*?<\\/\\1>)*[\\s\\S]*?)*?)<\\/\\1>\n *\n * 6. Capture excess newlines afterward\n *    \\n*\n */\nconst HTML_BLOCK_ELEMENT_R =\n  /^ *(?!<[a-z][^ >/]* ?\\/>)<([a-z][^ >/]*) ?((?:[^>]*[^/])?)>\\n?(\\s*(?:<\\1[^>]*?>[\\s\\S]*?<\\/\\1>|(?!<\\1\\b)[\\s\\S])*?)<\\/\\1>(?!<\\/\\1>)\\n*/i\n\nconst HTML_CHAR_CODE_R = /&([a-z0-9]+|#[0-9]{1,6}|#x[0-9a-fA-F]{1,6});/gi\n\nconst HTML_COMMENT_R = /^<!--[\\s\\S]*?(?:-->)/\n\n/**\n * borrowed from React 15(https://github.com/facebook/react/blob/894d20744cba99383ffd847dbd5b6e0800355a5c/src/renderers/dom/shared/HTMLDOMPropertyConfig.js)\n */\nconst HTML_CUSTOM_ATTR_R = /^(data|aria|x)-[a-z_][a-z\\d_.-]*$/\n\nconst HTML_SELF_CLOSING_ELEMENT_R =\n  /^ *<([a-z][a-z0-9:]*)(?:\\s+((?:<.*?>|[^>])*))?\\/?>(?!<\\/\\1>)(\\s*\\n)?/i\nconst INTERPOLATION_R = /^\\{.*\\}$/\nconst LINK_AUTOLINK_BARE_URL_R = /^(https?:\\/\\/[^\\s<]+[^<.,:;\"')\\]\\s])/\nconst LINK_AUTOLINK_MAILTO_R = /^<([^ >]+@[^ >]+)>/\nconst LINK_AUTOLINK_R = /^<([^ >]+:\\/[^ >]+)>/\nconst CAPTURE_LETTER_AFTER_HYPHEN = /-([a-z])?/gi\nconst NP_TABLE_R = /^(\\|.*)\\n(?: *(\\|? *[-:]+ *\\|[-| :]*)\\n((?:.*\\|.*\\n)*))?\\n?/\nconst PARAGRAPH_R = /^[^\\n]+(?:  \\n|\\n{2,})/\nconst REFERENCE_IMAGE_OR_LINK = /^\\[([^\\]]*)\\]:\\s+<?([^\\s>]+)>?\\s*(\"([^\"]*)\")?/\nconst REFERENCE_IMAGE_R = /^!\\[([^\\]]*)\\] ?\\[([^\\]]*)\\]/\nconst REFERENCE_LINK_R = /^\\[([^\\]]*)\\] ?\\[([^\\]]*)\\]/\nconst SHOULD_RENDER_AS_BLOCK_R = /(\\n|^[-*]\\s|^#|^ {2,}|^-{2,}|^>\\s)/\nconst TAB_R = /\\t/g\nconst TABLE_TRIM_PIPES = /(^ *\\||\\| *$)/g\nconst TABLE_CENTER_ALIGN = /^ *:-+: *$/\nconst TABLE_LEFT_ALIGN = /^ *:-+ *$/\nconst TABLE_RIGHT_ALIGN = /^ *-+: *$/\n\n/**\n * For inline formatting, this partial attempts to ignore characters that\n * may appear in nested formatting that could prematurely trigger detection\n * and therefore miss content that should have been included.\n */\nconst INLINE_SKIP_R =\n  '((?:\\\\[.*?\\\\][([].*?[)\\\\]]|<.*?>(?:.*?<.*?>)?|`.*?`|\\\\\\\\\\\\1|[\\\\s\\\\S])+?)'\n\n/**\n * Detect a sequence like **foo** or __foo__. Note that bold has a higher priority\n * than emphasized to support nesting of both since they share a delimiter.\n */\nconst TEXT_BOLD_R = new RegExp(`^([*_])\\\\1${INLINE_SKIP_R}\\\\1\\\\1(?!\\\\1)`)\n\n/**\n * Detect a sequence like *foo* or _foo_.\n */\nconst TEXT_EMPHASIZED_R = new RegExp(`^([*_])${INLINE_SKIP_R}\\\\1(?!\\\\1)`)\n\n/**\n * Detect a sequence like ==foo==.\n */\nconst TEXT_MARKED_R = new RegExp(`^(==)${INLINE_SKIP_R}\\\\1`)\n\n/**\n * Detect a sequence like ~~foo~~.\n */\nconst TEXT_STRIKETHROUGHED_R = new RegExp(`^(~~)${INLINE_SKIP_R}\\\\1`)\n\nconst TEXT_ESCAPED_R = /^\\\\([^0-9A-Za-z\\s])/\nconst TEXT_UNESCAPE_R = /\\\\([^0-9A-Za-z\\s])/g\n\n/**\n * Always take the first character, then eagerly take text until a double space\n * (potential line break) or some markdown-like punctuation is reached.\n */\nconst TEXT_PLAIN_R = /^(?: |[\\s\\S](?:(?!  |[0-9]\\.)[^=*_~\\-\\n<`\\\\\\[! ])*)/\n\nconst TRIM_STARTING_NEWLINES = /^\\n+/\n\nconst HTML_LEFT_TRIM_AMOUNT_R = /^([ \\t]*)/\n\nconst UNESCAPE_URL_R = /\\\\([^\\\\])/g\n\ntype LIST_TYPE = 1 | 2\nconst ORDERED: LIST_TYPE = 1\nconst UNORDERED: LIST_TYPE = 2\n\nconst LIST_LOOKBEHIND_R = /(?:^|\\n)( *)$/\n\n// recognize a `*` `-`, `+`, `1.`, `2.`... list bullet\nconst ORDERED_LIST_BULLET = '(?:\\\\d+\\\\.)'\nconst UNORDERED_LIST_BULLET = '(?:[*+-])'\n\nfunction generateListItemPrefix(type: LIST_TYPE) {\n  return (\n    '( *)(' +\n    (type === ORDERED ? ORDERED_LIST_BULLET : UNORDERED_LIST_BULLET) +\n    ') +'\n  )\n}\n\n// recognize the start of a list item:\n// leading space plus a bullet plus a space (`   * `)\nconst ORDERED_LIST_ITEM_PREFIX = generateListItemPrefix(ORDERED)\nconst UNORDERED_LIST_ITEM_PREFIX = generateListItemPrefix(UNORDERED)\n\nfunction generateListItemPrefixRegex(type: LIST_TYPE) {\n  return new RegExp(\n    '^' +\n      (type === ORDERED ? ORDERED_LIST_ITEM_PREFIX : UNORDERED_LIST_ITEM_PREFIX)\n  )\n}\n\nconst ORDERED_LIST_ITEM_PREFIX_R = generateListItemPrefixRegex(ORDERED)\nconst UNORDERED_LIST_ITEM_PREFIX_R = generateListItemPrefixRegex(UNORDERED)\n\nfunction generateListItemRegex(type: LIST_TYPE) {\n  // recognize an individual list item:\n  //  * hi\n  //    this is part of the same item\n  //\n  //    as is this, which is a new paragraph in the same item\n  //\n  //  * but this is not part of the same item\n  return new RegExp(\n    '^' +\n      (type === ORDERED\n        ? ORDERED_LIST_ITEM_PREFIX\n        : UNORDERED_LIST_ITEM_PREFIX) +\n      '[^\\\\n]*(?:\\\\n' +\n      '(?!\\\\1' +\n      (type === ORDERED ? ORDERED_LIST_BULLET : UNORDERED_LIST_BULLET) +\n      ' )[^\\\\n]*)*(\\\\n|$)',\n    'gm'\n  )\n}\n\nconst ORDERED_LIST_ITEM_R = generateListItemRegex(ORDERED)\nconst UNORDERED_LIST_ITEM_R = generateListItemRegex(UNORDERED)\n\n// check whether a list item has paragraphs: if it does,\n// we leave the newlines at the end\nfunction generateListRegex(type: LIST_TYPE) {\n  const bullet = type === ORDERED ? ORDERED_LIST_BULLET : UNORDERED_LIST_BULLET\n\n  return new RegExp(\n    '^( *)(' +\n      bullet +\n      ') ' +\n      '[\\\\s\\\\S]+?(?:\\\\n{2,}(?! )' +\n      '(?!\\\\1' +\n      bullet +\n      ' (?!' +\n      bullet +\n      ' ))\\\\n*' +\n      // the \\\\s*$ here is so that we can parse the inside of nested\n      // lists, where our content might end before we receive two `\\n`s\n      '|\\\\s*\\\\n*$)'\n  )\n}\n\nconst ORDERED_LIST_R = generateListRegex(ORDERED)\nconst UNORDERED_LIST_R = generateListRegex(UNORDERED)\n\nfunction generateListRule(\n  h: any,\n  type: LIST_TYPE\n): MarkdownToJSX.Rule<\n  MarkdownToJSX.OrderedListNode | MarkdownToJSX.UnorderedListNode\n> {\n  const ordered = type === ORDERED\n  const LIST_R = ordered ? ORDERED_LIST_R : UNORDERED_LIST_R\n  const LIST_ITEM_R = ordered ? ORDERED_LIST_ITEM_R : UNORDERED_LIST_ITEM_R\n  const LIST_ITEM_PREFIX_R = ordered\n    ? ORDERED_LIST_ITEM_PREFIX_R\n    : UNORDERED_LIST_ITEM_PREFIX_R\n\n  return {\n    match: allowInline(function (source, state) {\n      // We only want to break into a list if we are at the start of a\n      // line. This is to avoid parsing \"hi * there\" with \"* there\"\n      // becoming a part of a list.\n      // You might wonder, \"but that's inline, so of course it wouldn't\n      // start a list?\". You would be correct! Except that some of our\n      // lists can be inline, because they might be inside another list,\n      // in which case we can parse with inline scope, but need to allow\n      // nested lists inside this inline scope.\n      const isStartOfLine = LIST_LOOKBEHIND_R.exec(state.prevCapture)\n      const isListAllowed = state.list || (!state.inline && !state.simple)\n\n      if (isStartOfLine && isListAllowed) {\n        source = isStartOfLine[1] + source\n\n        return LIST_R.exec(source)\n      } else {\n        return null\n      }\n    }),\n    order: Priority.HIGH,\n    parse(capture, parse, state) {\n      const bullet = capture[2]\n      const start = ordered ? +bullet : undefined\n      const items = capture[0]\n        // recognize the end of a paragraph block inside a list item:\n        // two or more newlines at end end of the item\n        .replace(BLOCK_END_R, '\\n')\n        .match(LIST_ITEM_R)\n\n      let lastItemWasAParagraph = false\n\n      const itemContent = items.map(function (item, i) {\n        // We need to see how far indented the item is:\n        const space = LIST_ITEM_PREFIX_R.exec(item)[0].length\n\n        // And then we construct a regex to \"unindent\" the subsequent\n        // lines of the items by that amount:\n        const spaceRegex = new RegExp('^ {1,' + space + '}', 'gm')\n\n        // Before processing the item, we need a couple things\n        const content = item\n          // remove indents on trailing lines:\n          .replace(spaceRegex, '')\n          // remove the bullet:\n          .replace(LIST_ITEM_PREFIX_R, '')\n\n        // Handling \"loose\" lists, like:\n        //\n        //  * this is wrapped in a paragraph\n        //\n        //  * as is this\n        //\n        //  * as is this\n        const isLastItem = i === items.length - 1\n        const containsBlocks = content.indexOf('\\n\\n') !== -1\n\n        // Any element in a list is a block if it contains multiple\n        // newlines. The last element in the list can also be a block\n        // if the previous item in the list was a block (this is\n        // because non-last items in the list can end with \\n\\n, but\n        // the last item can't, so we just \"inherit\" this property\n        // from our previous element).\n        const thisItemIsAParagraph =\n          containsBlocks || (isLastItem && lastItemWasAParagraph)\n        lastItemWasAParagraph = thisItemIsAParagraph\n\n        // backup our state for delta afterwards. We're going to\n        // want to set state.list to true, and state.inline depending\n        // on our list's looseness.\n        const oldStateInline = state.inline\n        const oldStateList = state.list\n        state.list = true\n\n        // Parse inline if we're in a tight list, or block if we're in\n        // a loose list.\n        let adjustedContent\n        if (thisItemIsAParagraph) {\n          state.inline = false\n          adjustedContent = trimEnd(content) + '\\n\\n'\n        } else {\n          state.inline = true\n          adjustedContent = trimEnd(content)\n        }\n\n        const result = parse(adjustedContent, state)\n\n        // Restore our state before returning\n        state.inline = oldStateInline\n        state.list = oldStateList\n\n        return result\n      })\n\n      return {\n        items: itemContent,\n        ordered: ordered,\n        start: start,\n      }\n    },\n    render(node, output, state) {\n      const Tag = node.ordered ? 'ol' : 'ul'\n\n      return (\n        <Tag\n          key={state.key}\n          start={node.type === RuleType.orderedList ? node.start : undefined}\n        >\n          {node.items.map(function generateListItem(item, i) {\n            return <li key={i}>{output(item, state)}</li>\n          })}\n        </Tag>\n      )\n    },\n  }\n}\n\nconst LINK_INSIDE = '(?:\\\\[[^\\\\]]*\\\\]|[^\\\\[\\\\]]|\\\\](?=[^\\\\[]*\\\\]))*'\nconst LINK_HREF_AND_TITLE =\n  '\\\\s*<?((?:\\\\([^)]*\\\\)|[^\\\\s\\\\\\\\]|\\\\\\\\.)*?)>?(?:\\\\s+[\\'\"]([\\\\s\\\\S]*?)[\\'\"])?\\\\s*'\nconst LINK_R = new RegExp(\n  '^\\\\[(' + LINK_INSIDE + ')\\\\]\\\\(' + LINK_HREF_AND_TITLE + '\\\\)'\n)\nconst IMAGE_R = /^!\\[(.*?)\\]\\( *((?:\\([^)]*\\)|[^() ])*) *\"?([^)\"]*)?\"?\\)/\n\nfunction trimEnd(str: string) {\n  let end = str.length\n  while (end > 0 && str[end - 1] <= ' ') end--\n  return str.slice(0, end)\n}\n\n/** Remove symmetrical leading and trailing quotes */\nfunction unquote(str: string) {\n  const first = str[0]\n  if (\n    (first === '\"' || first === \"'\") &&\n    str.length >= 2 &&\n    str[str.length - 1] === first\n  ) {\n    return str.slice(1, -1)\n  }\n  return str\n}\n\n// based on https://stackoverflow.com/a/18123682/1141611\n// not complete, but probably good enough\nexport function slugify(str: string) {\n  return str\n    .replace(/[ÀÁÂÃÄÅàáâãäåæÆ]/g, 'a')\n    .replace(/[çÇ]/g, 'c')\n    .replace(/[ðÐ]/g, 'd')\n    .replace(/[ÈÉÊËéèêë]/g, 'e')\n    .replace(/[ÏïÎîÍíÌì]/g, 'i')\n    .replace(/[Ññ]/g, 'n')\n    .replace(/[øØœŒÕõÔôÓóÒò]/g, 'o')\n    .replace(/[ÜüÛûÚúÙù]/g, 'u')\n    .replace(/[ŸÿÝý]/g, 'y')\n    .replace(/[^a-z0-9- ]/gi, '')\n    .replace(/ /gi, '-')\n    .toLowerCase()\n}\n\nfunction parseTableAlignCapture(alignCapture: string) {\n  if (TABLE_RIGHT_ALIGN.test(alignCapture)) {\n    return 'right'\n  } else if (TABLE_CENTER_ALIGN.test(alignCapture)) {\n    return 'center'\n  } else if (TABLE_LEFT_ALIGN.test(alignCapture)) {\n    return 'left'\n  }\n\n  return null\n}\n\nfunction parseTableRow(\n  source: string,\n  parse: MarkdownToJSX.NestedParser,\n  state: MarkdownToJSX.State,\n  tableOutput: boolean\n): MarkdownToJSX.ParserResult[][] {\n  const prevInTable = state.inTable\n\n  state.inTable = true\n\n  let cells: MarkdownToJSX.ParserResult[][] = [[]]\n  let acc = ''\n\n  function flush() {\n    if (!acc) return\n\n    const cell = cells[cells.length - 1]\n    cell.push.apply(cell, parse(acc, state))\n    acc = ''\n  }\n\n  source\n    .trim()\n    // isolate situations where a pipe should be ignored (inline code, escaped, etc)\n    .split(/(`[^`]*`|\\\\\\||\\|)/)\n    .filter(Boolean)\n    .forEach((fragment, i, arr) => {\n      if (fragment.trim() === '|') {\n        flush()\n\n        if (tableOutput) {\n          if (i !== 0 && i !== arr.length - 1) {\n            // Split the current row\n            cells.push([])\n          }\n\n          return\n        }\n      }\n\n      acc += fragment\n    })\n\n  flush()\n\n  state.inTable = prevInTable\n\n  return cells\n}\n\nfunction parseTableAlign(source: string /*, parse, state*/) {\n  const alignText = source.replace(TABLE_TRIM_PIPES, '').split('|')\n\n  return alignText.map(parseTableAlignCapture)\n}\n\nfunction parseTableCells(\n  source: string,\n  parse: MarkdownToJSX.NestedParser,\n  state: MarkdownToJSX.State\n) {\n  const rowsText = source.trim().split('\\n')\n\n  return rowsText.map(function (rowText) {\n    return parseTableRow(rowText, parse, state, true)\n  })\n}\n\nfunction parseTable(\n  capture: RegExpMatchArray,\n  parse: MarkdownToJSX.NestedParser,\n  state: MarkdownToJSX.State\n) {\n  /**\n   * The table syntax makes some other parsing angry so as a bit of a hack even if alignment and/or cell rows are missing,\n   * we'll still run a detected first row through the parser and then just emit a paragraph.\n   */\n  state.inline = true\n  const align = capture[2] ? parseTableAlign(capture[2]) : []\n  const cells = capture[3] ? parseTableCells(capture[3], parse, state) : []\n  const header = parseTableRow(capture[1], parse, state, !!cells.length)\n  state.inline = false\n\n  return cells.length\n    ? {\n        align: align,\n        cells: cells,\n        header: header,\n        type: RuleType.table,\n      }\n    : {\n        children: header,\n        type: RuleType.paragraph,\n      }\n}\n\nfunction getTableStyle(node, colIndex) {\n  return node.align[colIndex] == null\n    ? {}\n    : {\n        textAlign: node.align[colIndex],\n      }\n}\n\n/** TODO: remove for react 16 */\nfunction normalizeAttributeKey(key) {\n  const hyphenIndex = key.indexOf('-')\n\n  if (hyphenIndex !== -1 && key.match(HTML_CUSTOM_ATTR_R) === null) {\n    key = key.replace(CAPTURE_LETTER_AFTER_HYPHEN, function (_, letter) {\n      return letter.toUpperCase()\n    })\n  }\n\n  return key\n}\n\ntype StyleTuple = [key: string, value: string]\n\nfunction parseStyleAttribute(styleString: string): StyleTuple[] {\n  const styles: StyleTuple[] = []\n  let buffer = ''\n  let inUrl = false\n  let inQuotes = false\n  let quoteChar: '\"' | \"'\" | '' = ''\n\n  if (!styleString) return styles\n\n  for (let i = 0; i < styleString.length; i++) {\n    const char = styleString[i]\n\n    // Handle quotes\n    if ((char === '\"' || char === \"'\") && !inUrl) {\n      if (!inQuotes) {\n        inQuotes = true\n        quoteChar = char\n      } else if (char === quoteChar) {\n        inQuotes = false\n        quoteChar = ''\n      }\n    }\n\n    // Track url() values\n    if (char === '(' && buffer.endsWith('url')) {\n      inUrl = true\n    } else if (char === ')' && inUrl) {\n      inUrl = false\n    }\n\n    // Only split on semicolons when not in quotes or url()\n    if (char === ';' && !inQuotes && !inUrl) {\n      const declaration = buffer.trim()\n      if (declaration) {\n        const colonIndex = declaration.indexOf(':')\n        if (colonIndex > 0) {\n          const key = declaration.slice(0, colonIndex).trim()\n          const value = declaration.slice(colonIndex + 1).trim()\n          styles.push([key, value])\n        }\n      }\n      buffer = ''\n    } else {\n      buffer += char\n    }\n  }\n\n  // Handle the last declaration\n  const declaration = buffer.trim()\n  if (declaration) {\n    const colonIndex = declaration.indexOf(':')\n    if (colonIndex > 0) {\n      const key = declaration.slice(0, colonIndex).trim()\n      const value = declaration.slice(colonIndex + 1).trim()\n      styles.push([key, value])\n    }\n  }\n\n  return styles\n}\n\nfunction attributeValueToJSXPropValue(\n  tag: MarkdownToJSX.HTMLTags,\n  key: keyof React.AllHTMLAttributes<Element>,\n  value: string,\n  sanitizeUrlFn: MarkdownToJSX.Options['sanitizer']\n): any {\n  if (key === 'style') {\n    return parseStyleAttribute(value).reduce(function (styles, [key, value]) {\n      // snake-case to camelCase\n      // also handles PascalCasing vendor prefixes\n      const camelCasedKey = key.replace(/(-[a-z])/g, substr =>\n        substr[1].toUpperCase()\n      )\n\n      // key.length + 1 to skip over the colon\n      styles[camelCasedKey] = sanitizeUrlFn(value, tag, key)\n\n      return styles\n    }, {})\n  } else if (ATTRIBUTES_TO_SANITIZE.indexOf(key) !== -1) {\n    return sanitizeUrlFn(value, tag, key)\n  } else if (value.match(INTERPOLATION_R)) {\n    // return as a string and let the consumer decide what to do with it\n    value = value.slice(1, value.length - 1)\n  }\n\n  if (value === 'true') {\n    return true\n  } else if (value === 'false') {\n    return false\n  }\n\n  return value\n}\n\nfunction normalizeWhitespace(source: string): string {\n  return source\n    .replace(CR_NEWLINE_R, '\\n')\n    .replace(FORMFEED_R, '')\n    .replace(TAB_R, '    ')\n}\n\n/**\n * Creates a parser for a given set of rules, with the precedence\n * specified as a list of rules.\n *\n * @rules: an object containing\n * rule type -> {match, order, parse} objects\n * (lower order is higher precedence)\n * (Note: `order` is added to defaultRules after creation so that\n *  the `order` of defaultRules in the source matches the `order`\n *  of defaultRules in terms of `order` fields.)\n *\n * @returns The resulting parse function, with the following parameters:\n *   @source: the input source string to be parsed\n *   @state: an optional object to be threaded through parse\n *     calls. Allows clients to add stateful operations to\n *     parsing, such as keeping track of how many levels deep\n *     some nesting is. For an example use-case, see passage-ref\n *     parsing in src/widgets/passage/passage-markdown.jsx\n */\nfunction parserFor(\n  rules: MarkdownToJSX.Rules\n): (\n  source: string,\n  state: MarkdownToJSX.State\n) => ReturnType<MarkdownToJSX.NestedParser> {\n  // Sorts rules in order of increasing order, then\n  // ascending rule name in case of ties.\n  let ruleList = Object.keys(rules)\n\n  if (process.env.NODE_ENV !== 'production') {\n    ruleList.forEach(function (type) {\n      let order = rules[type].order\n      if (\n        process.env.NODE_ENV !== 'production' &&\n        (typeof order !== 'number' || !isFinite(order))\n      ) {\n        console.warn(\n          'markdown-to-jsx: Invalid order for rule `' + type + '`: ' + order\n        )\n      }\n    })\n  }\n\n  ruleList.sort(function (typeA, typeB) {\n    let orderA = rules[typeA].order\n    let orderB = rules[typeB].order\n\n    // Sort based on increasing order\n    if (orderA !== orderB) {\n      return orderA - orderB\n    } else if (typeA < typeB) {\n      return -1\n    }\n\n    return 1\n  })\n\n  function nestedParse(\n    source: string,\n    state: MarkdownToJSX.State\n  ): MarkdownToJSX.ParserResult[] {\n    let result = []\n    let rule\n    let ruleType = ''\n    let parsed\n    let currCaptureString = ''\n\n    state.prevCapture = state.prevCapture || ''\n\n    // We store the previous capture so that match functions can\n    // use some limited amount of lookbehind. Lists use this to\n    // ensure they don't match arbitrary '- ' or '* ' in inline\n    // text (see the list rule for more information).\n    while (source) {\n      let i = 0\n      while (i < ruleList.length) {\n        ruleType = ruleList[i]\n        rule = rules[ruleType]\n\n        if (state.inline && !rule.match.inline) {\n          i++\n          continue\n        }\n\n        const capture = rule.match(source, state)\n\n        if (capture) {\n          currCaptureString = capture[0]\n\n          // retain what's been processed so far for lookbacks\n          state.prevCapture += currCaptureString\n\n          source = source.substring(currCaptureString.length)\n\n          parsed = rule.parse(capture, nestedParse, state)\n\n          // We also let rules override the default type of\n          // their parsed node if they would like to, so that\n          // there can be a single output function for all links,\n          // even if there are several rules to parse them.\n          if (parsed.type == null) {\n            parsed.type = ruleType as unknown as RuleType\n          }\n\n          result.push(parsed)\n          break\n        }\n\n        i++\n      }\n    }\n\n    // reset on exit\n    state.prevCapture = ''\n\n    return result\n  }\n\n  return function outerParse(source, state) {\n    return nestedParse(normalizeWhitespace(source), state)\n  }\n}\n\n/**\n * Marks a matcher function as eligible for being run inside an inline context;\n * allows us to do a little less work in the nested parser.\n */\nfunction allowInline<T extends Function & { inline?: 0 | 1 }>(fn: T) {\n  fn.inline = 1\n\n  return fn\n}\n\n// Creates a match function for an inline scoped or simple element from a regex\nfunction inlineRegex(regex: RegExp) {\n  return allowInline(function match(source, state: MarkdownToJSX.State) {\n    if (state.inline) {\n      return regex.exec(source)\n    } else {\n      return null\n    }\n  })\n}\n\n// basically any inline element except links\nfunction simpleInlineRegex(regex: RegExp) {\n  return allowInline(function match(\n    source: string,\n    state: MarkdownToJSX.State\n  ) {\n    if (state.inline || state.simple) {\n      return regex.exec(source)\n    } else {\n      return null\n    }\n  })\n}\n\n// Creates a match function for a block scoped element from a regex\nfunction blockRegex(regex: RegExp) {\n  return function match(source: string, state: MarkdownToJSX.State) {\n    if (state.inline || state.simple) {\n      return null\n    } else {\n      return regex.exec(source)\n    }\n  }\n}\n\n// Creates a match function from a regex, ignoring block/inline scope\nfunction anyScopeRegex(regex: RegExp) {\n  return allowInline(function match(source: string /*, state*/) {\n    return regex.exec(source)\n  })\n}\n\nconst SANITIZE_R = /(javascript|vbscript|data(?!:image)):/i\n\nexport function sanitizer(input: string): string {\n  try {\n    const decoded = decodeURIComponent(input).replace(/[^A-Za-z0-9/:]/g, '')\n\n    if (SANITIZE_R.test(decoded)) {\n      if (process.env.NODE_ENV !== 'production') {\n        console.warn(\n          'Input contains an unsafe JavaScript/VBScript/data expression, it will not be rendered.',\n          decoded\n        )\n      }\n\n      return null\n    }\n  } catch (e) {\n    if (process.env.NODE_ENV !== 'production') {\n      console.warn(\n        'Input could not be decoded due to malformed syntax or characters, it will not be rendered.',\n        input\n      )\n    }\n\n    // decodeURIComponent sometimes throws a URIError\n    // See `decodeURIComponent('a%AFc');`\n    // http://stackoverflow.com/questions/9064536/javascript-decodeuricomponent-malformed-uri-exception\n    return null\n  }\n\n  return input\n}\n\nfunction unescapeUrl(rawUrlString: string): string {\n  return rawUrlString.replace(UNESCAPE_URL_R, '$1')\n}\n\n/**\n * Everything inline, including links.\n */\nfunction parseInline(\n  parse: MarkdownToJSX.NestedParser,\n  children: string,\n  state: MarkdownToJSX.State\n): MarkdownToJSX.ParserResult[] {\n  const isCurrentlyInline = state.inline || false\n  const isCurrentlySimple = state.simple || false\n  state.inline = true\n  state.simple = true\n  const result = parse(children, state)\n  state.inline = isCurrentlyInline\n  state.simple = isCurrentlySimple\n  return result\n}\n\n/**\n * Anything inline that isn't a link.\n */\nfunction parseSimpleInline(\n  parse: MarkdownToJSX.NestedParser,\n  children: string,\n  state: MarkdownToJSX.State\n): MarkdownToJSX.ParserResult[] {\n  const isCurrentlyInline = state.inline || false\n  const isCurrentlySimple = state.simple || false\n  state.inline = false\n  state.simple = true\n  const result = parse(children, state)\n  state.inline = isCurrentlyInline\n  state.simple = isCurrentlySimple\n  return result\n}\n\nfunction parseBlock(\n  parse,\n  children,\n  state: MarkdownToJSX.State\n): MarkdownToJSX.ParserResult[] {\n  const isCurrentlyInline = state.inline || false\n  state.inline = false\n  const result = parse(children, state)\n  state.inline = isCurrentlyInline\n  return result\n}\n\nconst parseCaptureInline: MarkdownToJSX.Parser<{\n  children: MarkdownToJSX.ParserResult[]\n}> = (capture, parse, state: MarkdownToJSX.State) => {\n  return {\n    children: parseInline(parse, capture[2], state),\n  }\n}\n\nfunction captureNothing() {\n  return {}\n}\n\nfunction renderNothing() {\n  return null\n}\n\nfunction reactFor(render) {\n  return function patchedRender(\n    ast: MarkdownToJSX.ParserResult | MarkdownToJSX.ParserResult[],\n    state: MarkdownToJSX.State = {}\n  ): React.ReactNode[] {\n    if (Array.isArray(ast)) {\n      const oldKey = state.key\n      const result = []\n\n      // map nestedOutput over the ast, except group any text\n      // nodes together into a single string output.\n      let lastWasString = false\n\n      for (let i = 0; i < ast.length; i++) {\n        state.key = i\n\n        const nodeOut = patchedRender(ast[i], state)\n        const isString = typeof nodeOut === 'string'\n\n        if (isString && lastWasString) {\n          result[result.length - 1] += nodeOut\n        } else if (nodeOut !== null) {\n          result.push(nodeOut)\n        }\n\n        lastWasString = isString\n      }\n\n      state.key = oldKey\n\n      return result\n    }\n\n    return render(ast, patchedRender, state)\n  }\n}\n\nfunction createRenderer(\n  rules: MarkdownToJSX.Rules,\n  userRender?: MarkdownToJSX.Options['renderRule']\n) {\n  return function renderRule(\n    ast: MarkdownToJSX.ParserResult,\n    render: MarkdownToJSX.RuleOutput,\n    state: MarkdownToJSX.State\n  ): React.ReactNode {\n    const renderer = rules[ast.type].render as MarkdownToJSX.Rule['render']\n\n    return userRender\n      ? userRender(() => renderer(ast, render, state), ast, render, state)\n      : renderer(ast, render, state)\n  }\n}\n\nfunction cx(...args) {\n  return args.filter(Boolean).join(' ')\n}\n\nfunction get(src: Object, path: string, fb?: any) {\n  let ptr = src\n  const frags = path.split('.')\n\n  while (frags.length) {\n    ptr = ptr[frags[0]]\n\n    if (ptr === undefined) break\n    else frags.shift()\n  }\n\n  return ptr || fb\n}\n\nfunction getTag(tag: string, overrides: MarkdownToJSX.Overrides) {\n  const override = get(overrides, tag)\n\n  if (!override) return tag\n\n  return typeof override === 'function' ||\n    (typeof override === 'object' && 'render' in override)\n    ? override\n    : get(overrides, `${tag}.component`, tag)\n}\n\nexport function compiler(\n  markdown: string = '',\n  options: MarkdownToJSX.Options = {}\n): React.JSX.Element {\n  options.overrides = options.overrides || {}\n  options.sanitizer = options.sanitizer || sanitizer\n  options.slugify = options.slugify || slugify\n  options.namedCodesToUnicode = options.namedCodesToUnicode\n    ? { ...namedCodesToUnicode, ...options.namedCodesToUnicode }\n    : namedCodesToUnicode\n\n  options.createElement = options.createElement || React.createElement\n\n  const NON_PARAGRAPH_BLOCK_SYNTAXES = [\n    BLOCKQUOTE_R,\n    CODE_BLOCK_FENCED_R,\n    CODE_BLOCK_R,\n    options.enforceAtxHeadings ? HEADING_ATX_COMPLIANT_R : HEADING_R,\n    HEADING_SETEXT_R,\n    NP_TABLE_R,\n    ORDERED_LIST_R,\n    UNORDERED_LIST_R,\n  ]\n\n  const BLOCK_SYNTAXES = [\n    ...NON_PARAGRAPH_BLOCK_SYNTAXES,\n    PARAGRAPH_R,\n    HTML_BLOCK_ELEMENT_R,\n    HTML_COMMENT_R,\n    HTML_SELF_CLOSING_ELEMENT_R,\n  ]\n\n  function containsBlockSyntax(input: string) {\n    return BLOCK_SYNTAXES.some(r => r.test(input))\n  }\n\n  function matchParagraph(source: string, state: MarkdownToJSX.State) {\n    if (state.inline || state.simple) {\n      return null\n    }\n\n    let match = ''\n\n    source.split('\\n').every(line => {\n      line += '\\n'\n\n      // bail out on first sign of non-paragraph block\n      if (NON_PARAGRAPH_BLOCK_SYNTAXES.some(regex => regex.test(line))) {\n        return false\n      }\n\n      match += line\n\n      return !!line.trim()\n    })\n\n    const captured = trimEnd(match)\n    if (captured == '') {\n      return null\n    }\n\n    // parseCaptureInline expects the inner content to be at index 2\n    // because index 1 is the delimiter for text formatting syntaxes\n    return [match, , captured]\n  }\n\n  // JSX custom pragma\n  // eslint-disable-next-line no-unused-vars\n  function h(\n    // locally we always will render a known string tag\n    tag: MarkdownToJSX.HTMLTags,\n    props: Parameters<MarkdownToJSX.CreateElement>[1] & {\n      className?: string\n      id?: string\n    },\n    ...children\n  ) {\n    const overrideProps = get(options.overrides, `${tag}.props`, {})\n\n    return options.createElement(\n      getTag(tag, options.overrides),\n      {\n        ...props,\n        ...overrideProps,\n        className: cx(props?.className, overrideProps.className) || undefined,\n      },\n      ...children\n    )\n  }\n\n  function compile(input: string): React.JSX.Element {\n    input = input.replace(FRONT_MATTER_R, '')\n\n    let inline = false\n\n    if (options.forceInline) {\n      inline = true\n    } else if (!options.forceBlock) {\n      /**\n       * should not contain any block-level markdown like newlines, lists, headings,\n       * thematic breaks, blockquotes, tables, etc\n       */\n      inline = SHOULD_RENDER_AS_BLOCK_R.test(input) === false\n    }\n\n    const arr = emitter(\n      parser(\n        inline\n          ? input\n          : `${trimEnd(input).replace(TRIM_STARTING_NEWLINES, '')}\\n\\n`,\n        {\n          inline,\n        }\n      )\n    )\n\n    while (\n      typeof arr[arr.length - 1] === 'string' &&\n      !arr[arr.length - 1].trim()\n    ) {\n      arr.pop()\n    }\n\n    if (options.wrapper === null) {\n      return arr\n    }\n\n    const wrapper = options.wrapper || (inline ? 'span' : 'div')\n    let jsx\n\n    if (arr.length > 1 || options.forceWrapper) {\n      jsx = arr\n    } else if (arr.length === 1) {\n      jsx = arr[0]\n\n      // TODO: remove this for React 16\n      if (typeof jsx === 'string') {\n        return <span key=\"outer\">{jsx}</span>\n      } else {\n        return jsx\n      }\n    } else {\n      // TODO: return null for React 16\n      jsx = null\n    }\n\n    return options.createElement(\n      wrapper,\n      { key: 'outer' },\n      jsx\n    ) as React.JSX.Element\n  }\n\n  function attrStringToMap(\n    tag: MarkdownToJSX.HTMLTags,\n    str: string\n  ): React.JSX.IntrinsicAttributes {\n    const attributes = str.match(ATTR_EXTRACTOR_R)\n    if (!attributes) {\n      return null\n    }\n\n    return attributes.reduce(function (map, raw) {\n      const delimiterIdx = raw.indexOf('=')\n\n      if (delimiterIdx !== -1) {\n        const key = normalizeAttributeKey(raw.slice(0, delimiterIdx)).trim()\n        const value = unquote(raw.slice(delimiterIdx + 1).trim())\n\n        const mappedKey = ATTRIBUTE_TO_JSX_PROP_MAP[key] || key\n\n        // bail out, not supported\n        if (mappedKey === 'ref') return map\n\n        const normalizedValue = (map[mappedKey] = attributeValueToJSXPropValue(\n          tag,\n          key,\n          value,\n          options.sanitizer\n        ))\n\n        if (\n          typeof normalizedValue === 'string' &&\n          (HTML_BLOCK_ELEMENT_R.test(normalizedValue) ||\n            HTML_SELF_CLOSING_ELEMENT_R.test(normalizedValue))\n        ) {\n          map[mappedKey] = compile(normalizedValue.trim())\n        }\n      } else if (raw !== 'style') {\n        map[ATTRIBUTE_TO_JSX_PROP_MAP[raw] || raw] = true\n      }\n\n      return map\n    }, {})\n  }\n\n  if (process.env.NODE_ENV !== 'production') {\n    if (typeof markdown !== 'string') {\n      throw new Error(`markdown-to-jsx: the first argument must be\n                             a string`)\n    }\n\n    if (\n      Object.prototype.toString.call(options.overrides) !== '[object Object]'\n    ) {\n      throw new Error(`markdown-to-jsx: options.overrides (second argument property) must be\n                             undefined or an object literal with shape:\n                             {\n                                htmltagname: {\n                                    component: string|ReactComponent(optional),\n                                    props: object(optional)\n                                }\n                             }`)\n    }\n  }\n\n  const footnotes: { footnote: string; identifier: string }[] = []\n  const refs: { [key: string]: { target: string; title: string } } = {}\n\n  /**\n   * each rule's react() output function goes through our custom\n   * h() JSX pragma; this allows the override functionality to be\n   * automatically applied\n   */\n  // @ts-ignore\n  const rules: MarkdownToJSX.Rules = {\n    [RuleType.blockQuote]: {\n      match: blockRegex(BLOCKQUOTE_R),\n      order: Priority.HIGH,\n      parse(capture, parse, state) {\n        const [, alert, content] = capture[0]\n          .replace(BLOCKQUOTE_TRIM_LEFT_MULTILINE_R, '')\n          .match(BLOCKQUOTE_ALERT_R)\n\n        return {\n          alert,\n          children: parse(content, state),\n        }\n      },\n      render(node, output, state) {\n        const props = {\n          key: state.key,\n        } as Record<string, unknown>\n\n        if (node.alert) {\n          props.className =\n            'markdown-alert-' +\n            options.slugify(node.alert.toLowerCase(), slugify)\n\n          node.children.unshift({\n            attrs: {},\n            children: [{ type: RuleType.text, text: node.alert }],\n            noInnerParse: true,\n            type: RuleType.htmlBlock,\n            tag: 'header',\n          })\n        }\n\n        return h('blockquote', props, output(node.children, state))\n      },\n    },\n\n    [RuleType.breakLine]: {\n      match: anyScopeRegex(BREAK_LINE_R),\n      order: Priority.HIGH,\n      parse: captureNothing,\n      render(_, __, state) {\n        return <br key={state.key} />\n      },\n    },\n\n    [RuleType.breakThematic]: {\n      match: blockRegex(BREAK_THEMATIC_R),\n      order: Priority.HIGH,\n      parse: captureNothing,\n      render(_, __, state) {\n        return <hr key={state.key} />\n      },\n    },\n\n    [RuleType.codeBlock]: {\n      match: blockRegex(CODE_BLOCK_R),\n      order: Priority.MAX,\n      parse(capture /*, parse, state*/) {\n        return {\n          lang: undefined,\n          text: trimEnd(capture[0].replace(/^ {4}/gm, '')).replace(\n            TEXT_UNESCAPE_R,\n            '$1'\n          ),\n        }\n      },\n\n      render(node, output, state) {\n        return (\n          <pre key={state.key}>\n            <code\n              {...node.attrs}\n              className={node.lang ? `lang-${node.lang}` : ''}\n            >\n              {node.text}\n            </code>\n          </pre>\n        )\n      },\n    } as MarkdownToJSX.Rule<{\n      attrs?: ReturnType<typeof attrStringToMap>\n      lang?: string\n      text: string\n    }>,\n\n    [RuleType.codeFenced]: {\n      match: blockRegex(CODE_BLOCK_FENCED_R),\n      order: Priority.MAX,\n      parse(capture /*, parse, state*/) {\n        return {\n          // if capture[3] it's additional metadata\n          attrs: attrStringToMap('code', capture[3] || ''),\n          lang: capture[2] || undefined,\n          text: capture[4],\n          type: RuleType.codeBlock,\n        }\n      },\n    },\n\n    [RuleType.codeInline]: {\n      match: simpleInlineRegex(CODE_INLINE_R),\n      order: Priority.LOW,\n      parse(capture /*, parse, state*/) {\n        return {\n          text: capture[2].replace(TEXT_UNESCAPE_R, '$1'),\n        }\n      },\n      render(node, output, state) {\n        return <code key={state.key}>{node.text}</code>\n      },\n    },\n\n    /**\n     * footnotes are emitted at the end of compilation in a special <footer> block\n     */\n    [RuleType.footnote]: {\n      match: blockRegex(FOOTNOTE_R),\n      order: Priority.MAX,\n      parse(capture /*, parse, state*/) {\n        footnotes.push({\n          footnote: capture[2],\n          identifier: capture[1],\n        })\n\n        return {}\n      },\n      render: renderNothing,\n    },\n\n    [RuleType.footnoteReference]: {\n      match: inlineRegex(FOOTNOTE_REFERENCE_R),\n      order: Priority.HIGH,\n      parse(capture /*, parse*/) {\n        return {\n          target: `#${options.slugify(capture[1], slugify)}`,\n          text: capture[1],\n        }\n      },\n      render(node, output, state) {\n        return (\n          <a key={state.key} href={options.sanitizer(node.target, 'a', 'href')}>\n            <sup key={state.key}>{node.text}</sup>\n          </a>\n        )\n      },\n    } as MarkdownToJSX.Rule<{ target: string; text: string }>,\n\n    [RuleType.gfmTask]: {\n      match: inlineRegex(GFM_TASK_R),\n      order: Priority.HIGH,\n      parse(capture /*, parse, state*/) {\n        return {\n          completed: capture[1].toLowerCase() === 'x',\n        }\n      },\n      render(node, output, state) {\n        return (\n          <input\n            checked={node.completed}\n            key={state.key}\n            readOnly\n            type=\"checkbox\"\n          />\n        )\n      },\n    } as MarkdownToJSX.Rule<{ completed: boolean }>,\n\n    [RuleType.heading]: {\n      match: blockRegex(\n        options.enforceAtxHeadings ? HEADING_ATX_COMPLIANT_R : HEADING_R\n      ),\n      order: Priority.HIGH,\n      parse(capture, parse, state) {\n        return {\n          children: parseInline(parse, capture[2], state),\n          id: options.slugify(capture[2], slugify),\n          level: capture[1].length as MarkdownToJSX.HeadingNode['level'],\n        }\n      },\n      render(node, output, state) {\n        return h(\n          `h${node.level}`,\n          { id: node.id, key: state.key },\n          output(node.children, state)\n        )\n      },\n    },\n\n    [RuleType.headingSetext]: {\n      match: blockRegex(HEADING_SETEXT_R),\n      order: Priority.MAX,\n      parse(capture, parse, state) {\n        return {\n          children: parseInline(parse, capture[1], state),\n          level: capture[2] === '=' ? 1 : 2,\n          type: RuleType.heading,\n        }\n      },\n    },\n\n    [RuleType.htmlBlock]: {\n      /**\n       * find the first matching end tag and process the interior\n       */\n      match: anyScopeRegex(HTML_BLOCK_ELEMENT_R),\n      order: Priority.HIGH,\n      parse(capture, parse, state) {\n        const [, whitespace] = capture[3].match(HTML_LEFT_TRIM_AMOUNT_R)\n\n        const trimmer = new RegExp(`^${whitespace}`, 'gm')\n        const trimmed = capture[3].replace(trimmer, '')\n\n        const parseFunc = containsBlockSyntax(trimmed)\n          ? parseBlock\n          : parseInline\n\n        const tagName = capture[1].toLowerCase() as MarkdownToJSX.HTMLTags\n        const noInnerParse =\n          DO_NOT_PROCESS_HTML_ELEMENTS.indexOf(tagName) !== -1\n\n        const tag = (\n          noInnerParse ? tagName : capture[1]\n        ).trim() as MarkdownToJSX.HTMLTags\n\n        const ast = {\n          attrs: attrStringToMap(tag, capture[2]),\n          noInnerParse: noInnerParse,\n          tag,\n        } as {\n          attrs: ReturnType<typeof attrStringToMap>\n          children?: ReturnType<MarkdownToJSX.NestedParser> | undefined\n          noInnerParse: Boolean\n          tag: MarkdownToJSX.HTMLTags\n          text?: string | undefined\n        }\n\n        state.inAnchor = state.inAnchor || tagName === 'a'\n\n        if (noInnerParse) {\n          ast.text = capture[3]\n        } else {\n          ast.children = parseFunc(parse, trimmed, state)\n        }\n\n        /**\n         * if another html block is detected within, parse as block,\n         * otherwise parse as inline to pick up any further markdown\n         */\n        state.inAnchor = false\n\n        return ast\n      },\n      render(node, output, state) {\n        return (\n          <node.tag key={state.key} {...node.attrs}>\n            {node.text || (node.children ? output(node.children, state) : '')}\n          </node.tag>\n        )\n      },\n    },\n\n    [RuleType.htmlSelfClosing]: {\n      /**\n       * find the first matching end tag and process the interior\n       */\n      match: anyScopeRegex(HTML_SELF_CLOSING_ELEMENT_R),\n      order: Priority.HIGH,\n      parse(capture /*, parse, state*/) {\n        const tag = capture[1].trim() as MarkdownToJSX.HTMLTags\n        return {\n          attrs: attrStringToMap(tag, capture[2] || ''),\n          tag,\n        }\n      },\n      render(node, output, state) {\n        return <node.tag {...node.attrs} key={state.key} />\n      },\n    },\n\n    [RuleType.htmlComment]: {\n      match: anyScopeRegex(HTML_COMMENT_R),\n      order: Priority.HIGH,\n      parse() {\n        return {}\n      },\n      render: renderNothing,\n    },\n\n    [RuleType.image]: {\n      match: simpleInlineRegex(IMAGE_R),\n      order: Priority.HIGH,\n      parse(capture /*, parse, state*/) {\n        return {\n          alt: capture[1],\n          target: unescapeUrl(capture[2]),\n          title: capture[3],\n        }\n      },\n      render(node, output, state) {\n        return (\n          <img\n            key={state.key}\n            alt={node.alt || undefined}\n            title={node.title || undefined}\n            src={options.sanitizer(node.target, 'img', 'src')}\n          />\n        )\n      },\n    } as MarkdownToJSX.Rule<{\n      alt?: string\n      target: string\n      title?: string\n    }>,\n\n    [RuleType.link]: {\n      match: inlineRegex(LINK_R),\n      order: Priority.LOW,\n      parse(capture, parse, state) {\n        return {\n          children: parseSimpleInline(parse, capture[1], state),\n          target: unescapeUrl(capture[2]),\n          title: capture[3],\n        }\n      },\n      render(node, output, state) {\n        return (\n          <a\n            key={state.key}\n            href={options.sanitizer(node.target, 'a', 'href')}\n            title={node.title}\n          >\n            {output(node.children, state)}\n          </a>\n        )\n      },\n    },\n\n    // https://daringfireball.net/projects/markdown/syntax#autolink\n    [RuleType.linkAngleBraceStyleDetector]: {\n      match: inlineRegex(LINK_AUTOLINK_R),\n      order: Priority.MAX,\n      parse(capture /*, parse, state*/) {\n        return {\n          children: [\n            {\n              text: capture[1],\n              type: RuleType.text,\n            },\n          ],\n          target: capture[1],\n          type: RuleType.link,\n        }\n      },\n    },\n\n    [RuleType.linkBareUrlDetector]: {\n      match: allowInline((source, state) => {\n        if (state.inAnchor || options.disableAutoLink) {\n          return null\n        }\n\n        return inlineRegex(LINK_AUTOLINK_BARE_URL_R)(source, state)\n      }),\n      order: Priority.MAX,\n      parse(capture /*, parse, state*/) {\n        return {\n          children: [\n            {\n              text: capture[1],\n              type: RuleType.text,\n            },\n          ],\n          target: capture[1],\n          title: undefined,\n          type: RuleType.link,\n        }\n      },\n    },\n\n    [RuleType.linkMailtoDetector]: {\n      match: inlineRegex(LINK_AUTOLINK_MAILTO_R),\n      order: Priority.MAX,\n      parse(capture /*, parse, state*/) {\n        let address = capture[1]\n        let target = capture[1]\n\n        // Check for a `mailto:` already existing in the link:\n        if (!AUTOLINK_MAILTO_CHECK_R.test(target)) {\n          target = 'mailto:' + target\n        }\n\n        return {\n          children: [\n            {\n              text: address.replace('mailto:', ''),\n              type: RuleType.text,\n            },\n          ],\n          target: target,\n          type: RuleType.link,\n        }\n      },\n    },\n\n    [RuleType.orderedList]: generateListRule(\n      h,\n      ORDERED\n    ) as MarkdownToJSX.Rule<MarkdownToJSX.OrderedListNode>,\n\n    [RuleType.unorderedList]: generateListRule(\n      h,\n      UNORDERED\n    ) as MarkdownToJSX.Rule<MarkdownToJSX.UnorderedListNode>,\n\n    [RuleType.newlineCoalescer]: {\n      match: blockRegex(CONSECUTIVE_NEWLINE_R),\n      order: Priority.LOW,\n      parse: captureNothing,\n      render(/*node, output, state*/) {\n        return '\\n'\n      },\n    },\n\n    [RuleType.paragraph]: {\n      match: allowInline(matchParagraph),\n      order: Priority.LOW,\n      parse: parseCaptureInline,\n      render(node, output, state) {\n        return <p key={state.key}>{output(node.children, state)}</p>\n      },\n    } as MarkdownToJSX.Rule<ReturnType<typeof parseCaptureInline>>,\n\n    [RuleType.ref]: {\n      match: inlineRegex(REFERENCE_IMAGE_OR_LINK),\n      order: Priority.MAX,\n      parse(capture /*, parse*/) {\n        refs[capture[1]] = {\n          target: capture[2],\n          title: capture[4],\n        }\n\n        return {}\n      },\n      render: renderNothing,\n    },\n\n    [RuleType.refImage]: {\n      match: simpleInlineRegex(REFERENCE_IMAGE_R),\n      order: Priority.MAX,\n      parse(capture) {\n        return {\n          alt: capture[1] || undefined,\n          ref: capture[2],\n        }\n      },\n      render(node, output, state) {\n        return refs[node.ref] ? (\n          <img\n            key={state.key}\n            alt={node.alt}\n            src={options.sanitizer(refs[node.ref].target, 'img', 'src')}\n            title={refs[node.ref].title}\n          />\n        ) : null\n      },\n    } as MarkdownToJSX.Rule<{ alt?: string; ref: string }>,\n\n    [RuleType.refLink]: {\n      match: inlineRegex(REFERENCE_LINK_R),\n      order: Priority.MAX,\n      parse(capture, parse, state) {\n        return {\n          children: parse(capture[1], state),\n          fallbackChildren: capture[0],\n          ref: capture[2],\n        }\n      },\n      render(node, output, state) {\n        return refs[node.ref] ? (\n          <a\n            key={state.key}\n            href={options.sanitizer(refs[node.ref].target, 'a', 'href')}\n            title={refs[node.ref].title}\n          >\n            {output(node.children, state)}\n          </a>\n        ) : (\n          <span key={state.key}>{node.fallbackChildren}</span>\n        )\n      },\n    },\n\n    [RuleType.table]: {\n      match: blockRegex(NP_TABLE_R),\n      order: Priority.HIGH,\n      parse: parseTable,\n      render(node, output, state) {\n        const table = node as MarkdownToJSX.TableNode\n        return (\n          <table key={state.key}>\n            <thead>\n              <tr>\n                {table.header.map(function generateHeaderCell(content, i) {\n                  return (\n                    <th key={i} style={getTableStyle(table, i)}>\n                      {output(content, state)}\n                    </th>\n                  )\n                })}\n              </tr>\n            </thead>\n\n            <tbody>\n              {table.cells.map(function generateTableRow(row, i) {\n                return (\n                  <tr key={i}>\n                    {row.map(function generateTableCell(content, c) {\n                      return (\n                        <td key={c} style={getTableStyle(table, c)}>\n                          {output(content, state)}\n                        </td>\n                      )\n                    })}\n                  </tr>\n                )\n              })}\n            </tbody>\n          </table>\n        )\n      },\n    },\n\n    [RuleType.text]: {\n      // Here we look for anything followed by non-symbols,\n      // double newlines, or double-space-newlines\n      // We break on any symbol characters so that this grammar\n      // is easy to extend without needing to modify this regex\n      match: anyScopeRegex(TEXT_PLAIN_R),\n      order: Priority.MIN,\n      parse(capture /*, parse, state*/) {\n        return {\n          text: capture[0]\n            // nbsp -> unicode equivalent for named chars\n            .replace(HTML_CHAR_CODE_R, (full, inner) => {\n              return options.namedCodesToUnicode[inner]\n                ? options.namedCodesToUnicode[inner]\n                : full\n            }),\n        }\n      },\n      render(node /*, output, state*/) {\n        return node.text\n      },\n    },\n\n    [RuleType.textBolded]: {\n      match: simpleInlineRegex(TEXT_BOLD_R),\n      order: Priority.MED,\n      parse(capture, parse, state) {\n        return {\n          // capture[1] -> the syntax control character\n          // capture[2] -> inner content\n          children: parse(capture[2], state),\n        }\n      },\n      render(node, output, state) {\n        return <strong key={state.key}>{output(node.children, state)}</strong>\n      },\n    },\n\n    [RuleType.textEmphasized]: {\n      match: simpleInlineRegex(TEXT_EMPHASIZED_R),\n      order: Priority.LOW,\n      parse(capture, parse, state) {\n        return {\n          // capture[1] -> opening * or _\n          // capture[2] -> inner content\n          children: parse(capture[2], state),\n        }\n      },\n      render(node, output, state) {\n        return <em key={state.key}>{output(node.children, state)}</em>\n      },\n    },\n\n    [RuleType.textEscaped]: {\n      // We don't allow escaping numbers, letters, or spaces here so that\n      // backslashes used in plain text still get rendered. But allowing\n      // escaping anything else provides a very flexible escape mechanism,\n      // regardless of how this grammar is extended.\n      match: simpleInlineRegex(TEXT_ESCAPED_R),\n      order: Priority.HIGH,\n      parse(capture /*, parse, state*/) {\n        return {\n          text: capture[1],\n          type: RuleType.text,\n        }\n      },\n    },\n\n    [RuleType.textMarked]: {\n      match: simpleInlineRegex(TEXT_MARKED_R),\n      order: Priority.LOW,\n      parse: parseCaptureInline,\n      render(node, output, state) {\n        return <mark key={state.key}>{output(node.children, state)}</mark>\n      },\n    },\n\n    [RuleType.textStrikethroughed]: {\n      match: simpleInlineRegex(TEXT_STRIKETHROUGHED_R),\n      order: Priority.LOW,\n      parse: parseCaptureInline,\n      render(node, output, state) {\n        return <del key={state.key}>{output(node.children, state)}</del>\n      },\n    },\n  }\n\n  // Object.keys(rules).forEach(key => {\n  //   let { match: match, parse: parse } = rules[key]\n\n  //   // rules[key].match = (...args) => {\n  //   //   const start = performance.now()\n  //   //   const result = match(...args)\n  //   //   const delta = performance.now() - start\n\n  //   //   if (delta > 5)\n  //   //     console.warn(\n  //   //       `Slow match for ${key}: ${delta.toFixed(3)}ms, input: ${args[0]}`\n  //   //     )\n\n  //   //   return result\n  //   // }\n\n  //   rules[key].parse = (...args) => {\n  //     const start = performance.now()\n  //     const result = parse(...args)\n  //     const delta = performance.now() - start\n\n  //     console[delta > 5 ? 'warn' : 'log'](\n  //       `${key}:parse`,\n  //       `${delta.toFixed(3)}ms`,\n  //       args[0]\n  //     )\n\n  //     return result\n  //   }\n  // })\n\n  if (options.disableParsingRawHTML === true) {\n    delete rules[RuleType.htmlBlock]\n    delete rules[RuleType.htmlSelfClosing]\n  }\n\n  const parser = parserFor(rules)\n  const emitter: Function = reactFor(createRenderer(rules, options.renderRule))\n\n  const jsx = compile(markdown)\n\n  if (footnotes.length) {\n    return (\n      <div>\n        {jsx}\n        <footer key=\"footer\">\n          {footnotes.map(function createFootnote(def) {\n            return (\n              <div\n                id={options.slugify(def.identifier, slugify)}\n                key={def.identifier}\n              >\n                {def.identifier}\n                {emitter(parser(def.footnote, { inline: true }))}\n              </div>\n            )\n          })}\n        </footer>\n      </div>\n    )\n  }\n\n  return jsx\n}\n\n/**\n * A simple HOC for easy React use. Feed the markdown content as a direct child\n * and the rest is taken care of automatically.\n */\nconst Markdown: React.FC<\n  Omit<React.HTMLAttributes<Element>, 'children'> & {\n    children: string\n    options?: MarkdownToJSX.Options\n  }\n> = ({ children = '', options, ...props }) => {\n  if (process.env.NODE_ENV !== 'production' && typeof children !== 'string') {\n    console.error(\n      'markdown-to-jsx: <Markdown> component only accepts a single string as a child, received:',\n      children\n    )\n  }\n\n  return React.cloneElement(\n    compiler(children, options),\n    props as React.JSX.IntrinsicAttributes\n  )\n}\n\nexport namespace MarkdownToJSX {\n  /**\n   * RequireAtLeastOne<{ ... }> <- only requires at least one key\n   */\n  type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<\n    T,\n    Exclude<keyof T, Keys>\n  > &\n    {\n      [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>\n    }[Keys]\n\n  export type CreateElement = typeof React.createElement\n\n  export type HTMLTags = keyof React.JSX.IntrinsicElements\n\n  export type State = {\n    /** true if the current content is inside anchor link grammar */\n    inAnchor?: boolean\n    /** true if parsing in an inline context (subset of rules around formatting and links) */\n    inline?: boolean\n    /** true if in a table */\n    inTable?: boolean\n    /** use this for the `key` prop */\n    key?: React.Key\n    /** true if in a list */\n    list?: boolean\n    /** used for lookbacks */\n    prevCapture?: string\n    /** true if parsing in inline context w/o links */\n    simple?: boolean\n  }\n\n  export interface BlockQuoteNode {\n    alert?: string\n    children: MarkdownToJSX.ParserResult[]\n    type: typeof RuleType.blockQuote\n  }\n\n  export interface BreakLineNode {\n    type: typeof RuleType.breakLine\n  }\n\n  export interface BreakThematicNode {\n    type: typeof RuleType.breakThematic\n  }\n\n  export interface CodeBlockNode {\n    type: typeof RuleType.codeBlock\n    attrs?: React.JSX.IntrinsicAttributes\n    lang?: string\n    text: string\n  }\n\n  export interface CodeFencedNode {\n    type: typeof RuleType.codeFenced\n  }\n\n  export interface CodeInlineNode {\n    type: typeof RuleType.codeInline\n    text: string\n  }\n\n  export interface FootnoteNode {\n    type: typeof RuleType.footnote\n  }\n\n  export interface FootnoteReferenceNode {\n    type: typeof RuleType.footnoteReference\n    target: string\n    text: string\n  }\n\n  export interface GFMTaskNode {\n    type: typeof RuleType.gfmTask\n    completed: boolean\n  }\n\n  export interface HeadingNode {\n    type: typeof RuleType.heading\n    children: MarkdownToJSX.ParserResult[]\n    id: string\n    level: 1 | 2 | 3 | 4 | 5 | 6\n  }\n\n  export interface HeadingSetextNode {\n    type: typeof RuleType.headingSetext\n  }\n\n  export interface HTMLCommentNode {\n    type: typeof RuleType.htmlComment\n  }\n\n  export interface ImageNode {\n    type: typeof RuleType.image\n    alt?: string\n    target: string\n    title?: string\n  }\n\n  export interface LinkNode {\n    type: typeof RuleType.link\n    children: MarkdownToJSX.ParserResult[]\n    target: string\n    title?: string\n  }\n\n  export interface LinkAngleBraceNode {\n    type: typeof RuleType.linkAngleBraceStyleDetector\n  }\n\n  export interface LinkBareURLNode {\n    type: typeof RuleType.linkBareUrlDetector\n  }\n\n  export interface LinkMailtoNode {\n    type: typeof RuleType.linkMailtoDetector\n  }\n\n  export interface OrderedListNode {\n    type: typeof RuleType.orderedList\n    items: MarkdownToJSX.ParserResult[][]\n    ordered: true\n    start?: number\n  }\n\n  export interface UnorderedListNode {\n    type: typeof RuleType.unorderedList\n    items: MarkdownToJSX.ParserResult[][]\n    ordered: false\n  }\n\n  export interface NewlineNode {\n    type: typeof RuleType.newlineCoalescer\n  }\n\n  export interface ParagraphNode {\n    type: typeof RuleType.paragraph\n    children: MarkdownToJSX.ParserResult[]\n  }\n\n  export interface ReferenceNode {\n    type: typeof RuleType.ref\n  }\n\n  export interface ReferenceImageNode {\n    type: typeof RuleType.refImage\n    alt?: string\n    ref: string\n  }\n\n  export interface ReferenceLinkNode {\n    type: typeof RuleType.refLink\n    children: MarkdownToJSX.ParserResult[]\n    fallbackChildren: string\n    ref: string\n  }\n\n  export interface TableNode {\n    type: typeof RuleType.table\n    /**\n     * alignment for each table column\n     */\n    align: ('left' | 'right' | 'center')[]\n    cells: MarkdownToJSX.ParserResult[][][]\n    header: MarkdownToJSX.ParserResult[][]\n  }\n\n  export interface TableSeparatorNode {\n    type: typeof RuleType.tableSeparator\n  }\n\n  export interface TextNode {\n    type: typeof RuleType.text\n    text: string\n  }\n\n  export interface BoldTextNode {\n    type: typeof RuleType.textBolded\n    children: MarkdownToJSX.ParserResult[]\n  }\n\n  export interface ItalicTextNode {\n    type: typeof RuleType.textEmphasized\n    children: MarkdownToJSX.ParserResult[]\n  }\n\n  export interface EscapedTextNode {\n    type: typeof RuleType.textEscaped\n  }\n\n  export interface MarkedTextNode {\n    type: typeof RuleType.textMarked\n    children: MarkdownToJSX.ParserResult[]\n  }\n\n  export interface StrikethroughTextNode {\n    type: typeof RuleType.textStrikethroughed\n    children: MarkdownToJSX.ParserResult[]\n  }\n\n  export interface HTMLNode {\n    type: typeof RuleType.htmlBlock\n    attrs: React.JSX.IntrinsicAttributes\n    children?: ReturnType<MarkdownToJSX.NestedParser> | undefined\n    noInnerParse: Boolean\n    tag: MarkdownToJSX.HTMLTags\n    text?: string | undefined\n  }\n\n  export interface HTMLSelfClosingNode {\n    type: typeof RuleType.htmlSelfClosing\n    attrs: React.JSX.IntrinsicAttributes\n    tag: string\n  }\n\n  export type ParserResult =\n    | BlockQuoteNode\n    | BreakLineNode\n    | BreakThematicNode\n    | CodeBlockNode\n    | CodeFencedNode\n    | CodeInlineNode\n    | FootnoteNode\n    | FootnoteReferenceNode\n    | GFMTaskNode\n    | HeadingNode\n    | HeadingSetextNode\n    | HTMLCommentNode\n    | ImageNode\n    | LinkNode\n    | LinkAngleBraceNode\n    | LinkBareURLNode\n    | LinkMailtoNode\n    | OrderedListNode\n    | UnorderedListNode\n    | NewlineNode\n    | ParagraphNode\n    | ReferenceNode\n    | ReferenceImageNode\n    | ReferenceLinkNode\n    | TableNode\n    | TableSeparatorNode\n    | TextNode\n    | BoldTextNode\n    | ItalicTextNode\n    | EscapedTextNode\n    | MarkedTextNode\n    | StrikethroughTextNode\n    | HTMLNode\n    | HTMLSelfClosingNode\n\n  export type NestedParser = (\n    input: string,\n    state?: MarkdownToJSX.State\n  ) => MarkdownToJSX.ParserResult[]\n\n  export type Parser<ParserOutput> = (\n    capture: RegExpMatchArray,\n    nestedParse: NestedParser,\n    state?: MarkdownToJSX.State\n  ) => ParserOutput\n\n  export type RuleOutput = (\n    ast: MarkdownToJSX.ParserResult | MarkdownToJSX.ParserResult[],\n    state: MarkdownToJSX.State\n  ) => React.JSX.Element\n\n  export type Rule<ParserOutput = MarkdownToJSX.ParserResult> = {\n    match: (\n      source: string,\n      state: MarkdownToJSX.State,\n      prevCapturedString?: string\n    ) => RegExpMatchArray\n    order: Priority\n    parse: MarkdownToJSX.Parser<Omit<ParserOutput, 'type'>>\n    render?: (\n      node: ParserOutput,\n      /**\n       * Continue rendering AST nodes if applicable.\n       */\n      render: RuleOutput,\n      state?: MarkdownToJSX.State\n    ) => React.ReactNode\n  }\n\n  export type Rules = {\n    [K in ParserResult['type']]: K extends typeof RuleType.table\n      ? Rule<Extract<ParserResult, { type: K | typeof RuleType.paragraph }>>\n      : Rule<Extract<ParserResult, { type: K }>>\n  }\n\n  export type Override =\n    | RequireAtLeastOne<{\n        component: React.ElementType\n        props: Object\n      }>\n    | React.ElementType\n\n  export type Overrides = {\n    [tag in HTMLTags]?: Override\n  } & {\n    [customComponent: string]: Override\n  }\n\n  export type Options = Partial<{\n    /**\n     * Ultimate control over the output of all rendered JSX.\n     */\n    createElement: (\n      tag: Parameters<CreateElement>[0],\n      props: React.JSX.IntrinsicAttributes,\n      ...children: React.ReactNode[]\n    ) => React.ReactNode\n\n    /**\n     * The library automatically generates an anchor tag for bare URLs included in the markdown\n     * document, but this behavior can be disabled if desired.\n     */\n    disableAutoLink: boolean\n\n    /**\n     * Disable the compiler's best-effort transcription of provided raw HTML\n     * into JSX-equivalent. This is the functionality that prevents the need to\n     * use `dangerouslySetInnerHTML` in React.\n     */\n    disableParsingRawHTML: boolean\n\n    /**\n     * Forces the compiler to have space between hash sign and the header text which\n     * is explicitly stated in the most of the markdown specs.\n     * https://github.github.com/gfm/#atx-heading\n     * `The opening sequence of # characters must be followed by a space or by the end of line.`\n     */\n    enforceAtxHeadings: boolean\n\n    /**\n     * Forces the compiler to always output content with a block-level wrapper\n     * (`<p>` or any block-level syntax your markdown already contains.)\n     */\n    forceBlock: boolean\n\n    /**\n     * Forces the compiler to always output content with an inline wrapper (`<span>`)\n     */\n    forceInline: boolean\n\n    /**\n     * Forces the compiler to wrap results, even if there is only a single\n     * child or no children.\n     */\n    forceWrapper: boolean\n\n    /**\n     * Supply additional HTML entity: unicode replacement mappings.\n     *\n     * Pass only the inner part of the entity as the key,\n     * e.g. `&le;` -> `{ \"le\": \"\\u2264\" }`\n     *\n     * By default\n     * the following entities are replaced with their unicode equivalents:\n     *\n     * ```\n     * &amp;\n     * &apos;\n     * &gt;\n     * &lt;\n     * &nbsp;\n     * &quot;\n     * ```\n     */\n    namedCodesToUnicode: {\n      [key: string]: string\n    }\n\n    /**\n     * Selectively control the output of particular HTML tags as they would be\n     * emitted by the compiler.\n     */\n    overrides: Overrides\n\n    /**\n     * Allows for full control over rendering of particular rules.\n     * For example, to implement a LaTeX renderer such as `react-katex`:\n     *\n     * ```\n     * renderRule(next, node, renderChildren, state) {\n     *   if (node.type === RuleType.codeBlock && node.lang === 'latex') {\n     *     return (\n     *       <TeX as=\"div\" key={state.key}>\n     *         {String.raw`${node.text}`}\n     *       </TeX>\n     *     )\n     *   }\n     *\n     *   return next();\n     * }\n     * ```\n     *\n     * Thar be dragons obviously, but you can do a lot with this\n     * (have fun!) To see how things work internally, check the `render`\n     * method in source for a particular rule.\n     */\n    renderRule: (\n      /** Resume normal processing, call this function as a fallback if you are not returning custom JSX. */\n      next: () => React.ReactNode,\n      /** the current AST node, use `RuleType` against `node.type` for identification */\n      node: ParserResult,\n      /** use as `renderChildren(node.children)` for block nodes */\n      renderChildren: RuleOutput,\n      /** contains `key` which should be supplied to the topmost JSX element */\n      state: State\n    ) => React.ReactNode\n\n    /**\n     * Override the built-in sanitizer function for URLs, etc if desired. The built-in version is available as a library export called `sanitizer`.\n     */\n    sanitizer: (\n      value: string,\n      tag: HTMLTags,\n      attribute: string\n    ) => string | null\n\n    /**\n     * Override normalization of non-URI-safe characters for use in generating\n     * HTML IDs for anchor linking purposes.\n     */\n    slugify: (input: string, defaultFn: (input: string) => string) => string\n\n    /**\n     * Declare the type of the wrapper to be used when there are multiple\n     * children to render. Set to `null` to get an array of children back\n     * without any wrapper, or use `React.Fragment` to get a React element\n     * that won't show up in the DOM.\n     */\n    wrapper: React.ElementType | null\n  }>\n}\n\nexport default Markdown\n","import Markdown, { compiler, RuleType } from './index.tsx'\n\nObject.assign(Markdown, { compiler, RuleType })\n\nexport default Markdown as typeof Markdown & {\n  compiler: typeof compiler\n  RuleType: typeof RuleType\n}\n"],"names":["Priority","RuleType","blockQuote","breakLine","breakThematic","codeBlock","codeFenced","codeInline","footnote","footnoteReference","gfmTask","heading","headingSetext","htmlBlock","htmlComment","htmlSelfClosing","image","link","linkAngleBraceStyleDetector","linkBareUrlDetector","linkMailtoDetector","newlineCoalescer","orderedList","paragraph","ref","refImage","refLink","table","tableSeparator","text","textBolded","textEmphasized","textEscaped","textMarked","textStrikethroughed","unorderedList","ATTRIBUTE_TO_JSX_PROP_MAP","reduce","obj","x","toLowerCase","class","for","namedCodesToUnicode","amp","apos","gt","lt","nbsp","quot","DO_NOT_PROCESS_HTML_ELEMENTS","ATTRIBUTES_TO_SANITIZE","ATTR_EXTRACTOR_R","AUTOLINK_MAILTO_CHECK_R","BLOCK_END_R","BLOCKQUOTE_R","BLOCKQUOTE_TRIM_LEFT_MULTILINE_R","BLOCKQUOTE_ALERT_R","BREAK_LINE_R","BREAK_THEMATIC_R","CODE_BLOCK_FENCED_R","CODE_BLOCK_R","CODE_INLINE_R","CONSECUTIVE_NEWLINE_R","CR_NEWLINE_R","FOOTNOTE_R","FOOTNOTE_REFERENCE_R","FORMFEED_R","FRONT_MATTER_R","GFM_TASK_R","HEADING_R","HEADING_ATX_COMPLIANT_R","HEADING_SETEXT_R","HTML_BLOCK_ELEMENT_R","HTML_CHAR_CODE_R","HTML_COMMENT_R","HTML_CUSTOM_ATTR_R","HTML_SELF_CLOSING_ELEMENT_R","INTERPOLATION_R","LINK_AUTOLINK_BARE_URL_R","LINK_AUTOLINK_MAILTO_R","LINK_AUTOLINK_R","CAPTURE_LETTER_AFTER_HYPHEN","NP_TABLE_R","PARAGRAPH_R","REFERENCE_IMAGE_OR_LINK","REFERENCE_IMAGE_R","REFERENCE_LINK_R","SHOULD_RENDER_AS_BLOCK_R","TAB_R","TABLE_TRIM_PIPES","TABLE_CENTER_ALIGN","TABLE_LEFT_ALIGN","TABLE_RIGHT_ALIGN","INLINE_SKIP_R","TEXT_BOLD_R","RegExp","TEXT_EMPHASIZED_R","TEXT_MARKED_R","TEXT_STRIKETHROUGHED_R","TEXT_ESCAPED_R","TEXT_UNESCAPE_R","TEXT_PLAIN_R","TRIM_STARTING_NEWLINES","HTML_LEFT_TRIM_AMOUNT_R","UNESCAPE_URL_R","LIST_LOOKBEHIND_R","ORDERED_LIST_BULLET","UNORDERED_LIST_BULLET","generateListItemPrefix","type","ORDERED_LIST_ITEM_PREFIX","UNORDERED_LIST_ITEM_PREFIX","generateListItemPrefixRegex","ORDERED_LIST_ITEM_PREFIX_R","UNORDERED_LIST_ITEM_PREFIX_R","generateListItemRegex","ORDERED_LIST_ITEM_R","UNORDERED_LIST_ITEM_R","generateListRegex","bullet","ORDERED_LIST_R","UNORDERED_LIST_R","generateListRule","h","ordered","LIST_R","LIST_ITEM_R","LIST_ITEM_PREFIX_R","match","allowInline","source","state","isStartOfLine","exec","prevCapture","list","inline","simple","order","parse","capture","start","undefined","items","replace","lastItemWasAParagraph","map","item","i","space","length","spaceRegex","content","isLastItem","thisItemIsAParagraph","indexOf","adjustedContent","oldStateInline","oldStateList","trimEnd","result","render","node","output","key","LINK_R","IMAGE_R","str","end","slice","slugify","parseTableAlignCapture","alignCapture","test","parseTableRow","tableOutput","prevInTable","inTable","cells","acc","flush","cell","push","apply","trim","split","filter","Boolean","forEach","fragment","arr","parseTable","align","rowText","parseTableCells","header","children","getTableStyle","colIndex","textAlign","fn","inlineRegex","regex","simpleInlineRegex","blockRegex","anyScopeRegex","SANITIZE_R","sanitizer","input","decoded","decodeURIComponent","e","unescapeUrl","rawUrlString","parseInline","isCurrentlyInline","isCurrentlySimple","parseSimpleInline","parseBlock","parseCaptureInline","captureNothing","renderNothing","cx","call","arguments","join","get","src","path","fb","ptr","frags","shift","getTag","tag","overrides","override","compiler","markdown","options","_extends","createElement","React","NON_PARAGRAPH_BLOCK_SYNTAXES","enforceAtxHeadings","BLOCK_SYNTAXES","concat","props","overrideProps","_options","className","compile","forceInline","forceBlock","emitter","parser","pop","wrapper","jsx","forceWrapper","attrStringToMap","attributes","raw","delimiterIdx","_","letter","toUpperCase","normalizeAttributeKey","value","first","unquote","mappedKey","normalizedValue","sanitizeUrlFn","styleString","styles","buffer","inUrl","inQuotes","quoteChar","char","endsWith","declaration","colonIndex","parseStyleAttribute","_ref","substr","attributeValueToJSXPropValue","footnotes","refs","rules","_rules","_capture$0$replace$ma","alert","unshift","attrs","noInnerParse","__","lang","identifier","target","href","completed","checked","readOnly","id","level","_capture$3$match","trimmer","trimmed","parseFunc","some","r","tagName","ast","inAnchor","alt","title","disableAutoLink","address","every","line","captured","fallbackChildren","style","row","c","full","inner","disableParsingRawHTML","ruleList","Object","keys","nestedParse","rule","parsed","ruleType","currCaptureString","substring","sort","typeA","typeB","orderA","orderB","normalizeWhitespace","parserFor","userRender","renderer","createRenderer","renderRule","patchedRender","Array","isArray","oldKey","lastWasString","nodeOut","isString","def","Markdown","_ref2","_ref2$children","_objectWithoutPropertiesLoose","_excluded","cloneElement","assign"],"mappings":"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"}