{"version":3,"file":"react/js/5027.165cd1424b9623668938.js","mappings":"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","sources":["webpack:///./node_modules/md5/md5.js","webpack:///./node_modules/mdast-util-from-markdown/lib/index.js","webpack:///./node_modules/mdast-util-find-and-replace/lib/index.js","webpack:///./node_modules/mdast-util-find-and-replace/node_modules/escape-string-regexp/index.js","webpack:///./node_modules/mdast-util-gfm-autolink-literal/lib/index.js","webpack:///./node_modules/mdast-util-gfm-footnote/lib/index.js","webpack:///./node_modules/mdast-util-gfm-strikethrough/lib/index.js","webpack:///./node_modules/mdast-util-gfm-table/lib/index.js","webpack:///./node_modules/mdast-util-gfm-task-list-item/lib/index.js","webpack:///./node_modules/mdast-util-gfm/lib/index.js","webpack:///./node_modules/mdast-util-phrasing/lib/index.js","webpack:///./node_modules/mdast-util-to-string/lib/index.js"],"sourcesContent":["(function(){\r\n  var crypt = require('crypt'),\r\n      utf8 = require('charenc').utf8,\r\n      isBuffer = require('is-buffer'),\r\n      bin = require('charenc').bin,\r\n\r\n  // The core\r\n  md5 = function (message, options) {\r\n    // Convert to byte array\r\n    if (message.constructor == String)\r\n      if (options && options.encoding === 'binary')\r\n        message = bin.stringToBytes(message);\r\n      else\r\n        message = utf8.stringToBytes(message);\r\n    else if (isBuffer(message))\r\n      message = Array.prototype.slice.call(message, 0);\r\n    else if (!Array.isArray(message) && message.constructor !== Uint8Array)\r\n      message = message.toString();\r\n    // else, assume byte array already\r\n\r\n    var m = crypt.bytesToWords(message),\r\n        l = message.length * 8,\r\n        a =  1732584193,\r\n        b = -271733879,\r\n        c = -1732584194,\r\n        d =  271733878;\r\n\r\n    // Swap endian\r\n    for (var i = 0; i < m.length; i++) {\r\n      m[i] = ((m[i] <<  8) | (m[i] >>> 24)) & 0x00FF00FF |\r\n             ((m[i] << 24) | (m[i] >>>  8)) & 0xFF00FF00;\r\n    }\r\n\r\n    // Padding\r\n    m[l >>> 5] |= 0x80 << (l % 32);\r\n    m[(((l + 64) >>> 9) << 4) + 14] = l;\r\n\r\n    // Method shortcuts\r\n    var FF = md5._ff,\r\n        GG = md5._gg,\r\n        HH = md5._hh,\r\n        II = md5._ii;\r\n\r\n    for (var i = 0; i < m.length; i += 16) {\r\n\r\n      var aa = a,\r\n          bb = b,\r\n          cc = c,\r\n          dd = d;\r\n\r\n      a = FF(a, b, c, d, m[i+ 0],  7, -680876936);\r\n      d = FF(d, a, b, c, m[i+ 1], 12, -389564586);\r\n      c = FF(c, d, a, b, m[i+ 2], 17,  606105819);\r\n      b = FF(b, c, d, a, m[i+ 3], 22, -1044525330);\r\n      a = FF(a, b, c, d, m[i+ 4],  7, -176418897);\r\n      d = FF(d, a, b, c, m[i+ 5], 12,  1200080426);\r\n      c = FF(c, d, a, b, m[i+ 6], 17, -1473231341);\r\n      b = FF(b, c, d, a, m[i+ 7], 22, -45705983);\r\n      a = FF(a, b, c, d, m[i+ 8],  7,  1770035416);\r\n      d = FF(d, a, b, c, m[i+ 9], 12, -1958414417);\r\n      c = FF(c, d, a, b, m[i+10], 17, -42063);\r\n      b = FF(b, c, d, a, m[i+11], 22, -1990404162);\r\n      a = FF(a, b, c, d, m[i+12],  7,  1804603682);\r\n      d = FF(d, a, b, c, m[i+13], 12, -40341101);\r\n      c = FF(c, d, a, b, m[i+14], 17, -1502002290);\r\n      b = FF(b, c, d, a, m[i+15], 22,  1236535329);\r\n\r\n      a = GG(a, b, c, d, m[i+ 1],  5, -165796510);\r\n      d = GG(d, a, b, c, m[i+ 6],  9, -1069501632);\r\n      c = GG(c, d, a, b, m[i+11], 14,  643717713);\r\n      b = GG(b, c, d, a, m[i+ 0], 20, -373897302);\r\n      a = GG(a, b, c, d, m[i+ 5],  5, -701558691);\r\n      d = GG(d, a, b, c, m[i+10],  9,  38016083);\r\n      c = GG(c, d, a, b, m[i+15], 14, -660478335);\r\n      b = GG(b, c, d, a, m[i+ 4], 20, -405537848);\r\n      a = GG(a, b, c, d, m[i+ 9],  5,  568446438);\r\n      d = GG(d, a, b, c, m[i+14],  9, -1019803690);\r\n      c = GG(c, d, a, b, m[i+ 3], 14, -187363961);\r\n      b = GG(b, c, d, a, m[i+ 8], 20,  1163531501);\r\n      a = GG(a, b, c, d, m[i+13],  5, -1444681467);\r\n      d = GG(d, a, b, c, m[i+ 2],  9, -51403784);\r\n      c = GG(c, d, a, b, m[i+ 7], 14,  1735328473);\r\n      b = GG(b, c, d, a, m[i+12], 20, -1926607734);\r\n\r\n      a = HH(a, b, c, d, m[i+ 5],  4, -378558);\r\n      d = HH(d, a, b, c, m[i+ 8], 11, -2022574463);\r\n      c = HH(c, d, a, b, m[i+11], 16,  1839030562);\r\n      b = HH(b, c, d, a, m[i+14], 23, -35309556);\r\n      a = HH(a, b, c, d, m[i+ 1],  4, -1530992060);\r\n      d = HH(d, a, b, c, m[i+ 4], 11,  1272893353);\r\n      c = HH(c, d, a, b, m[i+ 7], 16, -155497632);\r\n      b = HH(b, c, d, a, m[i+10], 23, -1094730640);\r\n      a = HH(a, b, c, d, m[i+13],  4,  681279174);\r\n      d = HH(d, a, b, c, m[i+ 0], 11, -358537222);\r\n      c = HH(c, d, a, b, m[i+ 3], 16, -722521979);\r\n      b = HH(b, c, d, a, m[i+ 6], 23,  76029189);\r\n      a = HH(a, b, c, d, m[i+ 9],  4, -640364487);\r\n      d = HH(d, a, b, c, m[i+12], 11, -421815835);\r\n      c = HH(c, d, a, b, m[i+15], 16,  530742520);\r\n      b = HH(b, c, d, a, m[i+ 2], 23, -995338651);\r\n\r\n      a = II(a, b, c, d, m[i+ 0],  6, -198630844);\r\n      d = II(d, a, b, c, m[i+ 7], 10,  1126891415);\r\n      c = II(c, d, a, b, m[i+14], 15, -1416354905);\r\n      b = II(b, c, d, a, m[i+ 5], 21, -57434055);\r\n      a = II(a, b, c, d, m[i+12],  6,  1700485571);\r\n      d = II(d, a, b, c, m[i+ 3], 10, -1894986606);\r\n      c = II(c, d, a, b, m[i+10], 15, -1051523);\r\n      b = II(b, c, d, a, m[i+ 1], 21, -2054922799);\r\n      a = II(a, b, c, d, m[i+ 8],  6,  1873313359);\r\n      d = II(d, a, b, c, m[i+15], 10, -30611744);\r\n      c = II(c, d, a, b, m[i+ 6], 15, -1560198380);\r\n      b = II(b, c, d, a, m[i+13], 21,  1309151649);\r\n      a = II(a, b, c, d, m[i+ 4],  6, -145523070);\r\n      d = II(d, a, b, c, m[i+11], 10, -1120210379);\r\n      c = II(c, d, a, b, m[i+ 2], 15,  718787259);\r\n      b = II(b, c, d, a, m[i+ 9], 21, -343485551);\r\n\r\n      a = (a + aa) >>> 0;\r\n      b = (b + bb) >>> 0;\r\n      c = (c + cc) >>> 0;\r\n      d = (d + dd) >>> 0;\r\n    }\r\n\r\n    return crypt.endian([a, b, c, d]);\r\n  };\r\n\r\n  // Auxiliary functions\r\n  md5._ff  = function (a, b, c, d, x, s, t) {\r\n    var n = a + (b & c | ~b & d) + (x >>> 0) + t;\r\n    return ((n << s) | (n >>> (32 - s))) + b;\r\n  };\r\n  md5._gg  = function (a, b, c, d, x, s, t) {\r\n    var n = a + (b & d | c & ~d) + (x >>> 0) + t;\r\n    return ((n << s) | (n >>> (32 - s))) + b;\r\n  };\r\n  md5._hh  = function (a, b, c, d, x, s, t) {\r\n    var n = a + (b ^ c ^ d) + (x >>> 0) + t;\r\n    return ((n << s) | (n >>> (32 - s))) + b;\r\n  };\r\n  md5._ii  = function (a, b, c, d, x, s, t) {\r\n    var n = a + (c ^ (b | ~d)) + (x >>> 0) + t;\r\n    return ((n << s) | (n >>> (32 - s))) + b;\r\n  };\r\n\r\n  // Package private blocksize\r\n  md5._blocksize = 16;\r\n  md5._digestsize = 16;\r\n\r\n  module.exports = function (message, options) {\r\n    if (message === undefined || message === null)\r\n      throw new Error('Illegal argument ' + message);\r\n\r\n    var digestbytes = crypt.wordsToBytes(md5(message, options));\r\n    return options && options.asBytes ? digestbytes :\r\n        options && options.asString ? bin.bytesToString(digestbytes) :\r\n        crypt.bytesToHex(digestbytes);\r\n  };\r\n\r\n})();\r\n","/**\n * @typedef {import('mdast').Break} Break\n * @typedef {import('mdast').Blockquote} Blockquote\n * @typedef {import('mdast').Code} Code\n * @typedef {import('mdast').Definition} Definition\n * @typedef {import('mdast').Emphasis} Emphasis\n * @typedef {import('mdast').Heading} Heading\n * @typedef {import('mdast').Html} Html\n * @typedef {import('mdast').Image} Image\n * @typedef {import('mdast').InlineCode} InlineCode\n * @typedef {import('mdast').Link} Link\n * @typedef {import('mdast').List} List\n * @typedef {import('mdast').ListItem} ListItem\n * @typedef {import('mdast').Nodes} Nodes\n * @typedef {import('mdast').Paragraph} Paragraph\n * @typedef {import('mdast').Parent} Parent\n * @typedef {import('mdast').PhrasingContent} PhrasingContent\n * @typedef {import('mdast').ReferenceType} ReferenceType\n * @typedef {import('mdast').Root} Root\n * @typedef {import('mdast').Strong} Strong\n * @typedef {import('mdast').Text} Text\n * @typedef {import('mdast').ThematicBreak} ThematicBreak\n *\n * @typedef {import('micromark-util-types').Encoding} Encoding\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').ParseOptions} ParseOptions\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Value} Value\n *\n * @typedef {import('unist').Point} Point\n *\n * @typedef {import('../index.js').CompileData} CompileData\n */\n\n/**\n * @typedef {Omit<Parent, 'children' | 'type'> & {type: 'fragment', children: Array<PhrasingContent>}} Fragment\n */\n\n/**\n * @callback Transform\n *   Extra transform, to change the AST afterwards.\n * @param {Root} tree\n *   Tree to transform.\n * @returns {Root | null | undefined | void}\n *   New tree or nothing (in which case the current tree is used).\n *\n * @callback Handle\n *   Handle a token.\n * @param {CompileContext} this\n *   Context.\n * @param {Token} token\n *   Current token.\n * @returns {undefined | void}\n *   Nothing.\n *\n * @typedef {Record<string, Handle>} Handles\n *   Token types mapping to handles\n *\n * @callback OnEnterError\n *   Handle the case where the `right` token is open, but it is closed (by the\n *   `left` token) or because we reached the end of the document.\n * @param {Omit<CompileContext, 'sliceSerialize'>} this\n *   Context.\n * @param {Token | undefined} left\n *   Left token.\n * @param {Token} right\n *   Right token.\n * @returns {undefined}\n *   Nothing.\n *\n * @callback OnExitError\n *   Handle the case where the `right` token is open but it is closed by\n *   exiting the `left` token.\n * @param {Omit<CompileContext, 'sliceSerialize'>} this\n *   Context.\n * @param {Token} left\n *   Left token.\n * @param {Token} right\n *   Right token.\n * @returns {undefined}\n *   Nothing.\n *\n * @typedef {[Token, OnEnterError | undefined]} TokenTuple\n *   Open token on the stack, with an optional error handler for when\n *   that token isn’t closed properly.\n */\n\n/**\n * @typedef Config\n *   Configuration.\n *\n *   We have our defaults, but extensions will add more.\n * @property {Array<string>} canContainEols\n *   Token types where line endings are used.\n * @property {Handles} enter\n *   Opening handles.\n * @property {Handles} exit\n *   Closing handles.\n * @property {Array<Transform>} transforms\n *   Tree transforms.\n *\n * @typedef {Partial<Config>} Extension\n *   Change how markdown tokens from micromark are turned into mdast.\n *\n * @typedef CompileContext\n *   mdast compiler context.\n * @property {Array<Fragment | Nodes>} stack\n *   Stack of nodes.\n * @property {Array<TokenTuple>} tokenStack\n *   Stack of tokens.\n * @property {(this: CompileContext) => undefined} buffer\n *   Capture some of the output data.\n * @property {(this: CompileContext) => string} resume\n *   Stop capturing and access the output data.\n * @property {(this: CompileContext, node: Nodes, token: Token, onError?: OnEnterError) => undefined} enter\n *   Enter a node.\n * @property {(this: CompileContext, token: Token, onError?: OnExitError) => undefined} exit\n *   Exit a node.\n * @property {TokenizeContext['sliceSerialize']} sliceSerialize\n *   Get the string value of a token.\n * @property {Config} config\n *   Configuration.\n * @property {CompileData} data\n *   Info passed around; key/value store.\n *\n * @typedef FromMarkdownOptions\n *   Configuration for how to build mdast.\n * @property {Array<Extension | Array<Extension>> | null | undefined} [mdastExtensions]\n *   Extensions for this utility to change how tokens are turned into a tree.\n *\n * @typedef {ParseOptions & FromMarkdownOptions} Options\n *   Configuration.\n */\n\nimport { toString } from 'mdast-util-to-string';\nimport { parse, postprocess, preprocess } from 'micromark';\nimport { decodeNumericCharacterReference } from 'micromark-util-decode-numeric-character-reference';\nimport { decodeString } from 'micromark-util-decode-string';\nimport { normalizeIdentifier } from 'micromark-util-normalize-identifier';\nimport { decodeNamedCharacterReference } from 'decode-named-character-reference';\nimport { stringifyPosition } from 'unist-util-stringify-position';\nconst own = {}.hasOwnProperty;\n\n/**\n * Turn markdown into a syntax tree.\n *\n * @overload\n * @param {Value} value\n * @param {Encoding | null | undefined} [encoding]\n * @param {Options | null | undefined} [options]\n * @returns {Root}\n *\n * @overload\n * @param {Value} value\n * @param {Options | null | undefined} [options]\n * @returns {Root}\n *\n * @param {Value} value\n *   Markdown to parse.\n * @param {Encoding | Options | null | undefined} [encoding]\n *   Character encoding for when `value` is `Buffer`.\n * @param {Options | null | undefined} [options]\n *   Configuration.\n * @returns {Root}\n *   mdast tree.\n */\nexport function fromMarkdown(value, encoding, options) {\n  if (typeof encoding !== 'string') {\n    options = encoding;\n    encoding = undefined;\n  }\n  return compiler(options)(postprocess(parse(options).document().write(preprocess()(value, encoding, true))));\n}\n\n/**\n * Note this compiler only understand complete buffering, not streaming.\n *\n * @param {Options | null | undefined} [options]\n */\nfunction compiler(options) {\n  /** @type {Config} */\n  const config = {\n    transforms: [],\n    canContainEols: ['emphasis', 'fragment', 'heading', 'paragraph', 'strong'],\n    enter: {\n      autolink: opener(link),\n      autolinkProtocol: onenterdata,\n      autolinkEmail: onenterdata,\n      atxHeading: opener(heading),\n      blockQuote: opener(blockQuote),\n      characterEscape: onenterdata,\n      characterReference: onenterdata,\n      codeFenced: opener(codeFlow),\n      codeFencedFenceInfo: buffer,\n      codeFencedFenceMeta: buffer,\n      codeIndented: opener(codeFlow, buffer),\n      codeText: opener(codeText, buffer),\n      codeTextData: onenterdata,\n      data: onenterdata,\n      codeFlowValue: onenterdata,\n      definition: opener(definition),\n      definitionDestinationString: buffer,\n      definitionLabelString: buffer,\n      definitionTitleString: buffer,\n      emphasis: opener(emphasis),\n      hardBreakEscape: opener(hardBreak),\n      hardBreakTrailing: opener(hardBreak),\n      htmlFlow: opener(html, buffer),\n      htmlFlowData: onenterdata,\n      htmlText: opener(html, buffer),\n      htmlTextData: onenterdata,\n      image: opener(image),\n      label: buffer,\n      link: opener(link),\n      listItem: opener(listItem),\n      listItemValue: onenterlistitemvalue,\n      listOrdered: opener(list, onenterlistordered),\n      listUnordered: opener(list),\n      paragraph: opener(paragraph),\n      reference: onenterreference,\n      referenceString: buffer,\n      resourceDestinationString: buffer,\n      resourceTitleString: buffer,\n      setextHeading: opener(heading),\n      strong: opener(strong),\n      thematicBreak: opener(thematicBreak)\n    },\n    exit: {\n      atxHeading: closer(),\n      atxHeadingSequence: onexitatxheadingsequence,\n      autolink: closer(),\n      autolinkEmail: onexitautolinkemail,\n      autolinkProtocol: onexitautolinkprotocol,\n      blockQuote: closer(),\n      characterEscapeValue: onexitdata,\n      characterReferenceMarkerHexadecimal: onexitcharacterreferencemarker,\n      characterReferenceMarkerNumeric: onexitcharacterreferencemarker,\n      characterReferenceValue: onexitcharacterreferencevalue,\n      characterReference: onexitcharacterreference,\n      codeFenced: closer(onexitcodefenced),\n      codeFencedFence: onexitcodefencedfence,\n      codeFencedFenceInfo: onexitcodefencedfenceinfo,\n      codeFencedFenceMeta: onexitcodefencedfencemeta,\n      codeFlowValue: onexitdata,\n      codeIndented: closer(onexitcodeindented),\n      codeText: closer(onexitcodetext),\n      codeTextData: onexitdata,\n      data: onexitdata,\n      definition: closer(),\n      definitionDestinationString: onexitdefinitiondestinationstring,\n      definitionLabelString: onexitdefinitionlabelstring,\n      definitionTitleString: onexitdefinitiontitlestring,\n      emphasis: closer(),\n      hardBreakEscape: closer(onexithardbreak),\n      hardBreakTrailing: closer(onexithardbreak),\n      htmlFlow: closer(onexithtmlflow),\n      htmlFlowData: onexitdata,\n      htmlText: closer(onexithtmltext),\n      htmlTextData: onexitdata,\n      image: closer(onexitimage),\n      label: onexitlabel,\n      labelText: onexitlabeltext,\n      lineEnding: onexitlineending,\n      link: closer(onexitlink),\n      listItem: closer(),\n      listOrdered: closer(),\n      listUnordered: closer(),\n      paragraph: closer(),\n      referenceString: onexitreferencestring,\n      resourceDestinationString: onexitresourcedestinationstring,\n      resourceTitleString: onexitresourcetitlestring,\n      resource: onexitresource,\n      setextHeading: closer(onexitsetextheading),\n      setextHeadingLineSequence: onexitsetextheadinglinesequence,\n      setextHeadingText: onexitsetextheadingtext,\n      strong: closer(),\n      thematicBreak: closer()\n    }\n  };\n  configure(config, (options || {}).mdastExtensions || []);\n\n  /** @type {CompileData} */\n  const data = {};\n  return compile;\n\n  /**\n   * Turn micromark events into an mdast tree.\n   *\n   * @param {Array<Event>} events\n   *   Events.\n   * @returns {Root}\n   *   mdast tree.\n   */\n  function compile(events) {\n    /** @type {Root} */\n    let tree = {\n      type: 'root',\n      children: []\n    };\n    /** @type {Omit<CompileContext, 'sliceSerialize'>} */\n    const context = {\n      stack: [tree],\n      tokenStack: [],\n      config,\n      enter,\n      exit,\n      buffer,\n      resume,\n      data\n    };\n    /** @type {Array<number>} */\n    const listStack = [];\n    let index = -1;\n    while (++index < events.length) {\n      // We preprocess lists to add `listItem` tokens, and to infer whether\n      // items the list itself are spread out.\n      if (events[index][1].type === \"listOrdered\" || events[index][1].type === \"listUnordered\") {\n        if (events[index][0] === 'enter') {\n          listStack.push(index);\n        } else {\n          const tail = listStack.pop();\n          index = prepareList(events, tail, index);\n        }\n      }\n    }\n    index = -1;\n    while (++index < events.length) {\n      const handler = config[events[index][0]];\n      if (own.call(handler, events[index][1].type)) {\n        handler[events[index][1].type].call(Object.assign({\n          sliceSerialize: events[index][2].sliceSerialize\n        }, context), events[index][1]);\n      }\n    }\n\n    // Handle tokens still being open.\n    if (context.tokenStack.length > 0) {\n      const tail = context.tokenStack[context.tokenStack.length - 1];\n      const handler = tail[1] || defaultOnError;\n      handler.call(context, undefined, tail[0]);\n    }\n\n    // Figure out `root` position.\n    tree.position = {\n      start: point(events.length > 0 ? events[0][1].start : {\n        line: 1,\n        column: 1,\n        offset: 0\n      }),\n      end: point(events.length > 0 ? events[events.length - 2][1].end : {\n        line: 1,\n        column: 1,\n        offset: 0\n      })\n    };\n\n    // Call transforms.\n    index = -1;\n    while (++index < config.transforms.length) {\n      tree = config.transforms[index](tree) || tree;\n    }\n    return tree;\n  }\n\n  /**\n   * @param {Array<Event>} events\n   * @param {number} start\n   * @param {number} length\n   * @returns {number}\n   */\n  function prepareList(events, start, length) {\n    let index = start - 1;\n    let containerBalance = -1;\n    let listSpread = false;\n    /** @type {Token | undefined} */\n    let listItem;\n    /** @type {number | undefined} */\n    let lineIndex;\n    /** @type {number | undefined} */\n    let firstBlankLineIndex;\n    /** @type {boolean | undefined} */\n    let atMarker;\n    while (++index <= length) {\n      const event = events[index];\n      switch (event[1].type) {\n        case \"listUnordered\":\n        case \"listOrdered\":\n        case \"blockQuote\":\n          {\n            if (event[0] === 'enter') {\n              containerBalance++;\n            } else {\n              containerBalance--;\n            }\n            atMarker = undefined;\n            break;\n          }\n        case \"lineEndingBlank\":\n          {\n            if (event[0] === 'enter') {\n              if (listItem && !atMarker && !containerBalance && !firstBlankLineIndex) {\n                firstBlankLineIndex = index;\n              }\n              atMarker = undefined;\n            }\n            break;\n          }\n        case \"linePrefix\":\n        case \"listItemValue\":\n        case \"listItemMarker\":\n        case \"listItemPrefix\":\n        case \"listItemPrefixWhitespace\":\n          {\n            // Empty.\n\n            break;\n          }\n        default:\n          {\n            atMarker = undefined;\n          }\n      }\n      if (!containerBalance && event[0] === 'enter' && event[1].type === \"listItemPrefix\" || containerBalance === -1 && event[0] === 'exit' && (event[1].type === \"listUnordered\" || event[1].type === \"listOrdered\")) {\n        if (listItem) {\n          let tailIndex = index;\n          lineIndex = undefined;\n          while (tailIndex--) {\n            const tailEvent = events[tailIndex];\n            if (tailEvent[1].type === \"lineEnding\" || tailEvent[1].type === \"lineEndingBlank\") {\n              if (tailEvent[0] === 'exit') continue;\n              if (lineIndex) {\n                events[lineIndex][1].type = \"lineEndingBlank\";\n                listSpread = true;\n              }\n              tailEvent[1].type = \"lineEnding\";\n              lineIndex = tailIndex;\n            } else if (tailEvent[1].type === \"linePrefix\" || tailEvent[1].type === \"blockQuotePrefix\" || tailEvent[1].type === \"blockQuotePrefixWhitespace\" || tailEvent[1].type === \"blockQuoteMarker\" || tailEvent[1].type === \"listItemIndent\") {\n              // Empty\n            } else {\n              break;\n            }\n          }\n          if (firstBlankLineIndex && (!lineIndex || firstBlankLineIndex < lineIndex)) {\n            listItem._spread = true;\n          }\n\n          // Fix position.\n          listItem.end = Object.assign({}, lineIndex ? events[lineIndex][1].start : event[1].end);\n          events.splice(lineIndex || index, 0, ['exit', listItem, event[2]]);\n          index++;\n          length++;\n        }\n\n        // Create a new list item.\n        if (event[1].type === \"listItemPrefix\") {\n          /** @type {Token} */\n          const item = {\n            type: 'listItem',\n            _spread: false,\n            start: Object.assign({}, event[1].start),\n            // @ts-expect-error: we’ll add `end` in a second.\n            end: undefined\n          };\n          listItem = item;\n          events.splice(index, 0, ['enter', item, event[2]]);\n          index++;\n          length++;\n          firstBlankLineIndex = undefined;\n          atMarker = true;\n        }\n      }\n    }\n    events[start][1]._spread = listSpread;\n    return length;\n  }\n\n  /**\n   * Create an opener handle.\n   *\n   * @param {(token: Token) => Nodes} create\n   *   Create a node.\n   * @param {Handle | undefined} [and]\n   *   Optional function to also run.\n   * @returns {Handle}\n   *   Handle.\n   */\n  function opener(create, and) {\n    return open;\n\n    /**\n     * @this {CompileContext}\n     * @param {Token} token\n     * @returns {undefined}\n     */\n    function open(token) {\n      enter.call(this, create(token), token);\n      if (and) and.call(this, token);\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @returns {undefined}\n   */\n  function buffer() {\n    this.stack.push({\n      type: 'fragment',\n      children: []\n    });\n  }\n\n  /**\n   * @this {CompileContext}\n   *   Context.\n   * @param {Nodes} node\n   *   Node to enter.\n   * @param {Token} token\n   *   Corresponding token.\n   * @param {OnEnterError | undefined} [errorHandler]\n   *   Handle the case where this token is open, but it is closed by something else.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function enter(node, token, errorHandler) {\n    const parent = this.stack[this.stack.length - 1];\n    /** @type {Array<Nodes>} */\n    const siblings = parent.children;\n    siblings.push(node);\n    this.stack.push(node);\n    this.tokenStack.push([token, errorHandler]);\n    node.position = {\n      start: point(token.start),\n      // @ts-expect-error: `end` will be patched later.\n      end: undefined\n    };\n  }\n\n  /**\n   * Create a closer handle.\n   *\n   * @param {Handle | undefined} [and]\n   *   Optional function to also run.\n   * @returns {Handle}\n   *   Handle.\n   */\n  function closer(and) {\n    return close;\n\n    /**\n     * @this {CompileContext}\n     * @param {Token} token\n     * @returns {undefined}\n     */\n    function close(token) {\n      if (and) and.call(this, token);\n      exit.call(this, token);\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   *   Context.\n   * @param {Token} token\n   *   Corresponding token.\n   * @param {OnExitError | undefined} [onExitError]\n   *   Handle the case where another token is open.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function exit(token, onExitError) {\n    const node = this.stack.pop();\n    const open = this.tokenStack.pop();\n    if (!open) {\n      throw new Error('Cannot close `' + token.type + '` (' + stringifyPosition({\n        start: token.start,\n        end: token.end\n      }) + '): it’s not open');\n    } else if (open[0].type !== token.type) {\n      if (onExitError) {\n        onExitError.call(this, token, open[0]);\n      } else {\n        const handler = open[1] || defaultOnError;\n        handler.call(this, token, open[0]);\n      }\n    }\n    node.position.end = point(token.end);\n  }\n\n  /**\n   * @this {CompileContext}\n   * @returns {string}\n   */\n  function resume() {\n    return toString(this.stack.pop());\n  }\n\n  //\n  // Handlers.\n  //\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onenterlistordered() {\n    this.data.expectingFirstListItemValue = true;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onenterlistitemvalue(token) {\n    if (this.data.expectingFirstListItemValue) {\n      const ancestor = this.stack[this.stack.length - 2];\n      ancestor.start = Number.parseInt(this.sliceSerialize(token), 10);\n      this.data.expectingFirstListItemValue = undefined;\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefencedfenceinfo() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.lang = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefencedfencemeta() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.meta = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefencedfence() {\n    // Exit if this is the closing fence.\n    if (this.data.flowCodeInside) return;\n    this.buffer();\n    this.data.flowCodeInside = true;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefenced() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.value = data.replace(/^(\\r?\\n|\\r)|(\\r?\\n|\\r)$/g, '');\n    this.data.flowCodeInside = undefined;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodeindented() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.value = data.replace(/(\\r?\\n|\\r)$/g, '');\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitdefinitionlabelstring(token) {\n    const label = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.label = label;\n    node.identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase();\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitdefinitiontitlestring() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.title = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitdefinitiondestinationstring() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.url = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitatxheadingsequence(token) {\n    const node = this.stack[this.stack.length - 1];\n    if (!node.depth) {\n      const depth = this.sliceSerialize(token).length;\n      node.depth = depth;\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitsetextheadingtext() {\n    this.data.setextHeadingSlurpLineEnding = true;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitsetextheadinglinesequence(token) {\n    const node = this.stack[this.stack.length - 1];\n    node.depth = this.sliceSerialize(token).codePointAt(0) === 61 ? 1 : 2;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitsetextheading() {\n    this.data.setextHeadingSlurpLineEnding = undefined;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onenterdata(token) {\n    const node = this.stack[this.stack.length - 1];\n    /** @type {Array<Nodes>} */\n    const siblings = node.children;\n    let tail = siblings[siblings.length - 1];\n    if (!tail || tail.type !== 'text') {\n      // Add a new text node.\n      tail = text();\n      tail.position = {\n        start: point(token.start),\n        // @ts-expect-error: we’ll add `end` later.\n        end: undefined\n      };\n      siblings.push(tail);\n    }\n    this.stack.push(tail);\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitdata(token) {\n    const tail = this.stack.pop();\n    tail.value += this.sliceSerialize(token);\n    tail.position.end = point(token.end);\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlineending(token) {\n    const context = this.stack[this.stack.length - 1];\n    // If we’re at a hard break, include the line ending in there.\n    if (this.data.atHardBreak) {\n      const tail = context.children[context.children.length - 1];\n      tail.position.end = point(token.end);\n      this.data.atHardBreak = undefined;\n      return;\n    }\n    if (!this.data.setextHeadingSlurpLineEnding && config.canContainEols.includes(context.type)) {\n      onenterdata.call(this, token);\n      onexitdata.call(this, token);\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexithardbreak() {\n    this.data.atHardBreak = true;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexithtmlflow() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.value = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexithtmltext() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.value = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitcodetext() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.value = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlink() {\n    const node = this.stack[this.stack.length - 1];\n    // Note: there are also `identifier` and `label` fields on this link node!\n    // These are used / cleaned here.\n\n    // To do: clean.\n    if (this.data.inReference) {\n      /** @type {ReferenceType} */\n      const referenceType = this.data.referenceType || 'shortcut';\n      node.type += 'Reference';\n      // @ts-expect-error: mutate.\n      node.referenceType = referenceType;\n      // @ts-expect-error: mutate.\n      delete node.url;\n      delete node.title;\n    } else {\n      // @ts-expect-error: mutate.\n      delete node.identifier;\n      // @ts-expect-error: mutate.\n      delete node.label;\n    }\n    this.data.referenceType = undefined;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitimage() {\n    const node = this.stack[this.stack.length - 1];\n    // Note: there are also `identifier` and `label` fields on this link node!\n    // These are used / cleaned here.\n\n    // To do: clean.\n    if (this.data.inReference) {\n      /** @type {ReferenceType} */\n      const referenceType = this.data.referenceType || 'shortcut';\n      node.type += 'Reference';\n      // @ts-expect-error: mutate.\n      node.referenceType = referenceType;\n      // @ts-expect-error: mutate.\n      delete node.url;\n      delete node.title;\n    } else {\n      // @ts-expect-error: mutate.\n      delete node.identifier;\n      // @ts-expect-error: mutate.\n      delete node.label;\n    }\n    this.data.referenceType = undefined;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlabeltext(token) {\n    const string = this.sliceSerialize(token);\n    const ancestor = this.stack[this.stack.length - 2];\n    // @ts-expect-error: stash this on the node, as it might become a reference\n    // later.\n    ancestor.label = decodeString(string);\n    // @ts-expect-error: same as above.\n    ancestor.identifier = normalizeIdentifier(string).toLowerCase();\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlabel() {\n    const fragment = this.stack[this.stack.length - 1];\n    const value = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    // Assume a reference.\n    this.data.inReference = true;\n    if (node.type === 'link') {\n      /** @type {Array<PhrasingContent>} */\n      const children = fragment.children;\n      node.children = children;\n    } else {\n      node.alt = value;\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitresourcedestinationstring() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.url = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitresourcetitlestring() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.title = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitresource() {\n    this.data.inReference = undefined;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onenterreference() {\n    this.data.referenceType = 'collapsed';\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitreferencestring(token) {\n    const label = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    // @ts-expect-error: stash this on the node, as it might become a reference\n    // later.\n    node.label = label;\n    // @ts-expect-error: same as above.\n    node.identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase();\n    this.data.referenceType = 'full';\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitcharacterreferencemarker(token) {\n    this.data.characterReferenceType = token.type;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcharacterreferencevalue(token) {\n    const data = this.sliceSerialize(token);\n    const type = this.data.characterReferenceType;\n    /** @type {string} */\n    let value;\n    if (type) {\n      value = decodeNumericCharacterReference(data, type === \"characterReferenceMarkerNumeric\" ? 10 : 16);\n      this.data.characterReferenceType = undefined;\n    } else {\n      const result = decodeNamedCharacterReference(data);\n      value = result;\n    }\n    const tail = this.stack[this.stack.length - 1];\n    tail.value += value;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcharacterreference(token) {\n    const tail = this.stack.pop();\n    tail.position.end = point(token.end);\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitautolinkprotocol(token) {\n    onexitdata.call(this, token);\n    const node = this.stack[this.stack.length - 1];\n    node.url = this.sliceSerialize(token);\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitautolinkemail(token) {\n    onexitdata.call(this, token);\n    const node = this.stack[this.stack.length - 1];\n    node.url = 'mailto:' + this.sliceSerialize(token);\n  }\n\n  //\n  // Creaters.\n  //\n\n  /** @returns {Blockquote} */\n  function blockQuote() {\n    return {\n      type: 'blockquote',\n      children: []\n    };\n  }\n\n  /** @returns {Code} */\n  function codeFlow() {\n    return {\n      type: 'code',\n      lang: null,\n      meta: null,\n      value: ''\n    };\n  }\n\n  /** @returns {InlineCode} */\n  function codeText() {\n    return {\n      type: 'inlineCode',\n      value: ''\n    };\n  }\n\n  /** @returns {Definition} */\n  function definition() {\n    return {\n      type: 'definition',\n      identifier: '',\n      label: null,\n      title: null,\n      url: ''\n    };\n  }\n\n  /** @returns {Emphasis} */\n  function emphasis() {\n    return {\n      type: 'emphasis',\n      children: []\n    };\n  }\n\n  /** @returns {Heading} */\n  function heading() {\n    return {\n      type: 'heading',\n      // @ts-expect-error `depth` will be set later.\n      depth: 0,\n      children: []\n    };\n  }\n\n  /** @returns {Break} */\n  function hardBreak() {\n    return {\n      type: 'break'\n    };\n  }\n\n  /** @returns {Html} */\n  function html() {\n    return {\n      type: 'html',\n      value: ''\n    };\n  }\n\n  /** @returns {Image} */\n  function image() {\n    return {\n      type: 'image',\n      title: null,\n      url: '',\n      alt: null\n    };\n  }\n\n  /** @returns {Link} */\n  function link() {\n    return {\n      type: 'link',\n      title: null,\n      url: '',\n      children: []\n    };\n  }\n\n  /**\n   * @param {Token} token\n   * @returns {List}\n   */\n  function list(token) {\n    return {\n      type: 'list',\n      ordered: token.type === 'listOrdered',\n      start: null,\n      spread: token._spread,\n      children: []\n    };\n  }\n\n  /**\n   * @param {Token} token\n   * @returns {ListItem}\n   */\n  function listItem(token) {\n    return {\n      type: 'listItem',\n      spread: token._spread,\n      checked: null,\n      children: []\n    };\n  }\n\n  /** @returns {Paragraph} */\n  function paragraph() {\n    return {\n      type: 'paragraph',\n      children: []\n    };\n  }\n\n  /** @returns {Strong} */\n  function strong() {\n    return {\n      type: 'strong',\n      children: []\n    };\n  }\n\n  /** @returns {Text} */\n  function text() {\n    return {\n      type: 'text',\n      value: ''\n    };\n  }\n\n  /** @returns {ThematicBreak} */\n  function thematicBreak() {\n    return {\n      type: 'thematicBreak'\n    };\n  }\n}\n\n/**\n * Copy a point-like value.\n *\n * @param {Point} d\n *   Point-like value.\n * @returns {Point}\n *   unist point.\n */\nfunction point(d) {\n  return {\n    line: d.line,\n    column: d.column,\n    offset: d.offset\n  };\n}\n\n/**\n * @param {Config} combined\n * @param {Array<Array<Extension> | Extension>} extensions\n * @returns {undefined}\n */\nfunction configure(combined, extensions) {\n  let index = -1;\n  while (++index < extensions.length) {\n    const value = extensions[index];\n    if (Array.isArray(value)) {\n      configure(combined, value);\n    } else {\n      extension(combined, value);\n    }\n  }\n}\n\n/**\n * @param {Config} combined\n * @param {Extension} extension\n * @returns {undefined}\n */\nfunction extension(combined, extension) {\n  /** @type {keyof Extension} */\n  let key;\n  for (key in extension) {\n    if (own.call(extension, key)) {\n      switch (key) {\n        case 'canContainEols':\n          {\n            const right = extension[key];\n            if (right) {\n              combined[key].push(...right);\n            }\n            break;\n          }\n        case 'transforms':\n          {\n            const right = extension[key];\n            if (right) {\n              combined[key].push(...right);\n            }\n            break;\n          }\n        case 'enter':\n        case 'exit':\n          {\n            const right = extension[key];\n            if (right) {\n              Object.assign(combined[key], right);\n            }\n            break;\n          }\n        // No default\n      }\n    }\n  }\n}\n\n/** @type {OnEnterError} */\nfunction defaultOnError(left, right) {\n  if (left) {\n    throw new Error('Cannot close `' + left.type + '` (' + stringifyPosition({\n      start: left.start,\n      end: left.end\n    }) + '): a different token (`' + right.type + '`, ' + stringifyPosition({\n      start: right.start,\n      end: right.end\n    }) + ') is open');\n  } else {\n    throw new Error('Cannot close document, a token (`' + right.type + '`, ' + stringifyPosition({\n      start: right.start,\n      end: right.end\n    }) + ') is still open');\n  }\n}","/**\n * @typedef {import('mdast').Nodes} Nodes\n * @typedef {import('mdast').Parents} Parents\n * @typedef {import('mdast').PhrasingContent} PhrasingContent\n * @typedef {import('mdast').Root} Root\n * @typedef {import('mdast').Text} Text\n * @typedef {import('unist-util-visit-parents').Test} Test\n * @typedef {import('unist-util-visit-parents').VisitorResult} VisitorResult\n */\n\n/**\n * @typedef RegExpMatchObject\n *   Info on the match.\n * @property {number} index\n *   The index of the search at which the result was found.\n * @property {string} input\n *   A copy of the search string in the text node.\n * @property {[...Array<Parents>, Text]} stack\n *   All ancestors of the text node, where the last node is the text itself.\n *\n * @typedef {RegExp | string} Find\n *   Pattern to find.\n *\n *   Strings are escaped and then turned into global expressions.\n *\n * @typedef {Array<FindAndReplaceTuple>} FindAndReplaceList\n *   Several find and replaces, in array form.\n *\n * @typedef {[Find, Replace?]} FindAndReplaceTuple\n *   Find and replace in tuple form.\n *\n * @typedef {ReplaceFunction | string | null | undefined} Replace\n *   Thing to replace with.\n *\n * @callback ReplaceFunction\n *   Callback called when a search matches.\n * @param {...any} parameters\n *   The parameters are the result of corresponding search expression:\n *\n *   * `value` (`string`) — whole match\n *   * `...capture` (`Array<string>`) — matches from regex capture groups\n *   * `match` (`RegExpMatchObject`) — info on the match\n * @returns {Array<PhrasingContent> | PhrasingContent | string | false | null | undefined}\n *   Thing to replace with.\n *\n *   * when `null`, `undefined`, `''`, remove the match\n *   * …or when `false`, do not replace at all\n *   * …or when `string`, replace with a text node of that value\n *   * …or when `Node` or `Array<Node>`, replace with those nodes\n *\n * @typedef {[RegExp, ReplaceFunction]} Pair\n *   Normalized find and replace.\n *\n * @typedef {Array<Pair>} Pairs\n *   All find and replaced.\n *\n * @typedef Options\n *   Configuration.\n * @property {Test | null | undefined} [ignore]\n *   Test for which nodes to ignore (optional).\n */\n\nimport escape from 'escape-string-regexp'\nimport {visitParents} from 'unist-util-visit-parents'\nimport {convert} from 'unist-util-is'\n\n/**\n * Find patterns in a tree and replace them.\n *\n * The algorithm searches the tree in *preorder* for complete values in `Text`\n * nodes.\n * Partial matches are not supported.\n *\n * @param {Nodes} tree\n *   Tree to change.\n * @param {FindAndReplaceList | FindAndReplaceTuple} list\n *   Patterns to find.\n * @param {Options | null | undefined} [options]\n *   Configuration (when `find` is not `Find`).\n * @returns {undefined}\n *   Nothing.\n */\nexport function findAndReplace(tree, list, options) {\n  const settings = options || {}\n  const ignored = convert(settings.ignore || [])\n  const pairs = toPairs(list)\n  let pairIndex = -1\n\n  while (++pairIndex < pairs.length) {\n    visitParents(tree, 'text', visitor)\n  }\n\n  /** @type {import('unist-util-visit-parents').BuildVisitor<Root, 'text'>} */\n  function visitor(node, parents) {\n    let index = -1\n    /** @type {Parents | undefined} */\n    let grandparent\n\n    while (++index < parents.length) {\n      const parent = parents[index]\n      /** @type {Array<Nodes> | undefined} */\n      const siblings = grandparent ? grandparent.children : undefined\n\n      if (\n        ignored(\n          parent,\n          siblings ? siblings.indexOf(parent) : undefined,\n          grandparent\n        )\n      ) {\n        return\n      }\n\n      grandparent = parent\n    }\n\n    if (grandparent) {\n      return handler(node, parents)\n    }\n  }\n\n  /**\n   * Handle a text node which is not in an ignored parent.\n   *\n   * @param {Text} node\n   *   Text node.\n   * @param {Array<Parents>} parents\n   *   Parents.\n   * @returns {VisitorResult}\n   *   Result.\n   */\n  function handler(node, parents) {\n    const parent = parents[parents.length - 1]\n    const find = pairs[pairIndex][0]\n    const replace = pairs[pairIndex][1]\n    let start = 0\n    /** @type {Array<Nodes>} */\n    const siblings = parent.children\n    const index = siblings.indexOf(node)\n    let change = false\n    /** @type {Array<PhrasingContent>} */\n    let nodes = []\n\n    find.lastIndex = 0\n\n    let match = find.exec(node.value)\n\n    while (match) {\n      const position = match.index\n      /** @type {RegExpMatchObject} */\n      const matchObject = {\n        index: match.index,\n        input: match.input,\n        stack: [...parents, node]\n      }\n      let value = replace(...match, matchObject)\n\n      if (typeof value === 'string') {\n        value = value.length > 0 ? {type: 'text', value} : undefined\n      }\n\n      // It wasn’t a match after all.\n      if (value === false) {\n        // False acts as if there was no match.\n        // So we need to reset `lastIndex`, which currently being at the end of\n        // the current match, to the beginning.\n        find.lastIndex = position + 1\n      } else {\n        if (start !== position) {\n          nodes.push({\n            type: 'text',\n            value: node.value.slice(start, position)\n          })\n        }\n\n        if (Array.isArray(value)) {\n          nodes.push(...value)\n        } else if (value) {\n          nodes.push(value)\n        }\n\n        start = position + match[0].length\n        change = true\n      }\n\n      if (!find.global) {\n        break\n      }\n\n      match = find.exec(node.value)\n    }\n\n    if (change) {\n      if (start < node.value.length) {\n        nodes.push({type: 'text', value: node.value.slice(start)})\n      }\n\n      parent.children.splice(index, 1, ...nodes)\n    } else {\n      nodes = [node]\n    }\n\n    return index + nodes.length\n  }\n}\n\n/**\n * Turn a tuple or a list of tuples into pairs.\n *\n * @param {FindAndReplaceList | FindAndReplaceTuple} tupleOrList\n *   Schema.\n * @returns {Pairs}\n *   Clean pairs.\n */\nfunction toPairs(tupleOrList) {\n  /** @type {Pairs} */\n  const result = []\n\n  if (!Array.isArray(tupleOrList)) {\n    throw new TypeError('Expected find and replace tuple or list of tuples')\n  }\n\n  /** @type {FindAndReplaceList} */\n  // @ts-expect-error: correct.\n  const list =\n    !tupleOrList[0] || Array.isArray(tupleOrList[0])\n      ? tupleOrList\n      : [tupleOrList]\n\n  let index = -1\n\n  while (++index < list.length) {\n    const tuple = list[index]\n    result.push([toExpression(tuple[0]), toFunction(tuple[1])])\n  }\n\n  return result\n}\n\n/**\n * Turn a find into an expression.\n *\n * @param {Find} find\n *   Find.\n * @returns {RegExp}\n *   Expression.\n */\nfunction toExpression(find) {\n  return typeof find === 'string' ? new RegExp(escape(find), 'g') : find\n}\n\n/**\n * Turn a replace into a function.\n *\n * @param {Replace} replace\n *   Replace.\n * @returns {ReplaceFunction}\n *   Function.\n */\nfunction toFunction(replace) {\n  return typeof replace === 'function'\n    ? replace\n    : function () {\n        return replace\n      }\n}\n","export default function escapeStringRegexp(string) {\n\tif (typeof string !== 'string') {\n\t\tthrow new TypeError('Expected a string');\n\t}\n\n\t// Escape characters with special meaning either inside or outside character sets.\n\t// Use a simple backslash escape when it’s always valid, and a `\\xnn` escape when the simpler form would be disallowed by Unicode patterns’ stricter grammar.\n\treturn string\n\t\t.replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&')\n\t\t.replace(/-/g, '\\\\x2d');\n}\n","/**\n * @typedef {import('mdast').Link} Link\n * @typedef {import('mdast').PhrasingContent} PhrasingContent\n *\n * @typedef {import('mdast-util-from-markdown').CompileContext} CompileContext\n * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension\n * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle\n * @typedef {import('mdast-util-from-markdown').Transform} FromMarkdownTransform\n *\n * @typedef {import('mdast-util-to-markdown').ConstructName} ConstructName\n * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension\n *\n * @typedef {import('mdast-util-find-and-replace').RegExpMatchObject} RegExpMatchObject\n * @typedef {import('mdast-util-find-and-replace').ReplaceFunction} ReplaceFunction\n */\n\nimport {ccount} from 'ccount'\nimport {ok as assert} from 'devlop'\nimport {unicodePunctuation, unicodeWhitespace} from 'micromark-util-character'\nimport {findAndReplace} from 'mdast-util-find-and-replace'\n\n/** @type {ConstructName} */\nconst inConstruct = 'phrasing'\n/** @type {Array<ConstructName>} */\nconst notInConstruct = ['autolink', 'link', 'image', 'label']\n\n/**\n * Create an extension for `mdast-util-from-markdown` to enable GFM autolink\n * literals in markdown.\n *\n * @returns {FromMarkdownExtension}\n *   Extension for `mdast-util-to-markdown` to enable GFM autolink literals.\n */\nexport function gfmAutolinkLiteralFromMarkdown() {\n  return {\n    transforms: [transformGfmAutolinkLiterals],\n    enter: {\n      literalAutolink: enterLiteralAutolink,\n      literalAutolinkEmail: enterLiteralAutolinkValue,\n      literalAutolinkHttp: enterLiteralAutolinkValue,\n      literalAutolinkWww: enterLiteralAutolinkValue\n    },\n    exit: {\n      literalAutolink: exitLiteralAutolink,\n      literalAutolinkEmail: exitLiteralAutolinkEmail,\n      literalAutolinkHttp: exitLiteralAutolinkHttp,\n      literalAutolinkWww: exitLiteralAutolinkWww\n    }\n  }\n}\n\n/**\n * Create an extension for `mdast-util-to-markdown` to enable GFM autolink\n * literals in markdown.\n *\n * @returns {ToMarkdownExtension}\n *   Extension for `mdast-util-to-markdown` to enable GFM autolink literals.\n */\nexport function gfmAutolinkLiteralToMarkdown() {\n  return {\n    unsafe: [\n      {\n        character: '@',\n        before: '[+\\\\-.\\\\w]',\n        after: '[\\\\-.\\\\w]',\n        inConstruct,\n        notInConstruct\n      },\n      {\n        character: '.',\n        before: '[Ww]',\n        after: '[\\\\-.\\\\w]',\n        inConstruct,\n        notInConstruct\n      },\n      {\n        character: ':',\n        before: '[ps]',\n        after: '\\\\/',\n        inConstruct,\n        notInConstruct\n      }\n    ]\n  }\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction enterLiteralAutolink(token) {\n  this.enter({type: 'link', title: null, url: '', children: []}, token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction enterLiteralAutolinkValue(token) {\n  this.config.enter.autolinkProtocol.call(this, token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitLiteralAutolinkHttp(token) {\n  this.config.exit.autolinkProtocol.call(this, token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitLiteralAutolinkWww(token) {\n  this.config.exit.data.call(this, token)\n  const node = this.stack[this.stack.length - 1]\n  assert(node.type === 'link')\n  node.url = 'http://' + this.sliceSerialize(token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitLiteralAutolinkEmail(token) {\n  this.config.exit.autolinkEmail.call(this, token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitLiteralAutolink(token) {\n  this.exit(token)\n}\n\n/** @type {FromMarkdownTransform} */\nfunction transformGfmAutolinkLiterals(tree) {\n  findAndReplace(\n    tree,\n    [\n      [/(https?:\\/\\/|www(?=\\.))([-.\\w]+)([^ \\t\\r\\n]*)/gi, findUrl],\n      [/([-.\\w+]+)@([-\\w]+(?:\\.[-\\w]+)+)/g, findEmail]\n    ],\n    {ignore: ['link', 'linkReference']}\n  )\n}\n\n/**\n * @type {ReplaceFunction}\n * @param {string} _\n * @param {string} protocol\n * @param {string} domain\n * @param {string} path\n * @param {RegExpMatchObject} match\n * @returns {Array<PhrasingContent> | Link | false}\n */\n// eslint-disable-next-line max-params\nfunction findUrl(_, protocol, domain, path, match) {\n  let prefix = ''\n\n  // Not an expected previous character.\n  if (!previous(match)) {\n    return false\n  }\n\n  // Treat `www` as part of the domain.\n  if (/^w/i.test(protocol)) {\n    domain = protocol + domain\n    protocol = ''\n    prefix = 'http://'\n  }\n\n  if (!isCorrectDomain(domain)) {\n    return false\n  }\n\n  const parts = splitUrl(domain + path)\n\n  if (!parts[0]) return false\n\n  /** @type {Link} */\n  const result = {\n    type: 'link',\n    title: null,\n    url: prefix + protocol + parts[0],\n    children: [{type: 'text', value: protocol + parts[0]}]\n  }\n\n  if (parts[1]) {\n    return [result, {type: 'text', value: parts[1]}]\n  }\n\n  return result\n}\n\n/**\n * @type {ReplaceFunction}\n * @param {string} _\n * @param {string} atext\n * @param {string} label\n * @param {RegExpMatchObject} match\n * @returns {Link | false}\n */\nfunction findEmail(_, atext, label, match) {\n  if (\n    // Not an expected previous character.\n    !previous(match, true) ||\n    // Label ends in not allowed character.\n    /[-\\d_]$/.test(label)\n  ) {\n    return false\n  }\n\n  return {\n    type: 'link',\n    title: null,\n    url: 'mailto:' + atext + '@' + label,\n    children: [{type: 'text', value: atext + '@' + label}]\n  }\n}\n\n/**\n * @param {string} domain\n * @returns {boolean}\n */\nfunction isCorrectDomain(domain) {\n  const parts = domain.split('.')\n\n  if (\n    parts.length < 2 ||\n    (parts[parts.length - 1] &&\n      (/_/.test(parts[parts.length - 1]) ||\n        !/[a-zA-Z\\d]/.test(parts[parts.length - 1]))) ||\n    (parts[parts.length - 2] &&\n      (/_/.test(parts[parts.length - 2]) ||\n        !/[a-zA-Z\\d]/.test(parts[parts.length - 2])))\n  ) {\n    return false\n  }\n\n  return true\n}\n\n/**\n * @param {string} url\n * @returns {[string, string | undefined]}\n */\nfunction splitUrl(url) {\n  const trailExec = /[!\"&'),.:;<>?\\]}]+$/.exec(url)\n\n  if (!trailExec) {\n    return [url, undefined]\n  }\n\n  url = url.slice(0, trailExec.index)\n\n  let trail = trailExec[0]\n  let closingParenIndex = trail.indexOf(')')\n  const openingParens = ccount(url, '(')\n  let closingParens = ccount(url, ')')\n\n  while (closingParenIndex !== -1 && openingParens > closingParens) {\n    url += trail.slice(0, closingParenIndex + 1)\n    trail = trail.slice(closingParenIndex + 1)\n    closingParenIndex = trail.indexOf(')')\n    closingParens++\n  }\n\n  return [url, trail]\n}\n\n/**\n * @param {RegExpMatchObject} match\n * @param {boolean | null | undefined} [email=false]\n * @returns {boolean}\n */\nfunction previous(match, email) {\n  const code = match.input.charCodeAt(match.index - 1)\n\n  return (\n    (match.index === 0 ||\n      unicodeWhitespace(code) ||\n      unicodePunctuation(code)) &&\n    (!email || code !== 47)\n  )\n}\n","/**\n * @typedef {import('mdast').FootnoteDefinition} FootnoteDefinition\n * @typedef {import('mdast').FootnoteReference} FootnoteReference\n * @typedef {import('mdast-util-from-markdown').CompileContext} CompileContext\n * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension\n * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle\n * @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle\n * @typedef {import('mdast-util-to-markdown').Map} Map\n * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension\n */\n\nimport {ok as assert} from 'devlop'\nimport {normalizeIdentifier} from 'micromark-util-normalize-identifier'\n\nfootnoteReference.peek = footnoteReferencePeek\n\n/**\n * Create an extension for `mdast-util-from-markdown` to enable GFM footnotes\n * in markdown.\n *\n * @returns {FromMarkdownExtension}\n *   Extension for `mdast-util-from-markdown`.\n */\nexport function gfmFootnoteFromMarkdown() {\n  return {\n    enter: {\n      gfmFootnoteDefinition: enterFootnoteDefinition,\n      gfmFootnoteDefinitionLabelString: enterFootnoteDefinitionLabelString,\n      gfmFootnoteCall: enterFootnoteCall,\n      gfmFootnoteCallString: enterFootnoteCallString\n    },\n    exit: {\n      gfmFootnoteDefinition: exitFootnoteDefinition,\n      gfmFootnoteDefinitionLabelString: exitFootnoteDefinitionLabelString,\n      gfmFootnoteCall: exitFootnoteCall,\n      gfmFootnoteCallString: exitFootnoteCallString\n    }\n  }\n}\n\n/**\n * Create an extension for `mdast-util-to-markdown` to enable GFM footnotes\n * in markdown.\n *\n * @returns {ToMarkdownExtension}\n *   Extension for `mdast-util-to-markdown`.\n */\nexport function gfmFootnoteToMarkdown() {\n  return {\n    // This is on by default already.\n    unsafe: [{character: '[', inConstruct: ['phrasing', 'label', 'reference']}],\n    handlers: {footnoteDefinition, footnoteReference}\n  }\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction enterFootnoteDefinition(token) {\n  this.enter(\n    {type: 'footnoteDefinition', identifier: '', label: '', children: []},\n    token\n  )\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction enterFootnoteDefinitionLabelString() {\n  this.buffer()\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitFootnoteDefinitionLabelString(token) {\n  const label = this.resume()\n  const node = this.stack[this.stack.length - 1]\n  assert(node.type === 'footnoteDefinition')\n  node.label = label\n  node.identifier = normalizeIdentifier(\n    this.sliceSerialize(token)\n  ).toLowerCase()\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitFootnoteDefinition(token) {\n  this.exit(token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction enterFootnoteCall(token) {\n  this.enter({type: 'footnoteReference', identifier: '', label: ''}, token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction enterFootnoteCallString() {\n  this.buffer()\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitFootnoteCallString(token) {\n  const label = this.resume()\n  const node = this.stack[this.stack.length - 1]\n  assert(node.type === 'footnoteReference')\n  node.label = label\n  node.identifier = normalizeIdentifier(\n    this.sliceSerialize(token)\n  ).toLowerCase()\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitFootnoteCall(token) {\n  this.exit(token)\n}\n\n/**\n * @type {ToMarkdownHandle}\n * @param {FootnoteReference} node\n */\nfunction footnoteReference(node, _, state, info) {\n  const tracker = state.createTracker(info)\n  let value = tracker.move('[^')\n  const exit = state.enter('footnoteReference')\n  const subexit = state.enter('reference')\n  value += tracker.move(\n    state.safe(state.associationId(node), {\n      ...tracker.current(),\n      before: value,\n      after: ']'\n    })\n  )\n  subexit()\n  exit()\n  value += tracker.move(']')\n  return value\n}\n\n/** @type {ToMarkdownHandle} */\nfunction footnoteReferencePeek() {\n  return '['\n}\n\n/**\n * @type {ToMarkdownHandle}\n * @param {FootnoteDefinition} node\n */\nfunction footnoteDefinition(node, _, state, info) {\n  const tracker = state.createTracker(info)\n  let value = tracker.move('[^')\n  const exit = state.enter('footnoteDefinition')\n  const subexit = state.enter('label')\n  value += tracker.move(\n    state.safe(state.associationId(node), {\n      ...tracker.current(),\n      before: value,\n      after: ']'\n    })\n  )\n  subexit()\n  value += tracker.move(\n    ']:' + (node.children && node.children.length > 0 ? ' ' : '')\n  )\n  tracker.shift(4)\n  value += tracker.move(\n    state.indentLines(state.containerFlow(node, tracker.current()), map)\n  )\n  exit()\n\n  return value\n}\n\n/** @type {Map} */\nfunction map(line, index, blank) {\n  if (index === 0) {\n    return line\n  }\n\n  return (blank ? '' : '    ') + line\n}\n","/**\n * @typedef {import('mdast').Delete} Delete\n *\n * @typedef {import('mdast-util-from-markdown').CompileContext} CompileContext\n * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension\n * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle\n *\n * @typedef {import('mdast-util-to-markdown').ConstructName} ConstructName\n * @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle\n * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension\n */\n\n/**\n * List of constructs that occur in phrasing (paragraphs, headings), but cannot\n * contain strikethrough.\n * So they sort of cancel each other out.\n * Note: could use a better name.\n *\n * Note: keep in sync with: <https://github.com/syntax-tree/mdast-util-to-markdown/blob/8ce8dbf/lib/unsafe.js#L14>\n *\n * @type {Array<ConstructName>}\n */\nconst constructsWithoutStrikethrough = [\n  'autolink',\n  'destinationLiteral',\n  'destinationRaw',\n  'reference',\n  'titleQuote',\n  'titleApostrophe'\n]\n\nhandleDelete.peek = peekDelete\n\n/**\n * Create an extension for `mdast-util-from-markdown` to enable GFM\n * strikethrough in markdown.\n *\n * @returns {FromMarkdownExtension}\n *   Extension for `mdast-util-from-markdown` to enable GFM strikethrough.\n */\nexport function gfmStrikethroughFromMarkdown() {\n  return {\n    canContainEols: ['delete'],\n    enter: {strikethrough: enterStrikethrough},\n    exit: {strikethrough: exitStrikethrough}\n  }\n}\n\n/**\n * Create an extension for `mdast-util-to-markdown` to enable GFM\n * strikethrough in markdown.\n *\n * @returns {ToMarkdownExtension}\n *   Extension for `mdast-util-to-markdown` to enable GFM strikethrough.\n */\nexport function gfmStrikethroughToMarkdown() {\n  return {\n    unsafe: [\n      {\n        character: '~',\n        inConstruct: 'phrasing',\n        notInConstruct: constructsWithoutStrikethrough\n      }\n    ],\n    handlers: {delete: handleDelete}\n  }\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction enterStrikethrough(token) {\n  this.enter({type: 'delete', children: []}, token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitStrikethrough(token) {\n  this.exit(token)\n}\n\n/**\n * @type {ToMarkdownHandle}\n * @param {Delete} node\n */\nfunction handleDelete(node, _, state, info) {\n  const tracker = state.createTracker(info)\n  const exit = state.enter('strikethrough')\n  let value = tracker.move('~~')\n  value += state.containerPhrasing(node, {\n    ...tracker.current(),\n    before: value,\n    after: '~'\n  })\n  value += tracker.move('~~')\n  exit()\n  return value\n}\n\n/** @type {ToMarkdownHandle} */\nfunction peekDelete() {\n  return '~'\n}\n","/**\n * @typedef {import('mdast').InlineCode} InlineCode\n * @typedef {import('mdast').Table} Table\n * @typedef {import('mdast').TableCell} TableCell\n * @typedef {import('mdast').TableRow} TableRow\n *\n * @typedef {import('markdown-table').Options} MarkdownTableOptions\n *\n * @typedef {import('mdast-util-from-markdown').CompileContext} CompileContext\n * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension\n * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle\n *\n * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension\n * @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle\n * @typedef {import('mdast-util-to-markdown').State} State\n * @typedef {import('mdast-util-to-markdown').Info} Info\n */\n\n/**\n * @typedef Options\n *   Configuration.\n * @property {boolean | null | undefined} [tableCellPadding=true]\n *   Whether to add a space of padding between delimiters and cells (default:\n *   `true`).\n * @property {boolean | null | undefined} [tablePipeAlign=true]\n *   Whether to align the delimiters (default: `true`).\n * @property {MarkdownTableOptions['stringLength'] | null | undefined} [stringLength]\n *   Function to detect the length of table cell content, used when aligning\n *   the delimiters between cells (optional).\n */\n\nimport {ok as assert} from 'devlop'\nimport {markdownTable} from 'markdown-table'\nimport {defaultHandlers} from 'mdast-util-to-markdown'\n\n/**\n * Create an extension for `mdast-util-from-markdown` to enable GFM tables in\n * markdown.\n *\n * @returns {FromMarkdownExtension}\n *   Extension for `mdast-util-from-markdown` to enable GFM tables.\n */\nexport function gfmTableFromMarkdown() {\n  return {\n    enter: {\n      table: enterTable,\n      tableData: enterCell,\n      tableHeader: enterCell,\n      tableRow: enterRow\n    },\n    exit: {\n      codeText: exitCodeText,\n      table: exitTable,\n      tableData: exit,\n      tableHeader: exit,\n      tableRow: exit\n    }\n  }\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction enterTable(token) {\n  const align = token._align\n  assert(align, 'expected `_align` on table')\n  this.enter(\n    {\n      type: 'table',\n      align: align.map(function (d) {\n        return d === 'none' ? null : d\n      }),\n      children: []\n    },\n    token\n  )\n  this.data.inTable = true\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitTable(token) {\n  this.exit(token)\n  this.data.inTable = undefined\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction enterRow(token) {\n  this.enter({type: 'tableRow', children: []}, token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exit(token) {\n  this.exit(token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction enterCell(token) {\n  this.enter({type: 'tableCell', children: []}, token)\n}\n\n// Overwrite the default code text data handler to unescape escaped pipes when\n// they are in tables.\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitCodeText(token) {\n  let value = this.resume()\n\n  if (this.data.inTable) {\n    value = value.replace(/\\\\([\\\\|])/g, replace)\n  }\n\n  const node = this.stack[this.stack.length - 1]\n  assert(node.type === 'inlineCode')\n  node.value = value\n  this.exit(token)\n}\n\n/**\n * @param {string} $0\n * @param {string} $1\n * @returns {string}\n */\nfunction replace($0, $1) {\n  // Pipes work, backslashes don’t (but can’t escape pipes).\n  return $1 === '|' ? $1 : $0\n}\n\n/**\n * Create an extension for `mdast-util-to-markdown` to enable GFM tables in\n * markdown.\n *\n * @param {Options | null | undefined} [options]\n *   Configuration.\n * @returns {ToMarkdownExtension}\n *   Extension for `mdast-util-to-markdown` to enable GFM tables.\n */\nexport function gfmTableToMarkdown(options) {\n  const settings = options || {}\n  const padding = settings.tableCellPadding\n  const alignDelimiters = settings.tablePipeAlign\n  const stringLength = settings.stringLength\n  const around = padding ? ' ' : '|'\n\n  return {\n    unsafe: [\n      {character: '\\r', inConstruct: 'tableCell'},\n      {character: '\\n', inConstruct: 'tableCell'},\n      // A pipe, when followed by a tab or space (padding), or a dash or colon\n      // (unpadded delimiter row), could result in a table.\n      {atBreak: true, character: '|', after: '[\\t :-]'},\n      // A pipe in a cell must be encoded.\n      {character: '|', inConstruct: 'tableCell'},\n      // A colon must be followed by a dash, in which case it could start a\n      // delimiter row.\n      {atBreak: true, character: ':', after: '-'},\n      // A delimiter row can also start with a dash, when followed by more\n      // dashes, a colon, or a pipe.\n      // This is a stricter version than the built in check for lists, thematic\n      // breaks, and setex heading underlines though:\n      // <https://github.com/syntax-tree/mdast-util-to-markdown/blob/51a2038/lib/unsafe.js#L57>\n      {atBreak: true, character: '-', after: '[:|-]'}\n    ],\n    handlers: {\n      inlineCode: inlineCodeWithTable,\n      table: handleTable,\n      tableCell: handleTableCell,\n      tableRow: handleTableRow\n    }\n  }\n\n  /**\n   * @type {ToMarkdownHandle}\n   * @param {Table} node\n   */\n  function handleTable(node, _, state, info) {\n    return serializeData(handleTableAsData(node, state, info), node.align)\n  }\n\n  /**\n   * This function isn’t really used normally, because we handle rows at the\n   * table level.\n   * But, if someone passes in a table row, this ensures we make somewhat sense.\n   *\n   * @type {ToMarkdownHandle}\n   * @param {TableRow} node\n   */\n  function handleTableRow(node, _, state, info) {\n    const row = handleTableRowAsData(node, state, info)\n    const value = serializeData([row])\n    // `markdown-table` will always add an align row\n    return value.slice(0, value.indexOf('\\n'))\n  }\n\n  /**\n   * @type {ToMarkdownHandle}\n   * @param {TableCell} node\n   */\n  function handleTableCell(node, _, state, info) {\n    const exit = state.enter('tableCell')\n    const subexit = state.enter('phrasing')\n    const value = state.containerPhrasing(node, {\n      ...info,\n      before: around,\n      after: around\n    })\n    subexit()\n    exit()\n    return value\n  }\n\n  /**\n   * @param {Array<Array<string>>} matrix\n   * @param {Array<string | null | undefined> | null | undefined} [align]\n   */\n  function serializeData(matrix, align) {\n    return markdownTable(matrix, {\n      align,\n      // @ts-expect-error: `markdown-table` types should support `null`.\n      alignDelimiters,\n      // @ts-expect-error: `markdown-table` types should support `null`.\n      padding,\n      // @ts-expect-error: `markdown-table` types should support `null`.\n      stringLength\n    })\n  }\n\n  /**\n   * @param {Table} node\n   * @param {State} state\n   * @param {Info} info\n   */\n  function handleTableAsData(node, state, info) {\n    const children = node.children\n    let index = -1\n    /** @type {Array<Array<string>>} */\n    const result = []\n    const subexit = state.enter('table')\n\n    while (++index < children.length) {\n      result[index] = handleTableRowAsData(children[index], state, info)\n    }\n\n    subexit()\n\n    return result\n  }\n\n  /**\n   * @param {TableRow} node\n   * @param {State} state\n   * @param {Info} info\n   */\n  function handleTableRowAsData(node, state, info) {\n    const children = node.children\n    let index = -1\n    /** @type {Array<string>} */\n    const result = []\n    const subexit = state.enter('tableRow')\n\n    while (++index < children.length) {\n      // Note: the positional info as used here is incorrect.\n      // Making it correct would be impossible due to aligning cells?\n      // And it would need copy/pasting `markdown-table` into this project.\n      result[index] = handleTableCell(children[index], node, state, info)\n    }\n\n    subexit()\n\n    return result\n  }\n\n  /**\n   * @type {ToMarkdownHandle}\n   * @param {InlineCode} node\n   */\n  function inlineCodeWithTable(node, parent, state) {\n    let value = defaultHandlers.inlineCode(node, parent, state)\n\n    if (state.stack.includes('tableCell')) {\n      value = value.replace(/\\|/g, '\\\\$&')\n    }\n\n    return value\n  }\n}\n","/**\n * @typedef {import('mdast').ListItem} ListItem\n * @typedef {import('mdast').Paragraph} Paragraph\n * @typedef {import('mdast-util-from-markdown').CompileContext} CompileContext\n * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension\n * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle\n * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension\n * @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle\n */\n\nimport {ok as assert} from 'devlop'\nimport {defaultHandlers} from 'mdast-util-to-markdown'\n\n/**\n * Create an extension for `mdast-util-from-markdown` to enable GFM task\n * list items in markdown.\n *\n * @returns {FromMarkdownExtension}\n *   Extension for `mdast-util-from-markdown` to enable GFM task list items.\n */\nexport function gfmTaskListItemFromMarkdown() {\n  return {\n    exit: {\n      taskListCheckValueChecked: exitCheck,\n      taskListCheckValueUnchecked: exitCheck,\n      paragraph: exitParagraphWithTaskListItem\n    }\n  }\n}\n\n/**\n * Create an extension for `mdast-util-to-markdown` to enable GFM task list\n * items in markdown.\n *\n * @returns {ToMarkdownExtension}\n *   Extension for `mdast-util-to-markdown` to enable GFM task list items.\n */\nexport function gfmTaskListItemToMarkdown() {\n  return {\n    unsafe: [{atBreak: true, character: '-', after: '[:|-]'}],\n    handlers: {listItem: listItemWithTaskListItem}\n  }\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitCheck(token) {\n  // We’re always in a paragraph, in a list item.\n  const node = this.stack[this.stack.length - 2]\n  assert(node.type === 'listItem')\n  node.checked = token.type === 'taskListCheckValueChecked'\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitParagraphWithTaskListItem(token) {\n  const parent = this.stack[this.stack.length - 2]\n\n  if (\n    parent &&\n    parent.type === 'listItem' &&\n    typeof parent.checked === 'boolean'\n  ) {\n    const node = this.stack[this.stack.length - 1]\n    assert(node.type === 'paragraph')\n    const head = node.children[0]\n\n    if (head && head.type === 'text') {\n      const siblings = parent.children\n      let index = -1\n      /** @type {Paragraph | undefined} */\n      let firstParaghraph\n\n      while (++index < siblings.length) {\n        const sibling = siblings[index]\n        if (sibling.type === 'paragraph') {\n          firstParaghraph = sibling\n          break\n        }\n      }\n\n      if (firstParaghraph === node) {\n        // Must start with a space or a tab.\n        head.value = head.value.slice(1)\n\n        if (head.value.length === 0) {\n          node.children.shift()\n        } else if (\n          node.position &&\n          head.position &&\n          typeof head.position.start.offset === 'number'\n        ) {\n          head.position.start.column++\n          head.position.start.offset++\n          node.position.start = Object.assign({}, head.position.start)\n        }\n      }\n    }\n  }\n\n  this.exit(token)\n}\n\n/**\n * @type {ToMarkdownHandle}\n * @param {ListItem} node\n */\nfunction listItemWithTaskListItem(node, parent, state, info) {\n  const head = node.children[0]\n  const checkable =\n    typeof node.checked === 'boolean' && head && head.type === 'paragraph'\n  const checkbox = '[' + (node.checked ? 'x' : ' ') + '] '\n  const tracker = state.createTracker(info)\n\n  if (checkable) {\n    tracker.move(checkbox)\n  }\n\n  let value = defaultHandlers.listItem(node, parent, state, {\n    ...info,\n    ...tracker.current()\n  })\n\n  if (checkable) {\n    value = value.replace(/^(?:[*+-]|\\d+\\.)([\\r\\n]| {1,3})/, check)\n  }\n\n  return value\n\n  /**\n   * @param {string} $0\n   * @returns {string}\n   */\n  function check($0) {\n    return $0 + checkbox\n  }\n}\n","/**\n * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension\n * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension\n */\n\n/**\n * @typedef {import('mdast-util-gfm-table').Options} Options\n *   Configuration.\n */\n\nimport {\n  gfmAutolinkLiteralFromMarkdown,\n  gfmAutolinkLiteralToMarkdown\n} from 'mdast-util-gfm-autolink-literal'\nimport {\n  gfmFootnoteFromMarkdown,\n  gfmFootnoteToMarkdown\n} from 'mdast-util-gfm-footnote'\nimport {\n  gfmStrikethroughFromMarkdown,\n  gfmStrikethroughToMarkdown\n} from 'mdast-util-gfm-strikethrough'\nimport {gfmTableFromMarkdown, gfmTableToMarkdown} from 'mdast-util-gfm-table'\nimport {\n  gfmTaskListItemFromMarkdown,\n  gfmTaskListItemToMarkdown\n} from 'mdast-util-gfm-task-list-item'\n\n/**\n * Create an extension for `mdast-util-from-markdown` to enable GFM (autolink\n * literals, footnotes, strikethrough, tables, tasklists).\n *\n * @returns {Array<FromMarkdownExtension>}\n *   Extension for `mdast-util-from-markdown` to enable GFM (autolink literals,\n *   footnotes, strikethrough, tables, tasklists).\n */\nexport function gfmFromMarkdown() {\n  return [\n    gfmAutolinkLiteralFromMarkdown(),\n    gfmFootnoteFromMarkdown(),\n    gfmStrikethroughFromMarkdown(),\n    gfmTableFromMarkdown(),\n    gfmTaskListItemFromMarkdown()\n  ]\n}\n\n/**\n * Create an extension for `mdast-util-to-markdown` to enable GFM (autolink\n * literals, footnotes, strikethrough, tables, tasklists).\n *\n * @param {Options | null | undefined} [options]\n *   Configuration.\n * @returns {ToMarkdownExtension}\n *   Extension for `mdast-util-to-markdown` to enable GFM (autolink literals,\n *   footnotes, strikethrough, tables, tasklists).\n */\nexport function gfmToMarkdown(options) {\n  return {\n    extensions: [\n      gfmAutolinkLiteralToMarkdown(),\n      gfmFootnoteToMarkdown(),\n      gfmStrikethroughToMarkdown(),\n      gfmTableToMarkdown(options),\n      gfmTaskListItemToMarkdown()\n    ]\n  }\n}\n","/**\n * @typedef {import('mdast').Html} Html\n * @typedef {import('mdast').PhrasingContent} PhrasingContent\n */\n\nimport {convert} from 'unist-util-is'\n\n/**\n * Check if the given value is *phrasing content*.\n *\n * > 👉 **Note**: Excludes `html`, which can be both phrasing or flow.\n *\n * @param node\n *   Thing to check, typically `Node`.\n * @returns\n *   Whether `value` is phrasing content.\n */\n\nexport const phrasing =\n  /** @type {(node?: unknown) => node is Exclude<PhrasingContent, Html>} */\n  (\n    convert([\n      'break',\n      'delete',\n      'emphasis',\n      // To do: next major: removed since footnotes were added to GFM.\n      'footnote',\n      'footnoteReference',\n      'image',\n      'imageReference',\n      'inlineCode',\n      // Enabled by `mdast-util-math`:\n      'inlineMath',\n      'link',\n      'linkReference',\n      // Enabled by `mdast-util-mdx`:\n      'mdxJsxTextElement',\n      // Enabled by `mdast-util-mdx`:\n      'mdxTextExpression',\n      'strong',\n      'text',\n      // Enabled by `mdast-util-directive`:\n      'textDirective'\n    ])\n  )\n","/**\n * @typedef {import('mdast').Nodes} Nodes\n *\n * @typedef Options\n *   Configuration (optional).\n * @property {boolean | null | undefined} [includeImageAlt=true]\n *   Whether to use `alt` for `image`s (default: `true`).\n * @property {boolean | null | undefined} [includeHtml=true]\n *   Whether to use `value` of HTML (default: `true`).\n */\n\n/** @type {Options} */\nconst emptyOptions = {}\n\n/**\n * Get the text content of a node or list of nodes.\n *\n * Prefers the node’s plain-text fields, otherwise serializes its children,\n * and if the given value is an array, serialize the nodes in it.\n *\n * @param {unknown} [value]\n *   Thing to serialize, typically `Node`.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {string}\n *   Serialized `value`.\n */\nexport function toString(value, options) {\n  const settings = options || emptyOptions\n  const includeImageAlt =\n    typeof settings.includeImageAlt === 'boolean'\n      ? settings.includeImageAlt\n      : true\n  const includeHtml =\n    typeof settings.includeHtml === 'boolean' ? settings.includeHtml : true\n\n  return one(value, includeImageAlt, includeHtml)\n}\n\n/**\n * One node or several nodes.\n *\n * @param {unknown} value\n *   Thing to serialize.\n * @param {boolean} includeImageAlt\n *   Include image `alt`s.\n * @param {boolean} includeHtml\n *   Include HTML.\n * @returns {string}\n *   Serialized node.\n */\nfunction one(value, includeImageAlt, includeHtml) {\n  if (node(value)) {\n    if ('value' in value) {\n      return value.type === 'html' && !includeHtml ? '' : value.value\n    }\n\n    if (includeImageAlt && 'alt' in value && value.alt) {\n      return value.alt\n    }\n\n    if ('children' in value) {\n      return all(value.children, includeImageAlt, includeHtml)\n    }\n  }\n\n  if (Array.isArray(value)) {\n    return all(value, includeImageAlt, includeHtml)\n  }\n\n  return ''\n}\n\n/**\n * Serialize a list of nodes.\n *\n * @param {Array<unknown>} values\n *   Thing to serialize.\n * @param {boolean} includeImageAlt\n *   Include image `alt`s.\n * @param {boolean} includeHtml\n *   Include HTML.\n * @returns {string}\n *   Serialized nodes.\n */\nfunction all(values, includeImageAlt, includeHtml) {\n  /** @type {Array<string>} */\n  const result = []\n  let index = -1\n\n  while (++index < values.length) {\n    result[index] = one(values[index], includeImageAlt, includeHtml)\n  }\n\n  return result.join('')\n}\n\n/**\n * Check if `value` looks like a node.\n *\n * @param {unknown} value\n *   Thing.\n * @returns {value is Nodes}\n *   Whether `value` is a node.\n */\nfunction node(value) {\n  return Boolean(value && typeof value === 'object')\n}\n"],"names":["crypt","utf8","isBuffer","bin","md5","message","options","constructor","String","encoding","stringToBytes","Array","prototype","slice","call","isArray","Uint8Array","toString","m","bytesToWords","l","length","a","b","c","d","i","FF","_ff","GG","_gg","HH","_hh","II","_ii","aa","bb","cc","dd","endian","x","s","t","n","_blocksize","_digestsize","module","exports","Error","digestbytes","wordsToBytes","asBytes","asString","bytesToString","bytesToHex","own","hasOwnProperty","fromMarkdown","value","undefined","config","transforms","canContainEols","enter","autolink","opener","link","autolinkProtocol","onenterdata","autolinkEmail","atxHeading","heading","blockQuote","characterEscape","characterReference","codeFenced","codeFlow","codeFencedFenceInfo","buffer","codeFencedFenceMeta","codeIndented","codeText","codeTextData","data","codeFlowValue","definition","definitionDestinationString","definitionLabelString","definitionTitleString","emphasis","hardBreakEscape","hardBreak","hardBreakTrailing","htmlFlow","html","htmlFlowData","htmlText","htmlTextData","image","label","listItem","listItemValue","onenterlistitemvalue","listOrdered","list","onenterlistordered","listUnordered","paragraph","reference","onenterreference","referenceString","resourceDestinationString","resourceTitleString","setextHeading","strong","thematicBreak","exit","closer","atxHeadingSequence","onexitatxheadingsequence","onexitautolinkemail","onexitautolinkprotocol","characterEscapeValue","onexitdata","characterReferenceMarkerHexadecimal","onexitcharacterreferencemarker","characterReferenceMarkerNumeric","characterReferenceValue","onexitcharacterreferencevalue","onexitcharacterreference","onexitcodefenced","codeFencedFence","onexitcodefencedfence","onexitcodefencedfenceinfo","onexitcodefencedfencemeta","onexitcodeindented","onexitcodetext","onexitdefinitiondestinationstring","onexitdefinitionlabelstring","onexitdefinitiontitlestring","onexithardbreak","onexithtmlflow","onexithtmltext","onexitimage","onexitlabel","labelText","onexitlabeltext","lineEnding","onexitlineending","onexitlink","onexitreferencestring","onexitresourcedestinationstring","onexitresourcetitlestring","resource","onexitresource","onexitsetextheading","setextHeadingLineSequence","onexitsetextheadinglinesequence","setextHeadingText","onexitsetextheadingtext","configure","mdastExtensions","compile","events","tree","type","children","context","stack","tokenStack","resume","listStack","index","push","prepareList","pop","handler","Object","assign","sliceSerialize","tail","defaultOnError","position","start","point","line","column","offset","end","lineIndex","firstBlankLineIndex","atMarker","containerBalance","listSpread","event","tailIndex","tailEvent","_spread","splice","item","create","and","open","token","this","node","errorHandler","close","onExitError","expectingFirstListItemValue","Number","parseInt","lang","meta","flowCodeInside","replace","identifier","toLowerCase","title","url","depth","setextHeadingSlurpLineEnding","codePointAt","siblings","text","atHardBreak","includes","inReference","referenceType","string","ancestor","fragment","alt","characterReferenceType","ordered","spread","checked","compiler","document","write","combined","extensions","extension","key","right","left","findAndReplace","settings","ignored","ignore","pairs","tupleOrList","result","TypeError","tuple","toExpression","toFunction","toPairs","pairIndex","visitor","parents","grandparent","parent","indexOf","find","change","nodes","lastIndex","match","exec","matchObject","input","global","RegExp","inConstruct","notInConstruct","enterLiteralAutolink","enterLiteralAutolinkValue","exitLiteralAutolinkHttp","exitLiteralAutolinkWww","exitLiteralAutolinkEmail","exitLiteralAutolink","transformGfmAutolinkLiterals","findUrl","findEmail","_","protocol","domain","path","prefix","previous","test","parts","split","isCorrectDomain","trailExec","trail","closingParenIndex","openingParens","ccount","closingParens","splitUrl","atext","email","code","charCodeAt","enterFootnoteDefinition","enterFootnoteDefinitionLabelString","exitFootnoteDefinitionLabelString","exitFootnoteDefinition","enterFootnoteCall","enterFootnoteCallString","exitFootnoteCallString","exitFootnoteCall","footnoteReference","state","info","tracker","createTracker","move","subexit","safe","associationId","current","before","after","footnoteDefinition","shift","indentLines","containerFlow","map","blank","peek","constructsWithoutStrikethrough","enterStrikethrough","exitStrikethrough","handleDelete","containerPhrasing","enterTable","align","_align","inTable","exitTable","enterRow","enterCell","exitCodeText","$0","$1","gfmTableToMarkdown","padding","tableCellPadding","alignDelimiters","tablePipeAlign","stringLength","around","unsafe","character","atBreak","handlers","inlineCode","table","serializeData","handleTableRowAsData","handleTableAsData","tableCell","handleTableCell","tableRow","matrix","exitCheck","exitParagraphWithTaskListItem","head","firstParaghraph","sibling","listItemWithTaskListItem","checkable","checkbox","gfmFromMarkdown","literalAutolink","literalAutolinkEmail","literalAutolinkHttp","literalAutolinkWww","gfmFootnoteDefinition","gfmFootnoteDefinitionLabelString","gfmFootnoteCall","gfmFootnoteCallString","strikethrough","tableData","tableHeader","taskListCheckValueChecked","taskListCheckValueUnchecked","gfmToMarkdown","delete","phrasing","emptyOptions","one","includeImageAlt","includeHtml","Boolean","all","values","join"],"sourceRoot":""}