{"version":3,"file":"markdown-it.esm.min.mjs","names":["decode","encode","isLinkOpen","isLinkClose","linkify","_rules","r_normalize","r_block","r_strip_references","r_inline","r_linkify","r_replacements","r_smartquotes","r_text_join","block_names","_rules","r_table","r_code","r_fence","r_blockquote","r_hr","r_list","r_reference","r_html_block","r_heading","r_lheading","r_paragraph","postProcess","r_text","r_linkify","r_newline","r_escape","r_backticks","r_strikethrough","r_emphasis","r_link","r_image","r_autolink","r_html_inline","r_entity","r_balance_pairs","r_fragments_join","options","options","cfg_default","cfg_zero","cfg_commonmark","mdurl.parse","mdurl.encode","mdurl.format","mdurl.decode","utils","helpers","__defProp","__exportAll","target","name","all","no_symbols","decodeCache","getDecodeCache","cache","exclude","i","ch","decode$1","string","result","l","seq","b1","b2","chr","b3","b4","encodeCache","getEncodeCache","encode$1","keepEscaped","code","nextCode","format","url","Url","protocolPattern","portPattern","simplePathPattern","nonHostChars","hostEndingChars","hostnameMaxLen","hostnamePartPattern","hostnamePartStart","hostlessProtocol","slashedProtocol","urlParse","u","slashesDenoteHost","lowerProto","hec","slashes","rest","simplePath","proto","hostEnd","auth","atSign","host","ipv6Hostname","hostparts","part","newpart","j","k","validParts","notHost","bit","hash","qm","port","mdurl_exports","build_exports","Any","Cc","Cf","P","S","Z","c1","isInvalidCodePoint","codePoint","replaceCodePoint","codePointToString","BASE91_INVERSE","table","char","decodeTrieDict","inputLength","input","twoCharBias","dictSize","pos","readSlotCode","dict2AtomCount","atomCount","dict1AtomCount","slotCount","ngramCount","single","start","length","decodeDelta","previous","slot","off","end","count","runLength","next","references","poolSize","ngramIndex","readNgramReferences","index","startSlot","a","b","entryLength","pool","write","half","source","value","read","readEnd","out","resultLength","outIndex","htmlDecodeTree","BinTrieFlags","\"VALUE_LENGTH\"","\"FLAG13\"","\"BRANCH_LENGTH\"","\"JUMP_TABLE\"","\"VALUE_MASK\"","_typeof","o","toPrimitive","t","e","r","toPropertyKey","_defineProperty","CharCodes","\"AMP\"","\"NUM\"","\"SEMI\"","\"EQUALS\"","\"ZERO\"","\"NINE\"","\"LOWER_A\"","\"LOWER_X\"","TO_LOWER_BIT","CONSUMED_SHIFT","CODE_POINT_MASK","CONSUMED_OVERFLOW","longNumericConsumed","unpackConsumed","consumed","packed","isNumber","isHexadecimalCharacter","isAlpha","isEntityInAttributeInvalidEnd","EntityDecoderState","\"EntityStart\"","\"NumericStart\"","\"NumericDecimal\"","\"NumericHex\"","\"NamedEntity\"","DecodingMode","\"Legacy\"","\"Strict\"","\"Attribute\"","determineBranch","branchCount","current","jumpOffset","nodeIndex","stored","decodeTree","packedKeySlots","branchEnd","key","readTrieValue","valueLength","parseNumericEntity","offset","numberStart","cp","digitStart","digit","decodeWithTrie","chunkStart","root","rootJumpOffset","rootBranchCount","entityStart","firstChar","isStrict","rootSlotIndex","bestNodeIndex","bestValueLength","remaining","wordIndex","charIndexInPacked","finalVL","isAttribute","decodeHTMLStrict","htmlString","utils_exports","arrayReplaceAt","asciiTrim","callable","escapeHtml","escapeRE","fromCodePoint","isMdAsciiPunct","isPunctChar","isPunctCharCode","isSpace","isValidEntityCode","isWhiteSpace","lib","normalizeReference","unescapeAll","unescapeMd","wrapper","args","cls","src","newElements","c","surrogate1","surrogate2","UNESCAPE_MD_RE","UNESCAPE_ALL_RE","DIGITAL_ENTITY_TEST_RE","replaceEntityPattern","match","decoded","str","escaped","entity","HTML_ESCAPE_TEST_RE","HTML_ESCAPE_REPLACE_RE","HTML_REPLACEMENTS","replaceUnsafeChar","REGEXP_ESCAPE_RE","isAsciiTrimmable","parseLinkLabel","level","found","marker","prevPos","max","state","oldPos","disableNested","labelEnd","parseLinkDestination","parseLinkTitle","prev_state","helpers_exports","Token","type","tag","nesting","attrs","len","attrData","idx","Ruler","chains","rule","altName","chain","fn","options","beforeName","ruleName","afterName","list","ignoreInvalid","chainName","default_rules","token","tokens","slf","info","langName","langAttrs","arr","highlighted","tmpAttrs","tmpToken","env","Renderer","prev","needLf","nextToken","rules","StateCore","md","UNNORMALIZED_NEWLINE_RE","NULL_RE","normalize","block","strip_references","last","curr","inline","tok","isLinkOpen$1","isLinkClose$1","linkify$1","blockTokens","replacements","htmlLinkLevel","currentToken","text","links","nodes","lastPos","ln","fullUrl","urlText","token_o","token_t","token_c","newTokensLength","replacement","newTokens","replacementIndex","newTokenIndex","node","RARE_RE","SCOPED_ABBR_TEST_RE","SCOPED_ABBR_RE","SCOPED_ABBR","replaceFn","replace_scoped","inside_autolink","inlineTokens","replace_rare","replace","blkIdx","QUOTE_TEST_RE","QUOTE_RE","APOSTROPHE","MAX_OPENERS","truncateStack","stack","item","addReplacement","tokenIdx","applyReplacements","process_inlines","heads","thisLevel","canOpen","canClose","isSingle","lastChar","nextChar","isLastPunctChar","isNextPunctChar","isLastWhiteSpace","isNextWhiteSpace","openQuote","closeQuote","smartquotes","join_alt","text_join","_rules$2","ParserCore","StateBlock","s","indent","indent_found","line","from","min","begin","queue","lineIndent","lineStart","first","keepLastLF","MAX_AUTOCOMPLETED_CELLS","getLine","escapedSplit","isEscaped","startLine","endLine","nextLine","firstCh","secondCh","lineText","columns","aligns","columnCount","silent","oldParentType","terminatorRules","token_to","tableLines","token_tho","token_htro","token_ho","token_il","tbodyLines","autocompletedCells","terminate","token_tbo","token_tro","token_tdo","fence","mem","markup","params","haveEndMarker","blockquote","oldLineMax","oldBMarks","oldBSCount","oldSCount","oldTShift","lastLineEmpty","isOutdented","initial","spaceAfterMarker","adjustTab","oldIndent","lines","hr","cnt","skipBulletListMarker","skipOrderedListMarker","markTightParagraphs","tight","isTerminatingParagraph","isOrdered","markerValue","posAfterMarker","markerCharCode","listTokIdx","listLines","prevEmptyEnd","contentStart","indentAfterMarker","itemLines","oldTight","oldListIndent","MAX_LABEL_LENGTH","countCodePoints","high","low","lineEnd","getNextLinePos","isContinuation","reference","rawLabel","segmentStart","nextPos","destRes","href","destEndPos","destEndMax","destEndLineNo","titleStart","titleRes","title","label","meta","html_blocks_default","open_tag","close_tag","HTML_OPEN_CLOSE_TAG_RE","HTML_SEQUENCES","html_block","endsOnBlankLine","heading","tmp","token_i","lheading","content","paragraph","_rules$1","ParserBlock","maxNesting","hasEmptyLines","prevLine","ok","outTokens","StateInline","token_meta","highSurr","lowSurr","left_flanking","right_flanking","canSplitWord","isTerminatorChar","isAsciiAlpha","isSchemeChar","linkify","protoMin","protoStart","protoLength","link","urlEnd","newline","pmax","ws","ESCAPED","escape","ch1","escapedStr","ch2","origStr","buildLastRuns","lastRuns","backtick","_state$backticks$open","openerLength","matchEnd","matchStart","strikethrough_tokenize","scanned","postProcess$1","loneMarkers","delimiters","startDelim","endDelim","strikethrough_postProcess","tokens_meta","_tokens_meta$curr","strikethrough_default","emphasis_tokenize","postProcess","isStrong","emphasis_post_process","emphasis_default","res","ref","parseReference","labelStart","image","EMAIL_RE","AUTOLINK_RE","autolink","isLinkOpen","isLinkClose","isLetter","lc","scanSpecial","terminator","html_inline","DIGITAL_RE","NAMED_RE","processDelimiters","openersBottom","headerIdx","lastTokenIdx","jumps","closerIdx","closer","minOpenerIdx","openerIdx","newMinOpenerIdx","opener","isOddMatch","lastJump","link_pairs","fragments_join","_rules","_rules2","ParserInline","REBuilder","opts","openRE","open","closeRE","close","atom","pair","depth","_this$cache","_this$cache$text_sepa","_this$cache2","_this$cache2$src_pseu","_this$cache3","_this$cache3$src_ip","_this$cache4","_this$cache4$src_ip6_","h16","ls32","_this$cache5","_this$cache5$src_ip6_","_this$cache6","_this$cache6$src_ipv","_this$cache7","_this$cache7$src_auth","_this$cache8","_this$cache8$src_port","_this$cache9","_this$cache9$src_host","_this$cache10","_this$cache10$src_pat","_this$cache11","_this$cache11$src_pat","_this$cache12","_this$cache12$src_mai","_this$cache13","_this$cache13$src_xn","tlds_src","_this$cache14","_this$cache14$src_dom","_this$cache15","_this$cache15$src_dom","_this$cache16","_this$cache16$url_hos","_this$cache17","_this$cache17$fuzzy_u","_this$cache18","_this$cache18$src_mai","_this$cache19","_this$cache19$src_fuz","_this$cache20","_this$cache20$src_pat","_this$cache21","_this$cache21$mail_fu","_this$cache22","_this$cache22$link_fu","_this$cache23","_this$cache23$http_va","_this$cache24","_this$cache24$relativ","_this$cache25","_this$cache25$mail_na","_this$cache26","_this$cache26$mailto_","_this$cache27","_this$cache27$schema_","_this$cache28","_this$cache28$schema_","_this$cache29","_this$cache29$schema_","web_schema","re","self","m","defaultSchemas","tlds_2ch","tlds_default","unpackTlds","sep","prefix","suffix","defaultOptions","Match","raw","lastIndex","schema","LinkifyIt","linkifyOptions","rebuilder","definition","def","mailHostRe","mailNameRe","schemaRe","fuzzyLinkRe","fuzzyLinkCandidate","fuzzyEmailCandidate","schemaPrefix","schemaDone","fuzzyLinkDone","fuzzyEmailDone","scanFrom","fuzzyCandidate","schemaCandidate","candidate","keepOld","maxInt","base","tMin","tMax","skew","damp","initialBias","initialN","delimiter","regexPunycode","regexNonASCII","regexSeparators","errors","\"overflow\"","baseMinusTMin","floor","stringFromCharCode","error","map","array","callback","mapDomain","parts","domain","encoded","ucs2decode","output","counter","extra","ucs2encode","codePoints","basicToDigit","digitToBasic","flag","adapt","firstTime","delta","numPoints","decode","n","bias","basic","oldi","w","baseMinusT","encode","currentValue","basicLength","handledCPCount","handledCPCountPlusOne","q","qMinusT","punycode","\"version\"","\"ucs2\"","\"decode\"","\"encode\"","config","BAD_PROTO_RE","GOOD_DATA_RE","RECODE_HOSTNAME_FOR","MarkdownIt","parsed","er","presetNameOrOptions","p","presets","presetName","components","_components$inline","_components$name","rules2","missed","plugin","MarkdownItCallable"],"sources":["../../node_modules/mdurl/lib/decode.mjs","../../node_modules/mdurl/lib/encode.mjs","../../node_modules/mdurl/lib/format.mjs","../../node_modules/mdurl/lib/parse.mjs","../../node_modules/mdurl/index.mjs","../../node_modules/uc.micro/build/index.mjs","../../node_modules/entities/dist/decode-codepoint.js","../../node_modules/entities/dist/internal/decode-shared.js","../../node_modules/entities/dist/generated/decode-data-html.js","../../node_modules/entities/dist/internal/bin-trie-flags.js","../../node_modules/entities/dist/decode.js","../../src/common/utils.ts","../../src/helpers/parse_link_label.ts","../../src/helpers/parse_link_destination.ts","../../src/helpers/parse_link_title.ts","../../src/helpers/index.ts","../../src/token.ts","../../src/ruler.ts","../../src/renderer.ts","../../src/rules_core/state_core.ts","../../src/rules_core/normalize.ts","../../src/rules_core/block.ts","../../src/rules_core/strip_references.ts","../../src/rules_core/inline.ts","../../src/rules_core/linkify.ts","../../src/rules_core/replacements.ts","../../src/rules_core/smartquotes.ts","../../src/rules_core/text_join.ts","../../src/parser_core.ts","../../src/rules_block/state_block.ts","../../src/rules_block/table.ts","../../src/rules_block/code.ts","../../src/rules_block/fence.ts","../../src/rules_block/blockquote.ts","../../src/rules_block/hr.ts","../../src/rules_block/list.ts","../../src/rules_block/reference.ts","../../src/common/html_blocks.ts","../../src/common/html_re.ts","../../src/rules_block/html_block.ts","../../src/rules_block/heading.ts","../../src/rules_block/lheading.ts","../../src/rules_block/paragraph.ts","../../src/parser_block.ts","../../src/rules_inline/state_inline.ts","../../src/rules_inline/text.ts","../../src/rules_inline/linkify.ts","../../src/rules_inline/newline.ts","../../src/rules_inline/escape.ts","../../src/rules_inline/backticks.ts","../../src/rules_inline/strikethrough.ts","../../src/rules_inline/emphasis.ts","../../src/rules_inline/link.ts","../../src/rules_inline/image.ts","../../src/rules_inline/autolink.ts","../../src/rules_inline/html_inline.ts","../../src/rules_inline/entity.ts","../../src/rules_inline/balance_pairs.ts","../../src/rules_inline/fragments_join.ts","../../src/parser_inline.ts","../../node_modules/linkify-it/build/index.mjs","../../node_modules/punycode.js/punycode.es6.js","../../src/presets/default.ts","../../src/presets/zero.ts","../../src/presets/commonmark.ts","../../src/markdownit.ts","../../src/index.ts"],"sourcesContent":["/* eslint-disable no-bitwise */\n\nconst decodeCache = {}\n\nfunction getDecodeCache (exclude) {\n  let cache = decodeCache[exclude]\n  if (cache) { return cache }\n\n  cache = decodeCache[exclude] = []\n\n  for (let i = 0; i < 128; i++) {\n    const ch = String.fromCharCode(i)\n    cache.push(ch)\n  }\n\n  for (let i = 0; i < exclude.length; i++) {\n    const ch = exclude.charCodeAt(i)\n    cache[ch] = '%' + ('0' + ch.toString(16).toUpperCase()).slice(-2)\n  }\n\n  return cache\n}\n\n// Decode percent-encoded string.\n//\nfunction decode (string, exclude) {\n  if (typeof exclude !== 'string') {\n    exclude = decode.defaultChars\n  }\n\n  const cache = getDecodeCache(exclude)\n\n  return string.replace(/(%[a-f0-9]{2})+/gi, function (seq) {\n    let result = ''\n\n    for (let i = 0, l = seq.length; i < l; i += 3) {\n      const b1 = parseInt(seq.slice(i + 1, i + 3), 16)\n\n      if (b1 < 0x80) {\n        result += cache[b1]\n        continue\n      }\n\n      if ((b1 & 0xE0) === 0xC0 && (i + 3 < l)) {\n        // 110xxxxx 10xxxxxx\n        const b2 = parseInt(seq.slice(i + 4, i + 6), 16)\n\n        if ((b2 & 0xC0) === 0x80) {\n          const chr = ((b1 << 6) & 0x7C0) | (b2 & 0x3F)\n\n          if (chr < 0x80) {\n            result += '\\ufffd\\ufffd'\n          } else {\n            result += String.fromCharCode(chr)\n          }\n\n          i += 3\n          continue\n        }\n      }\n\n      if ((b1 & 0xF0) === 0xE0 && (i + 6 < l)) {\n        // 1110xxxx 10xxxxxx 10xxxxxx\n        const b2 = parseInt(seq.slice(i + 4, i + 6), 16)\n        const b3 = parseInt(seq.slice(i + 7, i + 9), 16)\n\n        if ((b2 & 0xC0) === 0x80 && (b3 & 0xC0) === 0x80) {\n          const chr = ((b1 << 12) & 0xF000) | ((b2 << 6) & 0xFC0) | (b3 & 0x3F)\n\n          if (chr < 0x800 || (chr >= 0xD800 && chr <= 0xDFFF)) {\n            result += '\\ufffd\\ufffd\\ufffd'\n          } else {\n            result += String.fromCharCode(chr)\n          }\n\n          i += 6\n          continue\n        }\n      }\n\n      if ((b1 & 0xF8) === 0xF0 && (i + 9 < l)) {\n        // 111110xx 10xxxxxx 10xxxxxx 10xxxxxx\n        const b2 = parseInt(seq.slice(i + 4, i + 6), 16)\n        const b3 = parseInt(seq.slice(i + 7, i + 9), 16)\n        const b4 = parseInt(seq.slice(i + 10, i + 12), 16)\n\n        if ((b2 & 0xC0) === 0x80 && (b3 & 0xC0) === 0x80 && (b4 & 0xC0) === 0x80) {\n          let chr = ((b1 << 18) & 0x1C0000) | ((b2 << 12) & 0x3F000) | ((b3 << 6) & 0xFC0) | (b4 & 0x3F)\n\n          if (chr < 0x10000 || chr > 0x10FFFF) {\n            result += '\\ufffd\\ufffd\\ufffd\\ufffd'\n          } else {\n            chr -= 0x10000\n            result += String.fromCharCode(0xD800 + (chr >> 10), 0xDC00 + (chr & 0x3FF))\n          }\n\n          i += 9\n          continue\n        }\n      }\n\n      result += '\\ufffd'\n    }\n\n    return result\n  })\n}\n\ndecode.defaultChars = ';/?:@&=+$,#'\ndecode.componentChars = ''\n\nexport default decode\n","const encodeCache = {}\n\n// Create a lookup array where anything but characters in `chars` string\n// and alphanumeric chars is percent-encoded.\n//\nfunction getEncodeCache (exclude) {\n  let cache = encodeCache[exclude]\n  if (cache) { return cache }\n\n  cache = encodeCache[exclude] = []\n\n  for (let i = 0; i < 128; i++) {\n    const ch = String.fromCharCode(i)\n\n    if (/^[0-9a-z]$/i.test(ch)) {\n      // always allow unencoded alphanumeric characters\n      cache.push(ch)\n    } else {\n      cache.push('%' + ('0' + i.toString(16).toUpperCase()).slice(-2))\n    }\n  }\n\n  for (let i = 0; i < exclude.length; i++) {\n    cache[exclude.charCodeAt(i)] = exclude[i]\n  }\n\n  return cache\n}\n\n// Encode unsafe characters with percent-encoding, skipping already\n// encoded sequences.\n//\n//  - string       - string to encode\n//  - exclude      - list of characters to ignore (in addition to a-zA-Z0-9)\n//  - keepEscaped  - don't encode '%' in a correct escape sequence (default: true)\n//\nfunction encode (string, exclude, keepEscaped) {\n  if (typeof exclude !== 'string') {\n    // encode(string, keepEscaped)\n    keepEscaped = exclude\n    exclude = encode.defaultChars\n  }\n\n  if (typeof keepEscaped === 'undefined') {\n    keepEscaped = true\n  }\n\n  const cache = getEncodeCache(exclude)\n  let result = ''\n\n  for (let i = 0, l = string.length; i < l; i++) {\n    const code = string.charCodeAt(i)\n\n    if (keepEscaped && code === 0x25 /* % */ && i + 2 < l) {\n      if (/^[0-9a-f]{2}$/i.test(string.slice(i + 1, i + 3))) {\n        result += string.slice(i, i + 3)\n        i += 2\n        continue\n      }\n    }\n\n    if (code < 128) {\n      result += cache[code]\n      continue\n    }\n\n    if (code >= 0xD800 && code <= 0xDFFF) {\n      if (code >= 0xD800 && code <= 0xDBFF && i + 1 < l) {\n        const nextCode = string.charCodeAt(i + 1)\n        if (nextCode >= 0xDC00 && nextCode <= 0xDFFF) {\n          result += encodeURIComponent(string[i] + string[i + 1])\n          i++\n          continue\n        }\n      }\n      result += '%EF%BF%BD'\n      continue\n    }\n\n    result += encodeURIComponent(string[i])\n  }\n\n  return result\n}\n\nencode.defaultChars = \";/?:@&=+$,-_.!~*'()#\"\nencode.componentChars = \"-_.!~*'()\"\n\nexport default encode\n","export default function format (url) {\n  let result = ''\n\n  result += url.protocol || ''\n  result += url.slashes ? '//' : ''\n  result += url.auth ? url.auth + '@' : ''\n\n  if (url.hostname && url.hostname.indexOf(':') !== -1) {\n    // ipv6 address\n    result += '[' + url.hostname + ']'\n  } else {\n    result += url.hostname || ''\n  }\n\n  result += url.port ? ':' + url.port : ''\n  result += url.pathname || ''\n  result += url.search || ''\n  result += url.hash || ''\n\n  return result\n};\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n//\n// Changes from joyent/node:\n//\n// 1. No leading slash in paths,\n//    e.g. in `url.parse('http://foo?bar')` pathname is ``, not `/`\n//\n// 2. Backslashes are not replaced with slashes,\n//    so `http:\\\\example.org\\` is treated like a relative path\n//\n// 3. Trailing colon is treated like a part of the path,\n//    i.e. in `http://example.org:foo` pathname is `:foo`\n//\n// 4. Nothing is URL-encoded in the resulting object,\n//    (in joyent/node some chars in auth and paths are encoded)\n//\n// 5. `url.parse()` does not have `parseQueryString` argument\n//\n// 6. Removed extraneous result properties: `host`, `path`, `query`, etc.,\n//    which can be constructed using other parts of the url.\n//\n\nfunction Url () {\n  this.protocol = null\n  this.slashes = null\n  this.auth = null\n  this.port = null\n  this.hostname = null\n  this.hash = null\n  this.search = null\n  this.pathname = null\n}\n\n// Reference: RFC 3986, RFC 1808, RFC 2396\n\n// define these here so at least they only have to be\n// compiled once on the first module load.\nconst protocolPattern = /^([a-z0-9.+-]+:)/i\nconst portPattern = /:[0-9]*$/\n\n// Special case for a simple path URL\n/* eslint-disable-next-line no-useless-escape */\nconst simplePathPattern = /^(\\/\\/?(?!\\/)[^\\?\\s]*)(\\?[^\\s]*)?$/\n\n// RFC 2396: characters reserved for delimiting URLs.\n// We actually just auto-escape these.\nconst delims = ['<', '>', '\"', '`', ' ', '\\r', '\\n', '\\t']\n\n// RFC 2396: characters not allowed for various reasons.\nconst unwise = ['{', '}', '|', '\\\\', '^', '`'].concat(delims)\n\n// Allowed by RFCs, but cause of XSS attacks.  Always escape these.\nconst autoEscape = ['\\''].concat(unwise)\n// Characters that are never ever allowed in a hostname.\n// Note that any invalid chars are also handled, but these\n// are the ones that are *expected* to be seen, so we fast-path\n// them.\nconst nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape)\nconst hostEndingChars = ['/', '?', '#']\nconst hostnameMaxLen = 255\nconst hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/\nconst hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/\n// protocols that can allow \"unsafe\" and \"unwise\" chars.\n// protocols that never have a hostname.\nconst hostlessProtocol = {\n  javascript: true,\n  'javascript:': true\n}\n// protocols that always contain a // bit.\nconst slashedProtocol = {\n  http: true,\n  https: true,\n  ftp: true,\n  gopher: true,\n  file: true,\n  'http:': true,\n  'https:': true,\n  'ftp:': true,\n  'gopher:': true,\n  'file:': true\n}\n\nfunction urlParse (url, slashesDenoteHost) {\n  if (url && url instanceof Url) return url\n\n  const u = new Url()\n  u.parse(url, slashesDenoteHost)\n  return u\n}\n\nUrl.prototype.parse = function (url, slashesDenoteHost) {\n  let lowerProto, hec, slashes\n  let rest = url\n\n  // trim before proceeding.\n  // This is to support parse stuff like \"  http://foo.com  \\n\"\n  rest = rest.trim()\n\n  if (!slashesDenoteHost && url.split('#').length === 1) {\n    // Try fast path regexp\n    const simplePath = simplePathPattern.exec(rest)\n    if (simplePath) {\n      this.pathname = simplePath[1]\n      if (simplePath[2]) {\n        this.search = simplePath[2]\n      }\n      return this\n    }\n  }\n\n  let proto = protocolPattern.exec(rest)\n  if (proto) {\n    proto = proto[0]\n    lowerProto = proto.toLowerCase()\n    this.protocol = proto\n    rest = rest.substr(proto.length)\n  }\n\n  // figure out if it's got a host\n  // user@server is *always* interpreted as a hostname, and url\n  // resolution will treat //foo/bar as host=foo,path=bar because that's\n  // how the browser resolves relative URLs.\n  /* eslint-disable-next-line no-useless-escape */\n  if (slashesDenoteHost || proto || rest.match(/^\\/\\/[^@\\/]+@[^@\\/]+/)) {\n    slashes = rest.substr(0, 2) === '//'\n    if (slashes && !(proto && hostlessProtocol[proto])) {\n      rest = rest.substr(2)\n      this.slashes = true\n    }\n  }\n\n  if (!hostlessProtocol[proto] &&\n      (slashes || (proto && !slashedProtocol[proto]))) {\n    // there's a hostname.\n    // the first instance of /, ?, ;, or # ends the host.\n    //\n    // If there is an @ in the hostname, then non-host chars *are* allowed\n    // to the left of the last @ sign, unless some host-ending character\n    // comes *before* the @-sign.\n    // URLs are obnoxious.\n    //\n    // ex:\n    // http://a@b@c/ => user:a@b host:c\n    // http://a@b?@c => user:a host:c path:/?@c\n\n    // v0.12 TODO(isaacs): This is not quite how Chrome does things.\n    // Review our test case against browsers more comprehensively.\n\n    // find the first instance of any hostEndingChars\n    let hostEnd = -1\n    for (let i = 0; i < hostEndingChars.length; i++) {\n      hec = rest.indexOf(hostEndingChars[i])\n      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {\n        hostEnd = hec\n      }\n    }\n\n    // at this point, either we have an explicit point where the\n    // auth portion cannot go past, or the last @ char is the decider.\n    let auth, atSign\n    if (hostEnd === -1) {\n      // atSign can be anywhere.\n      atSign = rest.lastIndexOf('@')\n    } else {\n      // atSign must be in auth portion.\n      // http://a@b/c@d => host:b auth:a path:/c@d\n      atSign = rest.lastIndexOf('@', hostEnd)\n    }\n\n    // Now we have a portion which is definitely the auth.\n    // Pull that off.\n    if (atSign !== -1) {\n      auth = rest.slice(0, atSign)\n      rest = rest.slice(atSign + 1)\n      this.auth = auth\n    }\n\n    // the host is the remaining to the left of the first non-host char\n    hostEnd = -1\n    for (let i = 0; i < nonHostChars.length; i++) {\n      hec = rest.indexOf(nonHostChars[i])\n      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {\n        hostEnd = hec\n      }\n    }\n    // if we still have not hit it, then the entire thing is a host.\n    if (hostEnd === -1) {\n      hostEnd = rest.length\n    }\n\n    if (rest[hostEnd - 1] === ':') { hostEnd-- }\n    const host = rest.slice(0, hostEnd)\n    rest = rest.slice(hostEnd)\n\n    // pull out port.\n    this.parseHost(host)\n\n    // we've indicated that there is a hostname,\n    // so even if it's empty, it has to be present.\n    this.hostname = this.hostname || ''\n\n    // if hostname begins with [ and ends with ]\n    // assume that it's an IPv6 address.\n    const ipv6Hostname = this.hostname[0] === '[' &&\n        this.hostname[this.hostname.length - 1] === ']'\n\n    // validate a little.\n    if (!ipv6Hostname) {\n      const hostparts = this.hostname.split(/\\./)\n      for (let i = 0, l = hostparts.length; i < l; i++) {\n        const part = hostparts[i]\n        if (!part) { continue }\n        if (!part.match(hostnamePartPattern)) {\n          let newpart = ''\n          for (let j = 0, k = part.length; j < k; j++) {\n            if (part.charCodeAt(j) > 127) {\n              // we replace non-ASCII char with a temporary placeholder\n              // we need this to make sure size of hostname is not\n              // broken by replacing non-ASCII by nothing\n              newpart += 'x'\n            } else {\n              newpart += part[j]\n            }\n          }\n          // we test again with ASCII char only\n          if (!newpart.match(hostnamePartPattern)) {\n            const validParts = hostparts.slice(0, i)\n            const notHost = hostparts.slice(i + 1)\n            const bit = part.match(hostnamePartStart)\n            if (bit) {\n              validParts.push(bit[1])\n              notHost.unshift(bit[2])\n            }\n            if (notHost.length) {\n              rest = notHost.join('.') + rest\n            }\n            this.hostname = validParts.join('.')\n            break\n          }\n        }\n      }\n    }\n\n    if (this.hostname.length > hostnameMaxLen) {\n      this.hostname = ''\n    }\n\n    // strip [ and ] from the hostname\n    // the host field still retains them, though\n    if (ipv6Hostname) {\n      this.hostname = this.hostname.substr(1, this.hostname.length - 2)\n    }\n  }\n\n  // chop off from the tail first.\n  const hash = rest.indexOf('#')\n  if (hash !== -1) {\n    // got a fragment string.\n    this.hash = rest.substr(hash)\n    rest = rest.slice(0, hash)\n  }\n  const qm = rest.indexOf('?')\n  if (qm !== -1) {\n    this.search = rest.substr(qm)\n    rest = rest.slice(0, qm)\n  }\n  if (rest) { this.pathname = rest }\n  if (slashedProtocol[lowerProto] &&\n      this.hostname && !this.pathname) {\n    this.pathname = ''\n  }\n\n  return this\n}\n\nUrl.prototype.parseHost = function (host) {\n  let port = portPattern.exec(host)\n  if (port) {\n    port = port[0]\n    if (port !== ':') {\n      this.port = port.substr(1)\n    }\n    host = host.substr(0, host.length - port.length)\n  }\n  if (host) { this.hostname = host }\n}\n\nexport default urlParse\n","import decode from './lib/decode.mjs'\nimport encode from './lib/encode.mjs'\nimport format from './lib/format.mjs'\nimport parse from './lib/parse.mjs'\n\nexport {\n  decode,\n  encode,\n  format,\n  parse\n}\n","const Any = /[\\0-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF]/;\nconst Cc = /[\\0-\\x1F\\x7F-\\x9F]/;\nconst Cf = /[\\xAD\\u0600-\\u0605\\u061C\\u06DD\\u070F\\u0890\\u0891\\u08E2\\u180E\\u200B-\\u200F\\u202A-\\u202E\\u2060-\\u2064\\u2066-\\u206F\\uFEFF\\uFFF9-\\uFFFB]|\\uD804[\\uDCBD\\uDCCD]|\\uD80D[\\uDC30-\\uDC3F]|\\uD82F[\\uDCA0-\\uDCA3]|\\uD834[\\uDD73-\\uDD7A]|\\uDB40[\\uDC01\\uDC20-\\uDC7F]/;\nconst P = /[!-#%-\\*,-\\/:;\\?@\\[-\\]_\\{\\}\\xA1\\xA7\\xAB\\xB6\\xB7\\xBB\\xBF\\u037E\\u0387\\u055A-\\u055F\\u0589\\u058A\\u05BE\\u05C0\\u05C3\\u05C6\\u05F3\\u05F4\\u0609\\u060A\\u060C\\u060D\\u061B\\u061D-\\u061F\\u066A-\\u066D\\u06D4\\u0700-\\u070D\\u07F7-\\u07F9\\u0830-\\u083E\\u085E\\u0964\\u0965\\u0970\\u09FD\\u0A76\\u0AF0\\u0C77\\u0C84\\u0DF4\\u0E4F\\u0E5A\\u0E5B\\u0F04-\\u0F12\\u0F14\\u0F3A-\\u0F3D\\u0F85\\u0FD0-\\u0FD4\\u0FD9\\u0FDA\\u104A-\\u104F\\u10FB\\u1360-\\u1368\\u1400\\u166E\\u169B\\u169C\\u16EB-\\u16ED\\u1735\\u1736\\u17D4-\\u17D6\\u17D8-\\u17DA\\u1800-\\u180A\\u1944\\u1945\\u1A1E\\u1A1F\\u1AA0-\\u1AA6\\u1AA8-\\u1AAD\\u1B4E\\u1B4F\\u1B5A-\\u1B60\\u1B7D-\\u1B7F\\u1BFC-\\u1BFF\\u1C3B-\\u1C3F\\u1C7E\\u1C7F\\u1CC0-\\u1CC7\\u1CD3\\u2010-\\u2027\\u2030-\\u2043\\u2045-\\u2051\\u2053-\\u205E\\u207D\\u207E\\u208D\\u208E\\u2308-\\u230B\\u2329\\u232A\\u2768-\\u2775\\u27C5\\u27C6\\u27E6-\\u27EF\\u2983-\\u2998\\u29D8-\\u29DB\\u29FC\\u29FD\\u2CF9-\\u2CFC\\u2CFE\\u2CFF\\u2D70\\u2E00-\\u2E2E\\u2E30-\\u2E4F\\u2E52-\\u2E5D\\u3001-\\u3003\\u3008-\\u3011\\u3014-\\u301F\\u3030\\u303D\\u30A0\\u30FB\\uA4FE\\uA4FF\\uA60D-\\uA60F\\uA673\\uA67E\\uA6F2-\\uA6F7\\uA874-\\uA877\\uA8CE\\uA8CF\\uA8F8-\\uA8FA\\uA8FC\\uA92E\\uA92F\\uA95F\\uA9C1-\\uA9CD\\uA9DE\\uA9DF\\uAA5C-\\uAA5F\\uAADE\\uAADF\\uAAF0\\uAAF1\\uABEB\\uFD3E\\uFD3F\\uFE10-\\uFE19\\uFE30-\\uFE52\\uFE54-\\uFE61\\uFE63\\uFE68\\uFE6A\\uFE6B\\uFF01-\\uFF03\\uFF05-\\uFF0A\\uFF0C-\\uFF0F\\uFF1A\\uFF1B\\uFF1F\\uFF20\\uFF3B-\\uFF3D\\uFF3F\\uFF5B\\uFF5D\\uFF5F-\\uFF65]|\\uD800[\\uDD00-\\uDD02\\uDF9F\\uDFD0]|\\uD801\\uDD6F|\\uD802[\\uDC57\\uDD1F\\uDD3F\\uDE50-\\uDE58\\uDE7F\\uDEF0-\\uDEF6\\uDF39-\\uDF3F\\uDF99-\\uDF9C]|\\uD803[\\uDD6E\\uDEAD\\uDED0\\uDF55-\\uDF59\\uDF86-\\uDF89]|\\uD804[\\uDC47-\\uDC4D\\uDCBB\\uDCBC\\uDCBE-\\uDCC1\\uDD40-\\uDD43\\uDD74\\uDD75\\uDDC5-\\uDDC8\\uDDCD\\uDDDB\\uDDDD-\\uDDDF\\uDE38-\\uDE3D\\uDEA9\\uDFD4\\uDFD5\\uDFD7\\uDFD8]|\\uD805[\\uDC4B-\\uDC4F\\uDC5A\\uDC5B\\uDC5D\\uDCC6\\uDDC1-\\uDDD7\\uDE41-\\uDE43\\uDE60-\\uDE6C\\uDEB9\\uDF3C-\\uDF3E]|\\uD806[\\uDC3B\\uDD44-\\uDD46\\uDDE2\\uDE3F-\\uDE46\\uDE9A-\\uDE9C\\uDE9E-\\uDEA2\\uDF00-\\uDF09\\uDFE1]|\\uD807[\\uDC41-\\uDC45\\uDC70\\uDC71\\uDEF7\\uDEF8\\uDF43-\\uDF4F\\uDFFF]|\\uD809[\\uDC70-\\uDC74]|\\uD80B[\\uDFF1\\uDFF2]|\\uD81A[\\uDE6E\\uDE6F\\uDEF5\\uDF37-\\uDF3B\\uDF44]|\\uD81B[\\uDD6D-\\uDD6F\\uDE97-\\uDE9A\\uDFE2]|\\uD82F\\uDC9F|\\uD836[\\uDE87-\\uDE8B]|\\uD839\\uDDFF|\\uD83A[\\uDD5E\\uDD5F]/;\nconst S = /[\\$\\+<->\\^`\\|~\\xA2-\\xA6\\xA8\\xA9\\xAC\\xAE-\\xB1\\xB4\\xB8\\xD7\\xF7\\u02C2-\\u02C5\\u02D2-\\u02DF\\u02E5-\\u02EB\\u02ED\\u02EF-\\u02FF\\u0375\\u0384\\u0385\\u03F6\\u0482\\u058D-\\u058F\\u0606-\\u0608\\u060B\\u060E\\u060F\\u06DE\\u06E9\\u06FD\\u06FE\\u07F6\\u07FE\\u07FF\\u0888\\u09F2\\u09F3\\u09FA\\u09FB\\u0AF1\\u0B70\\u0BF3-\\u0BFA\\u0C7F\\u0D4F\\u0D79\\u0E3F\\u0F01-\\u0F03\\u0F13\\u0F15-\\u0F17\\u0F1A-\\u0F1F\\u0F34\\u0F36\\u0F38\\u0FBE-\\u0FC5\\u0FC7-\\u0FCC\\u0FCE\\u0FCF\\u0FD5-\\u0FD8\\u109E\\u109F\\u1390-\\u1399\\u166D\\u17DB\\u1940\\u19DE-\\u19FF\\u1B61-\\u1B6A\\u1B74-\\u1B7C\\u1FBD\\u1FBF-\\u1FC1\\u1FCD-\\u1FCF\\u1FDD-\\u1FDF\\u1FED-\\u1FEF\\u1FFD\\u1FFE\\u2044\\u2052\\u207A-\\u207C\\u208A-\\u208C\\u20A0-\\u20C1\\u2100\\u2101\\u2103-\\u2106\\u2108\\u2109\\u2114\\u2116-\\u2118\\u211E-\\u2123\\u2125\\u2127\\u2129\\u212E\\u213A\\u213B\\u2140-\\u2144\\u214A-\\u214D\\u214F\\u218A\\u218B\\u2190-\\u2307\\u230C-\\u2328\\u232B-\\u2429\\u2440-\\u244A\\u249C-\\u24E9\\u2500-\\u2767\\u2794-\\u27C4\\u27C7-\\u27E5\\u27F0-\\u2982\\u2999-\\u29D7\\u29DC-\\u29FB\\u29FE-\\u2B73\\u2B76-\\u2BFF\\u2CE5-\\u2CEA\\u2E50\\u2E51\\u2E80-\\u2E99\\u2E9B-\\u2EF3\\u2F00-\\u2FD5\\u2FF0-\\u2FFF\\u3004\\u3012\\u3013\\u3020\\u3036\\u3037\\u303E\\u303F\\u309B\\u309C\\u3190\\u3191\\u3196-\\u319F\\u31C0-\\u31E5\\u31EF\\u3200-\\u321E\\u322A-\\u3247\\u3250\\u3260-\\u327F\\u328A-\\u32B0\\u32C0-\\u33FF\\u4DC0-\\u4DFF\\uA490-\\uA4C6\\uA700-\\uA716\\uA720\\uA721\\uA789\\uA78A\\uA828-\\uA82B\\uA836-\\uA839\\uAA77-\\uAA79\\uAB5B\\uAB6A\\uAB6B\\uFB29\\uFBB2-\\uFBD2\\uFD40-\\uFD4F\\uFD90\\uFD91\\uFDC8-\\uFDCF\\uFDFC-\\uFDFF\\uFE62\\uFE64-\\uFE66\\uFE69\\uFF04\\uFF0B\\uFF1C-\\uFF1E\\uFF3E\\uFF40\\uFF5C\\uFF5E\\uFFE0-\\uFFE6\\uFFE8-\\uFFEE\\uFFFC\\uFFFD]|\\uD800[\\uDD37-\\uDD3F\\uDD79-\\uDD89\\uDD8C-\\uDD8E\\uDD90-\\uDD9C\\uDDA0\\uDDD0-\\uDDFC]|\\uD802[\\uDC77\\uDC78\\uDEC8]|\\uD803[\\uDD8E\\uDD8F\\uDED1-\\uDED8]|\\uD805\\uDF3F|\\uD807[\\uDFD5-\\uDFF1]|\\uD81A[\\uDF3C-\\uDF3F\\uDF45]|\\uD82F\\uDC9C|\\uD833[\\uDC00-\\uDCEF\\uDCFA-\\uDCFC\\uDD00-\\uDEB3\\uDEBA-\\uDED0\\uDEE0-\\uDEF0\\uDF50-\\uDFC3]|\\uD834[\\uDC00-\\uDCF5\\uDD00-\\uDD26\\uDD29-\\uDD64\\uDD6A-\\uDD6C\\uDD83\\uDD84\\uDD8C-\\uDDA9\\uDDAE-\\uDDEA\\uDE00-\\uDE41\\uDE45\\uDF00-\\uDF56]|\\uD835[\\uDEC1\\uDEDB\\uDEFB\\uDF15\\uDF35\\uDF4F\\uDF6F\\uDF89\\uDFA9\\uDFC3]|\\uD836[\\uDC00-\\uDDFF\\uDE37-\\uDE3A\\uDE6D-\\uDE74\\uDE76-\\uDE83\\uDE85\\uDE86]|\\uD838[\\uDD4F\\uDEFF]|\\uD83B[\\uDCAC\\uDCB0\\uDD2E\\uDEF0\\uDEF1]|\\uD83C[\\uDC00-\\uDC2B\\uDC30-\\uDC93\\uDCA0-\\uDCAE\\uDCB1-\\uDCBF\\uDCC1-\\uDCCF\\uDCD1-\\uDCF5\\uDD0D-\\uDDAD\\uDDE6-\\uDE02\\uDE10-\\uDE3B\\uDE40-\\uDE48\\uDE50\\uDE51\\uDE60-\\uDE65\\uDF00-\\uDFFF]|\\uD83D[\\uDC00-\\uDED8\\uDEDC-\\uDEEC\\uDEF0-\\uDEFC\\uDF00-\\uDFD9\\uDFE0-\\uDFEB\\uDFF0]|\\uD83E[\\uDC00-\\uDC0B\\uDC10-\\uDC47\\uDC50-\\uDC59\\uDC60-\\uDC87\\uDC90-\\uDCAD\\uDCB0-\\uDCBB\\uDCC0\\uDCC1\\uDCD0-\\uDCD8\\uDD00-\\uDE57\\uDE60-\\uDE6D\\uDE70-\\uDE7C\\uDE80-\\uDE8A\\uDE8E-\\uDEC6\\uDEC8\\uDECD-\\uDEDC\\uDEDF-\\uDEEA\\uDEEF-\\uDEF8\\uDF00-\\uDF92\\uDF94-\\uDFEF\\uDFFA]/;\nconst Z = /[ \\xA0\\u1680\\u2000-\\u200A\\u2028\\u2029\\u202F\\u205F\\u3000]/;\n\nexport { Any, Cc, Cf, P, S, Z };\n","// Adapted from https://github.com/mathiasbynens/he/blob/36afe179392226cf1b6ccdb16ebbb7a5a844d93a/src/he.js#L106-L134\n/**\n * C1 Unicode control character reference replacements (code points 128–159).\n * Index i gives the replacement for code point 128+i; 0 means \"no replacement\".\n */\nconst c1 = [\n    8364, 0, 8218, 402, 8222, 8230, 8224, 8225, 710, 8240, 352, 8249, 338, 0,\n    381, 0, 0, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 732, 8482, 353, 8250,\n    339, 0, 382, 376,\n];\n/**\n * True for NUL, UTF-16 surrogates, and values past U+10FFFF.\n * @param codePoint Unicode code point to check.\n */\nfunction isInvalidCodePoint(codePoint) {\n    return (codePoint === 0 ||\n        (codePoint >= 0xd8_00 && codePoint <= 0xdf_ff) ||\n        codePoint > 0x10_ff_ff);\n}\n/**\n * Replace the given code point with U+FFFD if it is NUL (0), a surrogate, or\n * outside the valid Unicode range. Code points in the C1 controls range\n * (128–159) are remapped to their Windows-1252 equivalents, following the\n * HTML spec. All other code points are returned unchanged.\n * @param codePoint Unicode code point to convert.\n */\nexport function replaceCodePoint(codePoint) {\n    if (isInvalidCodePoint(codePoint)) {\n        return 0xff_fd;\n    }\n    if (codePoint >= 128 && codePoint <= 159) {\n        return c1[codePoint - 128] || codePoint;\n    }\n    return codePoint;\n}\n/**\n * XML numeric character references are the referenced Unicode code point.\n * Invalid values still become U+FFFD; the HTML Windows-1252 C1 remap is not\n * applied.\n * @see https://www.w3.org/TR/xml/#NT-CharRef\n * @param codePoint Unicode code point to convert.\n */\nexport function replaceCodePointXML(codePoint) {\n    return isInvalidCodePoint(codePoint) ? 0xff_fd : codePoint;\n}\n/**\n * Convert the code point of a decoded numeric entity to a string, replacing\n * invalid values.\n *\n * Fast path for plain BMP code points: [1..0x7F] and [0xA0..0xD7FF] pass\n * `replaceCodePoint` unchanged (no NUL, C1 remap, surrogate, or out-of-range\n * handling) and fit a single charCode. 0xd760 = 0xD800 (the first surrogate)\n * - 0xA0.\n * @param codePoint Unicode code point to convert.\n */\nexport function codePointToString(codePoint) {\n    return (codePoint - 1) >>> 0 < 0x7f || (codePoint - 0xa0) >>> 0 < 0xd7_60\n        ? String.fromCharCode(codePoint)\n        : String.fromCodePoint(replaceCodePoint(codePoint));\n}\n//# sourceMappingURL=decode-codepoint.js.map","/*\n * Inverse of the encoder's SAFE alphabet (0x21..0x7E minus 0x22, 0x24, 0x5C),\n * precomputed once at module load. Entries for excluded chars stay 0 but\n * are never read.\n */\nconst BASE91_INVERSE = /* #__PURE__ */ (() => {\n    const table = new Uint8Array(127);\n    let code = 0;\n    for (let char = 0x21; char <= 0x7e; char++) {\n        if (char !== 0x22 && char !== 0x24 && char !== 0x5c) {\n            table[char] = code++;\n        }\n    }\n    return table;\n})();\n/**\n * Decode a dictionary-encoded trie string back into its Uint16Array.\n *\n * Stream layout (consumed in this order):\n *   1. dict1 atoms — `dict1AtomCount` uint16 values, delta+RLE encoded.\n *   2. dict2 atoms — `atomCount - dict1AtomCount` values, delta+RLE.\n *   3. dict2 ngrams — `ngramCount - (dictSize - dict1AtomCount)` entries,\n *      each a pair of slot codes that resolve to earlier slots.\n *   4. dict1 ngrams — `dictSize - dict1AtomCount` entries, same shape.\n *   5. data — slot codes, each expanding to one or more uint16 values.\n *\n * Codes use a 91-char base (printable ASCII minus `\"`, `$`, `\\`):\n *   - char1 < dictSize  → 1-char code, slot = char1\n *   - char1 ≥ dictSize  → 2-char code, slot = dictSize + (char1 - dictSize)*91 + char2\n *\n * Slot index → token kind:\n *   [0, A)                  dict1 atoms     (1-char codes)\n *   [A, dictSize)           dict1 ngrams    (1-char codes)\n *   [dictSize, dictSize+D)  dict2 atoms     (2-char codes)\n *   [dictSize+D, end)       dict2 ngrams    (2-char codes)\n *\n * Both atom dicts decode before any ngram, and dict2 ngrams decode before\n * dict1 ngrams. So every ngram entry references slots whose contents are\n * already filled — no forward references to handle.\n *\n * This runs on library import. Flat typed arrays store each slot as either\n * a plain value (`single`, covering every atom) or a range in a shared\n * `pool` (ngrams).\n * @param input Packed trie string.\n * @param resultLength Expected number of uint16 values in the output.\n * @param atomCount Total number of distinct uint16 values in the trie.\n * @param dict1AtomCount Atoms in the 1-char range (`A` above).\n * @param ngramCount Total number of ngram entries (dict1 + dict2).\n * @param dictSize Number of 1-char code slots; the rest of `BASE - dictSize`\n *   first-byte values are 2-char codes.\n */\nexport function decodeTrieDict(input, resultLength, atomCount, dict1AtomCount, ngramCount, dictSize) {\n    const base = 91;\n    const inputLength = input.length;\n    // For 2-char codes, slot = char1 * base - twoCharBias + char2.\n    const twoCharBias = dictSize * (base - 1);\n    let pos = 0;\n    /** Read one slot code at `pos` and return its slot index, advancing pos. */\n    const readSlotCode = () => {\n        const c1 = BASE91_INVERSE[input.charCodeAt(pos++)];\n        return c1 < dictSize\n            ? c1\n            : c1 * base - twoCharBias + BASE91_INVERSE[input.charCodeAt(pos++)];\n    };\n    const dict2AtomCount = atomCount - dict1AtomCount;\n    const slotCount = atomCount + ngramCount;\n    /*\n     * Per-slot contents: atoms (always a single value) live directly in\n     * `single`; ngram slots hold -1 there and expand to\n     * `pool[start[slot] .. start[slot] + length[slot])`.\n     */\n    const single = new Int32Array(slotCount);\n    single.fill(-1, dict1AtomCount, dictSize);\n    single.fill(-1, dictSize + dict2AtomCount, slotCount);\n    const start = new Int32Array(slotCount);\n    const length = new Int32Array(slotCount);\n    /**\n     * Decode `count` ascending uint16 values from a delta+RLE stream into\n     * `single[off..off+count)`.\n     *\n     *   code < 89   → delta = code\n     *   code == 89  → run-length: next char encodes runLength-2; emit `runLength` consecutive +1 values\n     *   code == 90, next < 90  → escape: delta = 89 + next * BASE + after-next\n     *   code == 90, next == 90 → double-escape: extra char for very large deltas\n     * @param count\n     * @param off\n     */\n    function decodeDelta(count, off) {\n        let previous = 0;\n        let slot = off;\n        const end = off + count;\n        while (slot < end) {\n            const code = BASE91_INVERSE[input.charCodeAt(pos++)];\n            if (code < 89) {\n                previous += code;\n                single[slot++] = previous;\n            }\n            else if (code === 89) {\n                let runLength = BASE91_INVERSE[input.charCodeAt(pos++)] + 2;\n                while (runLength--)\n                    single[slot++] = ++previous;\n            }\n            else {\n                const next = BASE91_INVERSE[input.charCodeAt(pos++)];\n                previous +=\n                    89 +\n                        // eslint-disable-next-line unicorn/prefer-minimal-ternary -- branches read a different number of side-effecting input bytes\n                        (next < 90\n                            ? next * base + BASE91_INVERSE[input.charCodeAt(pos++)]\n                            : BASE91_INVERSE[input.charCodeAt(pos++)] * 8281 +\n                                BASE91_INVERSE[input.charCodeAt(pos++)] * base +\n                                BASE91_INVERSE[input.charCodeAt(pos++)]);\n                single[slot++] = previous;\n            }\n        }\n    }\n    // Streams 1 & 2: atoms decoded into their slot ranges.\n    decodeDelta(dict1AtomCount, 0);\n    decodeDelta(dict2AtomCount, dictSize);\n    /*\n     * Streams 3 & 4 are read in two passes: first collect every ngram's two\n     * references and derive its expanded length (each ref resolves to an earlier\n     * slot, so lengths are already known), which sizes the shared pool.\n     * Pool ranges are handed out in decode order, so the second pass fills\n     * the pool contiguously with a single write cursor.\n     */\n    const references = new Int32Array(ngramCount * 2);\n    let poolSize = 0;\n    let ngramIndex = 0;\n    /**\n     * Read `count` ngram entries (each = 2 slot-code references) for the slots\n     * starting at `startSlot`, recording references and assigning pool ranges.\n     * @param count\n     * @param startSlot\n     */\n    function readNgramReferences(count, startSlot) {\n        for (let index = 0; index < count; index++) {\n            const slot = startSlot + index;\n            const a = readSlotCode();\n            const b = readSlotCode();\n            references[ngramIndex * 2] = a;\n            references[ngramIndex * 2 + 1] = b;\n            ngramIndex += 1;\n            start[slot] = poolSize;\n            const entryLength = (single[a] < 0 ? length[a] : 1) +\n                (single[b] < 0 ? length[b] : 1);\n            length[slot] = entryLength;\n            poolSize += entryLength;\n        }\n    }\n    readNgramReferences(ngramCount - dictSize + dict1AtomCount, dictSize + dict2AtomCount);\n    readNgramReferences(dictSize - dict1AtomCount, dict1AtomCount);\n    // Second pass: concatenate each ngram's two halves into the pool.\n    const pool = new Uint16Array(poolSize);\n    let write = 0;\n    for (let index = 0; index < ngramIndex; index++) {\n        for (let half = 0; half < 2; half++) {\n            const source = references[index * 2 + half];\n            const value = single[source];\n            if (value < 0) {\n                let read = start[source];\n                const readEnd = read + length[source];\n                while (read < readEnd)\n                    pool[write++] = pool[read++];\n            }\n            else {\n                pool[write++] = value;\n            }\n        }\n    }\n    // Stream 5: data. Each code expands to its slot's stored values.\n    const out = new Uint16Array(resultLength);\n    let outIndex = 0;\n    while (pos < inputLength) {\n        let slot = BASE91_INVERSE[input.charCodeAt(pos++)];\n        if (slot >= dictSize) {\n            slot =\n                slot * base -\n                    twoCharBias +\n                    BASE91_INVERSE[input.charCodeAt(pos++)];\n        }\n        const value = single[slot];\n        if (value < 0) {\n            let read = start[slot];\n            const readEnd = read + length[slot];\n            while (read < readEnd)\n                out[outIndex++] = pool[read++];\n        }\n        else {\n            out[outIndex++] = value;\n        }\n    }\n    return out;\n}\n//# sourceMappingURL=decode-shared.js.map","// Generated using scripts/write-decode-map.ts\nimport { decodeTrieDict } from \"../internal/decode-shared.js\";\n/** Packed HTML decode trie data. */\nexport const htmlDecodeTree = /* #__PURE__ */ decodeTrieDict(\"!}.&u%}'&}*'~!6*)%&,~!J~!J~%L~y<~!R,~~%Lu~~#GD~~#|)1#%}^%}2%+#.##%##%}&%##%'#%##&%#%#'%#&#%#&#'#%%#&#%##%#)%''%&%#%#'%#%%#%%}%%%#%#&(23#%%#&-%0%('1#(##%#'##+%'*.:1}#%#6-+(%'%%#%%%}#L'2351&('%}&/N'(0(/*-%(%%}#'+&T%7.2}#&%&#%#36/5##%&%%#&#%%#))2%%##%&&'0~!#*+&'%1~!%).'3q?&%'1~!.##%6(~!+%%%(Gw'rT~!E#<nA%#jZ~!H%(~!42##~!*31&~!G%U~#)5~#`3~!J~!Z~%]~%Y~%C~!q~!u~#kz~%#~!6'~!D~!U~!?~#T~!c%~!G#'~%7|~!G~!J~!G&~#pb~(Df}#%}*&}#%##%##%##&#-}&'#'&%#.++}%mI,#,@&(}*%}*'%&##&#%##%}&0}#.},U},%}+%}&%}#%##&}B%(}(%}+%)})%##%#&}&%##%&}<%}>%#%&}*%}(%}9%}/%})%}*%}*%}?&}&%}3%}&*#%})%#%#)}#&#-#+*%E%%'%'#%}#*V##&##I}#&&##%&%#&&Qf%%))w/0+&%#(#.%-''''++++7}>%4'',##1,#%#&%##&#'##&#*#9)%&%}#*}%,#+P(%A&%#'&##wSD',9E00#y#@}(+}&%&>~!#~!X}#*}(&&}(&}(,%}%&#+&}#&}I%#%}%)#(},'%#*}4%%#%}(''}#/##(##),%-##%%)#&}(.}&%#&}%%}*&#%},&&}&%}#%*'#%})%}D&}&%}-&}6&#&}-,%}#%})-(~+`~,=?~I9'9%~!,#%})%})%}@%}?%}(~!?~#<~#pP~#BG~#=1#%K+~#?#~%;)~#A~#mF1~#A'~'X%'~#lR~#N~'N~#r~#m#-~#i'?%#'%~#B%##%,%#~#_%#0%~#]732~,w~2+#:&#%&'0%&>%}#>##F+)#%&&#(+_}4&}-%}(&}@&}O7Fdf0@+/v4}&WU##&/0#&'('B#%}.%}'+#%}#%%&#&%#%##+#&#)#6#'#.},%}c%},%#%##%&#&%#&~#>'*-.%##%##%}#%%}%'~#)D1}#%*&~#_%%'(~#S2%'.}#~#=##*'*-%}&'%'##&&~'E%.#&~#M4}%%##&'%#~#O1##%&#'+~#<B%##%%'%+~#;#@%}#&%#&&%#(~#H1}'%'##&&~#?A}&'~#D#%32}'&&&&~#[}'(#%}'~#;C})&}%%#%~#=&%,3}%'(#%%~#^'#&&)#%'~#Y%-~#d-%'~#^%%&#&&&}#~#b~2t*&'~&(~&@~0%~e~3}%*''0})&}+~!9##-}#%-hD*)1fC#%/&/fB#40~!+#)*4~!+~!K'&:~!/*7~!.#~!H~!L':~%x&~!H#~!*~%1~!I#~!+A~#p'~!F~~#-#~,,(~.Z~!V~%;'B'mq-W~!N~%I%#&&#&}#%},%%}'%}+X#%}#&}(%}'%}<%}#%}%%'}'%}:~![)9@~%>~#UA%-%##&~!C%~!-.9:~!1~!-^2/:a~!y,D*J#-5)/4~%23,~#G~!L1~!0X3`~!2+~!!0-~&E~!W~!o,>Y&]~%cZx_&~#O*9#A#'#+I'%#)~!0B*-5A+-((F&*M#)(-7-5+'-3a5Vi~!Y~!?+[)%3),ERHm~!+:D,VG.+)?fB%%*(%)'(#&80%1'8`K8?`+'Z#&O&'H5#*9)A%%5&3))0%39+.*7#()&&*=4@**L)<'_&*+..;(#*+)./&0#3)%')-8(4ixD(&.}%,('aI:,)%,k2231T)I'#/-W7,/'Q#.'Y24+h')37</31&83##&0#),H(?'&?/1##%#&&#%''-%&&&#(&''&#.-'%#%%(,')*'&#&#'##%(%(#%('#&##%%%%('%#%#%%#%#&%##h>w+v<ayvyvcg.uuhKr}g/v|g>u9i[~>g5uI~=RvdwEg;v/g;uk!!TTSx]@RT!U!#!@VBRUU!'UTe-d0c`e&gSdicedFcrdTaqb.kYcAohdYd@a3e+d}dMdtd.aJ#bqcK`dle/e.e'dwdPdodddjbEb}ogd^ofdpduc6j?l%d{drdqc)d7bacOdQ%T#Y)X.sR[yH>6Vyv3[xwLu>vo'!*.[yBacahoj>6Rew3[xqdZa#!a&#^(X-[yG>6Vyu3[xvg3sEr|g.u/Ri9db0T#^(Xa)!-[y;>6Vylg4wKs{JwNZt3@3r=c4Z([xlg;wKt!cpq's@v7A'*a(a+!-a#[y<3Dt?3Dt'>6Vym3[xmg9rxsNJwLZt4~?r?db1T#`-!(Xa,!0[yS>6Vz%NuQs.g4wKtnJwNZtS@3r>c4Z([y%g;wKtrdga8!a(!#&T*Y-Xa#!a0<or[yc3Dtq>6Vz43[y3JwNZtf@3s!Ju}!%Dti:pm3c_%X#tjB5pkd6q!r]u?voC'*-a.a2!0a&a+[yI3DtI3Ds~3DtH>6Vyw3[xx;:s#~<5pKJwNZtE@3r~d`a)!a2T#a.(!+U.X1[yT3Dt`3Dtv>6Vz&3[y&g9rxwzcxstPu.<rAJwLZtT~?r@dZa%!a.&^*Za(/Reu[ya>6Vz23[y1g3sEr}wkg{NuQRg{ci(U#5@b`~,cg#U(2WnH5wugcRh7dX#T(Y,a'Ta!!a,[yZ<]mj>6Vz,3[y+Pv#5ReZKu+=,%!H}7ABwkaS?Rh:BcW(X#<]mrj:ubv/ARekdg%!(!a.*Ta(Y.X1!#sP>Rl*Dt6[y>>6Vyo3Wf*jOvuumvuRgRJuq*!:9<B@bX~3jVv&v@s@5Re[d/rQt{uAvo&a&a*)a2!,0Wf!3Dt0=Bs'>6Re}3[xy~<5s%JwJZt1~Gs)c;&!#2sJkNuXvzq7rxu,Re8dka4!a8(aEZ+a@Y.X1Xa)[yd=Bs(3DtP>6Vz53[y4cX#X&Re:avRe9~<5s&JwJZtQ~Gs*i^rzvdRg+Jv{%!2sbB@bX}kdga,!Za?&^*T1/!a'Dt+[y6>6Vyf3Wf%g/u;s4hGu6?Rh-JvZ,!c%#&RoX54Rivj7uyvf8RgTKvZB%*!2sGh<vu5Rgq<=C::9bb~#dZ#T&Ta6Y.X*Dt>[y93Wf)coZ(T,6VyifluvRgC@95@B@bX~/hFu34cC#T,k/unq8w8Q5RkUklwQuzunq8w8Q5Rk8d/rJu?v8w9)-&!a0a;a&aIWejg3sEr/h1s<DtDJvyZqY5aws3Jvy!&Wei~Hr1:au5@Bag>23E~5c:Z&bX};kKv?w&unuVu5Rjc;>bs)#~@:Rh.=ay<a]C;b`}Vd6s/t{uAvoaxa()!a,a7%-a#a2Dt,[yF2Wo[>6Vyt3[xuNuPRi&NuPwpi#RoWh?vf8Ri%Jv]!%Ri:KvxD!.'2WeAjZu`q9rxu,Re7woeAg-unLq(qA_/*2Wg_g3u5q^9:4E}/jTrxrzv=Wkkd~0UX#^^Xa-a1a5T&a=U1a'*aEa]!a*aPaA-adok[y54Rn>;:p3~Dp5g9rpsFNvZqjg3uJp4~<5p0Pw;5qlJwNZt*@3p1Pw:5p/Ou!5p2JvG'!6Vye=<qnJvh_[xhg3v,Rh3kOwOw-sDuev/Re^dha[a%!%!a+#Ta7)-5TaCaO!aka!a)sf[yb2>Rl!9ARiq5E}Qg=ucRkBE|oJrJ_@Wk~@Wk{JrJ_@Wk|@WkyJrJ_@Wk}@WkzJvO_[y2g-vMRmiKuYC!)&>Ri;>Ri<@3RkNc](X#@9Rk=g5vuRmhKvDB!+'=]meg3u4Rmgd)#Y'Vz3CARmfd`a+!%T'!+#Ta1Ta6TaM-sTDt9[yA9sYd'%Y#s[[xpj:ueunaXRgEjRq,v-vuqdd2'`#6Rev<32@5>:2<E}5xIo9a*X#Y(;5RePJvD_g>vyRgNj8w)v8<wggs:RgXiZt|vjx,hSq3ah!-(~@:Ro/Ou!5RhWj^v(pyw8unRhUdx-UY#^Ua.a3a70!)%UX1TaDa)'omRiRRhE[y:3Dsz=Br,>6Vyj3[xkg6ruwjcqsrPw;5r*Ku]D'Zt-@3r(~?r.i[vwv]dU1a--U#`a4(g/vsRhPOu!5RhLj:rmu9Wo!~@:wdh@g/vsRiTjXuvvNr}:RhBj^v(pyw8unRn]dz1UYa'a+^Y(!aETZalaRY.Ta?a4[yDJw1!#qLsW>6Vyrfzq-pLflpwRe|Js>%!Dt@3Dt&Jvy_[xs~HrnjMuwpsw'RecKu+D#'!t<~Grl~?rjg5u-x,gwp{ah!-(~@:Rg~Ou!5Rh'jXuvvNr}:Rh#cW#X/c;&!#2sLi[v7u7RgpJv)(!iLrxu,Re6j7v@s@5Se[e7d`aW!Za(a`T.a#!a3!&aDa-!9)Dt_=6s+3[x~~DR|h~DS6avhGun5RkZj3w)v-]mkKunB!&*]kb97R|i<ARk<c:Z(6Vy}Juh'!wziMRoS:F|vkLuauJv5vtvQRh1d='T+Y#VyO~DR|jcF#T'7R|g97R|kJv3'!ay<Rj,Jvh&!:ReXcsa6*a+#a#_aIRf9aLRf?c,Z&Rf5Rf7c.Z&Rf;Rf>cQ#%T'p-Rf8Rf=ct#%'(*!,p,Rf4p+Rf6Rf:Rf<d~'Ua%U*^UYa(!a,-!#a4YaTalaEX0a8a<Weo3Dt/3Dsx=Br93Wen~Dr;~<5p<JwNZt2@3p=Pw:5p;Ou!5r3c7&!#:p>3Ds}KvGB)_6Vyk2sM=<r7x'eovA(!hFu1ARf}cV#X&@r5j6rvwQa^Rf3c=Za'wkghJv__g;unRggA53B9=b^}%j6uduo5Jq;!(hIv%2Re`Ou4ARe_e%a#^^^Xa&!a*a2!&a6YaP!*ad!#a:aE/5Rn?[y@>6Vyp;:pE~DrY~<5pBJwNZt8@3pCh=rt3rWPw:5pAJup_[xoNuPpF9c!#'45pD5ARn)d8#X'X*3@rU72s]h>v<<sSjJpqvewOJq/(!hNw'5ReBk0s2u3w/w'5ReE5@Jq.!a+JQ!&WeU23d(#Y&RjG5]jBk!u7w&u0udARjEe#+^^^Ub#!a2/a`Z(agT1!a-a;|@TaG!aS[yV=Re~fow'RguNuPRe?bz#'>RoUWeL>:Cbb|?JwPZtVg6ruRmzJvD'!6Vz(g/vmRh~Jvy_[y(g9voRgyx*cy(#2>Ri2B9b]~9kIw9u7rluJu3Rg]dI#a%UY'@=p%CAx.gQZ&RhwwygtRm{x5g_Z'+ABqR9Woa=Bp&dV#^*Xa'!&@o{g4v]Rk;Jv{!%Rk[wkkiA5RkiwwfUB=x,fUuqC&*!>RfTg8v0RfV~ARfSd;rJsAuAv9wR'ae+/aO!a@aza/a#[yQ@Wg!2Wemg3sEr0JvB_g>uvReWg2v+Re=KupB_+[y!2AbY~-~Hr2AJwD!(h<~El>h<~El?Kun@+_:9b`}Kg-v/Ri3g;vtwyk_9]k_d=&T#*U.6qh@Ab`|K9:H|CJv[!&3Dtex'fDwC%!Rf[9WlMd[(^X,!a%Z06Vz!@WgBg=v~Rgvg,QRe@awd,#Y+jTv|Q~EfWj]uNr|~FRfXdy#Y&^Ua%!aO.!(a)Ua;=!a@aKap!a-,a!Ta]a[rSa]p?[y82sK=Bq~;:p:~<5p8Pw:5p7d'#Y'Wf(;RnRi[u4w&RgJJvG'!6Vyh=<r#ijuuv/sIKuYD'ZtG@3p9~Gr&d2#`(g<vtRgFj`u5w&rqpxRf2CJuY!+:wfnTOu!5Rg}jNs1ucv&RfwJvA!&3@q|BDcC#T,k/unq8w8Q5RkTklwQuzunq8w8Q5Rk9dga#!a'!a=#a0!:+Tb*b@aO.a4!aba8aFJv^}?!VyR~Dr<g;u%Rn.~<5p[x'e`wNZtR@3p]Pw:5pZhNvjBp.woe_g5u-r4JwF!%DtO3:ooc7&!#:p^3DtpLuGw(!+%)Dtk6Vz#2sd=<r8d'#Y([y#<x3gJt`w@!)%}MRiowzikRij=]ilxAf3,U(#B2Rf#g0v-Rm[ck{`U#]giKv3>)!&6Ri154s,KuGB_%@r68r:dJ|t`#X(9<E|u2@H|rx3gJu?w'!+'1Nu7Reg4=H~+9<wxgY95Rm]xLggZ-`(X}U2:Ri4h<uOawRmsJv__5@bb{jbV~3dka#a'a]!,#a+U=a>b6a3b%!/aKa/)!arwve^VyJ;:pR~DpTg3uJpS~<5pOPw;5qmPw:5pNOu!5pQJvG'!6Vyx=<qoJvA!{~Jup!%@qk7Rn/KvyD!}''[xz;>wkh'?Rh,x8gyt`w5D!&),(SgyccRgztJ@3pPB5p#d'(Y#<]mmifubw&RgoJvE&!82s^JvF&!8Rf,ADb]~;x=h'rNu]vK!,%'*0RnORh)4Rh*AqQg-vaRnNg;wHwkh'ba~4cE#Ta*x3gctyw@'!+%RnFRnD<4Rn@hFvK5RnCxWg[#`&a0Ua()`1Rm75Rg[c]%X#qi8Rg^NvdRj>BwzgZauwji7Rm6A4wgg]d1#&(*,.0a#Rm;Rm<Rm=Rm>Rm?Rm@RmARmBe%#^^^Xaea?aC/b+(,!a+a#!a/!>a&Ta<aKbD!2wphBRnk[yPw}hE|.=Br-3Dtm>6Vy~g6urRf.x,hPrNav!%'RnqRo%Ro#Nu;q[Pw;5r+JwNZtM@3r)d'#Y'Weh;xChL#`&RnmRnoKu}>%(!Rne~Bs-;2wjcussJv+'!aYSO}6@B<5?ba~8LrNvj!.%*ROwungw~ng~:9;Ri^>wtnig;wHRnixDh@|(UZ.x1h@|)!#:2<H|*xHn]#-UX'3Ro)z=iT}6ARns=Bwsn_wpnaRncw]aR(#UXa&Ua*a/=]iPd'#Y&Ro'WnXf{QRm2hNvj]nZd`'T~&1`{|`#9b]{}c:'!#Wl{>@=be}]?cl{{U#:5Abb}Jds#^YaF!a*b4a#a3aPa>&Tb!bH!*a_!Eau?/a&RjY<]gj>6Vz*;:pe~DrZg,QRj1JwNZtX@wihspcJvZ&!VyX9WmOJu|!|N2WmHJvh&!]ht~Bpbcn&T(!#RmQ<s7Nu;padH#X'`+WmJ@>RmKCARhnKup=!)&Wf+:RhqNuPpf9c!#'45pd5AwghpARn(Ls@w!%,)!RmP@Wfe<E|IJva!&WmNg8vsRmLd`*.`#Y'Xa!axRn*]hrA8Rhug5s@rXg8u!RmMd8#X'X*3@rV72smdI*#UY&RmICARho~GsgxVgd)Ta'U-Y&Xa!T#RnEWnA@Wffg1uDRi0hFvK5RnBxGnG&#`%owp)@wsf+bX}Ze-*1!a*^^^Ua|!#a.aq&Ya2!a>.a6!a:aO`aJDtL[y`@Wg#>6Vz12@wzoYRoZNuPRi!NuPRhzg=ucRi,@=b`{Yg=ucRi-ACJvB!&Sh[ebSh]ebi`wUuFRm4Jw2_[y0JvB!.<Ju(!&SoG}6Shd}6<Ju(!&SoH}6She}6Kur@._g5vHRieJvx!{L2G{Kx6gd'T#?Rh82Wi5cZ#X(g1w)Rm5dW-Y(Ta#!a)!#aYa=wnfE=su2>>bU{0j9udv:<svj8uQv-7RgHdE%#^'sq9sp=>Bb_{TJv`!&g/r|snj6v(us5d,#Y(56H}[978H}]Jw5!&g1rushJvB!+j;v{u5?zDhd}6}bj;v{u5?zDhe}6}ce*#`(^^^a[aea!=!a6a*aoXb1a.!aAbL!b>,b'aL!aV@Wf|2Wlg3[y/JwNZt^@3piPw:5pgJunZou3@rsJva&!Vy_g<v~Rm#JvG'!6Vz0=<r{Ju{%!:pj@WfsiXuJu3Rm:JvZ&!WfA~Bph@c4Z&Dtwax5rubx(#:awRk1@d,#Y&RfjRfid1#,Y(@Wfp2Wlrg5s@ryKu[@!,'=]ig9wlk?Rk>g5u-rqJvy'!@9RkQcH(T#=>Ri~@<wkj(Wj(KuZB*!&<7rw@9RkRcH(T#=>Ri}@<wkj)Wj)dg(Ta2Xa9X#`-!a*CARhg@@=I}d9x;c~#X%so=<sj>2@@=aybb}XjWv0Q~EfEj3vLv;<d,#Y(56H}`978H}_dgaPaFa'a/!#a3Y0a_a;a|!1(a7-[yE3[xt;:pJNvZrrg3uJrvJwNZt=@3pIh=rt3rxPw:5pGOu!5rpJvG'!6Vys=<rz@c4Z&Dt(ax5rtJvZ!&~BpH@wsfNg-vaRlNci*U#=<wei<F}a5@Jq.!a*JQ!%@qZ23d(#Y&RjH5]jCk!u7w&u0udARjFd/prq=tyvpaEa(a:.!a1aZ(@@=I}:9wpd%=<sX55w_h}@@=I{t=ay<aU@@=I}T=ay<2@@=I})?C9:9au@9Cb]}DP~=x-fAZ(2Wl1=ay<aU@@=I}>5@d##Y+jTv|vV~EfFj]uNpn~FRfGdgaK!Z2&!a8a-Tb({E!acTbM*!a(DtY[yYd'%Y#sl[y*hHvh>Re5x2c{Z}.j4uCvcawRiMd+#X+_x&d!},<5RkX;2Hzw@x,gavfB-!{CcF&T#Roe;RodwWbBg5urRgaKvHC*_6Vz+<4opieuew&Rmq@d]&Y)X,T#X0Rh}<BqP=4qS9:ReMg/ujReNJw0!/<Jui%!bd{kawwnemRelAxUa?a3#*.&UX(Ya+a/RhvRnQ<o}9Wmtd-#Y&RgSRmw9;Rmxay=Rmyg-vaRmuxEhSrNu,v-voC!%(aR.a(a7+1Ro1>Ro5CE{A9b]{@;5x#eO{:g;urRi+KrNA!%(Ro3>Ro79;Ri_Ku@>{;&!x%gX|{KunA_+g5QRj/g3u5Rj#g>uERj%wio/xRhS&!,!#^1U}wba{8>>@=be}qC@:D5ba{7Ku+A&!}x?ba}t>>@=be}se(aA^^^Uat!b0#{pa+awUazbGa#aLb9bgaWac'a5TbS=Br!d1#`%scp_Jvl!#rT>Re0JvX&!VyN=H{Fcm#U&:pY=ReaJv2&!]h0=]nUJvG'!6Vy|=<r%JrM_=]h2@Wlud'#)U'Wf'b]{i=]h/Jvh!&~BpWg=v]RnMx+ny#'Nu;pVwjnu=]nwxJnx,T#`&Reqwjnt=]nvieu9vrRjLLuYwP(#+!th@wih5pX~Gr'g5v/Rh4KunA'!-CARnP@wwiN:Rm_9x'cvw>!|l=<saKvAA!0&3@q}>w^e1bp#&Re2Re3BDx7gH#T|f5H|eKuZ>!%(:qNAH{]Jv6!+3B2B9=b^{X<5<B92:E{ZLvhwA(a;a%!igQuyRmad+#Y}m@3Rh5d8#X'X*:AqUAHzmaxwbh<aXRnVcF}RT#Nw&cj#U(BWnug/vsRntdka)(a3+.Zb7aYYan1!bVa@Xa}[y^@b[{G=H{+hFu73Rj&Pv#5ReQcK%T#sig1v{Rj'Ku+D#'!t]~Grm~?rkKuMB!01d5#`'Vy.ta3Dtu~Hroc8#'{^45s85AwZbP&!#Rn!wghxWn#KvEA!)&2RlA2RlBx:h|#(T,=]j09Wobz>x]z/@awRoTd+#Y(az]hFhCrm4d,#Y+jTv|Q~EfMj]uNr|~FRfOdCa!Xa9_X#@<plJvf!%b`{(9;Rgwc;.!#2x7cw#T|UDb]|T5Ju={(!=@E{&Jv)&!Ab`{'awJvf!~*>>@=be{#KuY>!+&4Ezyi[ugv&RjIdea+T)#UXa&T-T&a!Rh9auRmW=]kLg5vuRn+g3u4Rn-Ow6ARn,hHus5xNk?#UX(U~)/g8v0RkD~AwkkF?Ri.OuNBwkkA?Ri/d|a2`a*^UYa.!aBTZaTa'Xa;!(!2!-a#b2[yC>6Vyq3[xr2Wi?g1rusVh%s?DtF~<5rbJs;%!DtBfswKtCj[uvuSsEu3RgVx3o:u+wN'*Zt;@3rd~Grh~?rfg8w)Lq)qE&-a%!>bI|`jWv0vV~EfCjTv|vV~Ef@j]uNpn~FRfBcK#T']gWNu7x,k7q4ai(0!hHv8<RhmkMu9vrsBuev/RhlCJvB!,g<v{wchh~@:Rhji[vrv{wchi~@:RhkdS&a5UY#Ta!RgPwwiI5BwciI~@:Rh`x'iJvj'!5]iJPu8Bwch]~@:Rhach)U#h3rp]gLh@t|Ax,hTq3ah!-(~@:Ro0Ou!5RhXj^v(pyw8unRhVd|)`,^UYas!a?/a2Z'a^Ta{Tb7Ta(a#!a,Wf&9sZ3DtAadamov=Bqt3[xig8vsRm~>waiL2b`{QJv*_Ouv2qgj<v]v2BqfdR'X*X#Y-@3qr~Gqv~?p6hHv-]glPup5Lq+q?_%*b_{qF{n9b^{rOu4ARhpKvCD!+&~Bqp:5Dbb}nwoiKl&unuTuBv]v+ueunaXRf0=Jvh!0nKufu8v1w&w7q%w&uHrz:Rgnj5w,uxDJq/(!hNw'5ReCk0s2u3w/w'5ReFd>Za&!*UaA=<wkgsRnSJv^!%Refifw3vyRgOKu_B'!,<]gkiiu:w&Rh<=C@a^<B57@2F{[<B5@aW:=3away9A5aW=<B=C@a^<B57@2F{Ie-#`(^^^bCara.b8aza6!/bZ,!adTbnTbOb+aFaS!aAT9@Wf~2Wli3Dtl2@d,#Y&RfnRfmJwJZtN~GqyJva&!VyMg<v~Rm%iXuJu3Rm9Jv[_=]ih9wlkDRkCd1#`(@Wg>2Wls3cH#T(@<Rj*=>Ri|b~'#23s9h<~El.d'#Y&Dtxi^rzvdRl#d*#U%(o|B2s`hJwSaxRmDKv4B&!1:Rmdd5#`'Vx}to~Hq{x'f1v3(!BA5ba|bJv_&!Wfug1v]ReIdO+U/Y#&G}-8wze=Rh{g1v]ReHg/uQRf/by#)ibQwERl/cH#T(@<Rj+=>Ri{cNu+vlax-!(#a0qa9<Rii2;;bU{H;x<i=&X#Rk`<4wwi=C9H~8xAI(Y#<azRi@45wXI<B9;5bb~7dL(X#Xa(+!aL6Vy{g5QqOau:5au2@ay547EzbxOcU(UX-T#Ta#:Cbb|A?wjh/b_|SOw6ARgtihr}u7Rhy<d1#T)X1@@=I|~=ay<2@@=aybb}Sj3vLv;<d,#Y(56H}A978H}@dGpvs@uAu`vcw9*!aFa+ai%(b!aXa8.a?a[ozWey=sU2@G}Nch&U#Rf_WexKu+D#'!t:~Gr`~?r^j]uNr|~FRg*j^psurwJt|RmcKv)@&!)7Rkv~Br[@wxfO:Rl3co#U'6Rezj_q#vIuavjRltwzeyh@vr5JqD0!>aY?C9:9au@9Cb]}9cl#U*5;5<H||jbuus1ucv&Rfvg1v~d/pppzqFr^a--a~!aMat1(hFv;Wiz@@=Izoj5uuv-7Rix~Cw`fk2WlVcZ#X,k)u3vWs@u2]ktg;wEx'fBq(_2Wg/jTv|vV~EfoJv]!15x'hzqG!(P~EfU~CRl_j6v(us5x4i-#T(2WmZ?C2F|d>Kq<aj1!*jTqIsBv=Wl`~Cw`fi2WlWj`v0u*~>RlR=c>Z,k#u3vWs@u2]kr<c1Z+jTqIsBv=Wla~Cw`fm2WlXdmb3!a{(arZa`bkTa%TbQTa-a9+c'!aM!/[yL=Bqug.w'RifhFvyDRj.g>vgwyk^9]k^Jv3_@WfbAARkhJw2_[x|JvB_wkoIRoKwkoJRoLd'(Y#<]gm=<9<H|yd'%_X#skDtb3awwqkgNulRkgdB#^',9:p'hJwSaxRmEBwVb8@4=H|qLu+w50&!)@3qs~?pU>Awwn;;Rn=c:Z'ARn<=<qwKvC@!/&~BqqJv6!&]eVb^z^xRge'/a%+^`#Sge}6<4Rn3=]n0Pw2>Rn8Jw0!&>Rn:>Rn6cY#a7+!a&=<wkaNw~h3z_c5Z{=wjh#=]nLKv^D!&)Vyz=bW|swYb<WetcG#T(2wxa@qVx@gD#Y&b^|V5JwG&!5bb|pg/w&RgD@x=kHs=uAvn!a%%/'+RmSRh694Ro`g-vaRmRhHv-]mlxCcS#`&ba~.5cD#Ta)P~=d,#Y(56H{>978H{Dd_#{2^Y%_+qbbb{6g3sERhsbU{?dfa.,`a(Xa<!aiX#(55RiG54RiHcI#T'WiU3RiVNvdwtfcRlKNvdd,#Y&RlHRlExQgf.1*^T'X#Sgf}6Wn4=]hfPrk>Rn7Jw0!&>Rn5>Rn9Lunw?&a2!,5<oq@@wqfdRlJj5Q~=d,#Y(~ARfcOuN]fdDKw;ay(}i!547E}j?cI#T(@5bV}iCbV}hdv(^^Tb?a40,b##Tbo!a*bR!a<b|a/!aKai!aU[yK=]o^g:v>ReGJwPZtK<7Rh+h<~El,Pv#5ReR@awwxjCg,ulRjDJv6&!]j!z?aQeeg>w=Sh<eeJw;!&axEzOg,Qosc!#*:wkeJ]eJ>x'h-u(!%Ro.w~h.zPdNZ(X,Ya![x{;9ReY;wkgxRiF:x?ap#Y&RmUg<s2Rkod]+UY0TZ'!a&A9sw<=bczLNvuw{gqzNhJwSaxRmCKuLay!#&s_Rf-55b^{uJvZa!!c%#(55Ri654wmiu5RiuawLu,vp!+}^%b_}Y9;wkgxba}o>A9:=b^}zKuh=a''!3awRk3c*'!#aHRk6c+Z&Rk5Rk4Jv)&!awRjSawd9*`#0?C2@EzMj8u<uJ5RmbjQrquJu3x,k>uq@_+=ayb^|W~ARkEOuN]k@7dhzV^X/X&a-#zRzSb`zXcJzTT#2WkVKvDBzW!%FzY9;5bbzWjQrquJu3Jw3%!b`zU=ayb^zQd:#X(T-a!6Vyywxh}=b]{Jg=u1RiAdGp~qHtzv!w(wA+a+a;<!aJaYai'anasb(=azRmV:Cbb{MLq2vb!%')RjuRjrRjtRjqx3jnqCw3!%')Rk(Rk+Rk&Rk)Lq2vb!%')Rj{RjxRjzRjwLq2vb!%')RjsRjpRjfRjex3jcqCw3!%')Rk'Rk*RjkRjl9<CbbzfOu4ARhxLq2vb!%')RjyRjvRjhRjgx=joq*uKvb!%')+-Rk.Rk%Rj~Rk-Rk#Rj}x=jdq*uKvb!%')+-Rk,Rk!Rj|RjmRjjRjidAq&qKs@uAv8Aa.'*-a@a&0!aM@a5[y73Dsy3Ds|3Dt):wxgI2sHJwJZt.~Gqxwsf0ikrzt}Rl0Jvy_[xj~HqzKv_A|D!&WfP8axRoVcf,U#k(v]v+ueunaXRf1Ju}'!g8u#Ri=jQw!sCunLprq>!,')~<5qeGzq9F{W=c##%s5au:5aU3CBE|;d4#X(D!a&6Vygx(b;#(=]ed?C2F{N<capoq2r[a&!aPa9,'Pw;5s:@@=I|,55w_h|@@=IzcP~=x'fCqB_2Wl2>aU@@=I|1OuNBc1Z+jTqIsBv=Wlc~Cw`fl2WlZ~AcTa%!Z+jTqIsBv=Wlb~Cw`fh2WlYk+uNqJsBv=WlSg,u3dca3#UXaMYa)TaB-=cM|7T#<bI}l5@B932:aV2G{BOuNBJq:|M!5Ezt=<B=C@a^<B57@2F{v>cB{/T#=ay<bI{3Jv6!a.6BKq0ah&+!5E}HP~Ef{978BaU@@=Iza<7d#.Y#978BaU@@=IzH~AJq0!(@@=IzG978BaU@@=IzFe,aU*Y&^^^bvJb,b:bFad!a,c2Ta>aL.bo6!a#CbTa'T#Re{2Wlh2@G{yg6t~Ro_NvdRfticuRQRllJv3&!x&c|zs@Jw3!%RflwpfkRlpKuL;%(!Re<@G|C2GzdhIvuBwgjAg-u0RjAKQB%!(GzZ@G|5NuuRl7d='T+Y#Vy[g<v~Rm!==G|>JvA!)@wma=]m1ifuaw&RmnLs@vT'!|/+[y,g:v>ReTJw1!#qX=x!eC{bLu+wT&)ZtZauq_~Graci&U#F|89:r_Lupvq!.)&2RlG8RfaC=x!eF{_h?rpWlmd&'!#X|&]k::xJey#`'T|+<E|&2@H|%dE#(^,g;u.RiEg6vjRiC9xCkA{O|zY#g=ucRmXKs0@!&*@G|m@awRknJuh!,3d(}gY}eJvj!%Rm):Jw3!%Rm+Rm-Ls0w(&!a(a#@b[|6cZ#X'7RkxWgAOu4ARn'dH'U#Y*Vz-Wm'CARm}d]*#a%^a*T'aK!a<9bV{PC=p*Jw4!&SgxcbB5r]idw(wBRmF7xFkt#&`(Rm/Rm8E|!JuY_9:Rl5=wrgr2:bbxd@xXfB(a*#T+!.X0X1Ta/a'T&RlDRfL>RlyARl9b[z[>RfZ:RlL:RfRwlg/ARl;9;RlxKv,A/!%7s69<74=BA5ba{-8Bde#`a<XaKYa1,a'P~=wxfB2bZ}}?C972@@=I}r8@55B9;5bb}G978B2@@=aybb}3j3vLv;<Jw3&!>Rfk=ayb^}4~Ad1#`*@@=aybb{w2@>==<bbz]dx+UY#^UaF!a9!bB'Ya1.!ajXa#%olRhD[y=3Dt#Ov5BrHKuMB%!(Rf^Wep~HrJwkiQjKr|~FRg)Ku+D#'!t5~GrF~?rDdV)UY,Z/_7RkuG{<~BrBg,rlsO:235B@bX}|d?a1!#`(6Vyn5@d##Y+jTv|vV~EfIj]uNpn~FRfH7Lq2vb1!a9-978BaU@@=Iz9978BbU}#~AJq0!(@@=Iz8978BaU@@=Iz7~AJQ|}!978BbU}!JvkaK!AdUa21-U#`a+(g/vsRn~Ou!5RPj:rmu9WhOjXuvvNr}:RhAj^v(pyw8unRn[kPr}p|u7vwv]RiSBd;pppzq@qHQa?(b.!a.a`@.|xa(hFv;Wiyj5uuv-7Riw~Cw`fg2WlU978BbU|wOuNBJqG!(P~EfD~CRlQcZ#X,k)u3vWs@u2]ksg;wEx'f@q1_2Wg.j]uNpn~FRfqJv]!15x'h{qG!(@@=IzK~CRl^j6v(us5x4i,#T(2WmY?C2F{1>Kq<aj1!*jTqIsBv=Wld~Cw`fj2Wl[j`v0u*~>RlT=c>Z,k#u3vWs@u2]kq<c1Z+jTqIsBv=Wle~Cw`fn2Wl]dn1#c(a(b^a2!b/bAT(bj!aDa7bu,a_a{c0!2T0g:v>ReD2@G{42@G{5~DpM~<5rc=Bx6i>{RT#RnI@zCx]y]z:2Jv[!zr5Awyk]9]k]dD(Y+X#6Vz.g=wKtgwhaCwgmTWj2Lu,w%_+/[y-B;b^xeg3u3Rj-2@bX{*KrJ<!+'@Wg(g?QRlC@Jv`!%b[zIwsfII}8JQ_@w|kW|=Jv(%!AqcOuNBJvEzh!bYzjLs@wP#(0!oy@>RkdJwMZtc3Dtd@BcG#T'9bWxg2@2Fznd*#Y+;2x'c}w<zizixNgwa#Z'U+!/!a'!a+w~g~z6wcn{Rn}wcnzRn|5Rh%=]nJg5vuRmvNvdRlvcprJu}w*az*a#!%.a.'Bot9qT]kj@Wg'ay2Gzv@Jv`!%b[zEwsfHI}1;ck#Ux`<Cbbx_Lu+w!a&0*!wko*wwo,So,}6Juqxf!E}PigQuyRm`d3(`#8>Rn%:A5B;bZ~%KvhCa!a2!x>k7#Uxb@b{#xaRk7Jw0!)>wwhlShl}6>wwhmShm}6CJvB!.x'hhvj{!!5Bwkhhbaz}x'hivjz~!5Bwkhibaz|xEhTrNu,v-vpD!a%&/)a3a.,%Ro2t[CE{)@3re9b]{%wjo09:rgc:Z&Ro6=<riifuaw&RmoKrNA!%(Ro4>Ro89;Ri`dSaL'UYzxZb)7Rka3xRhT&!,!#^1U}vbaz{>>@=be}yC@:D5bazzKu+A&!}{?ba}y>>@=be}wxBh[t`u~vJvr!%a!a()a,a0a4RoC=]o;Ju(!%RoGRhdwjh`=]oAg>w#Ro?g5vuRo=NvdRl|Ku]C.!&;RoEJvB!%RoORoMBx'h[v+_?w~h`}~5?w~hd~!xKh]oiptu-utv.vp!#%&a30a@a'a+(a/aOp(o~p!RoDJu(!%RoHRhewjha=]oBNvdRl}g>w#Ro@g5vuRo>c[#X']o<CauRoRAd-#Y':RkpauRoQKu]C.!&;RoFJvB!%RoNRoPBx'h]v+_?w~ha}t5?w~he}ue!/UbhYacXaW^Tc&a;b:a-c/#b&aja1(!cL+!bKbt!bmcRc9aIc?8[yW3Dtt94Rg`Jv}!&SiRMzBhEebShEMNuPRe>x7gL#TzuwjirRipc<Z&>on;>z=h-MSh.Mwqczx'a7vj&!>Re4@=ResJt__NuPRi*NuPRi)j]uNr|~FRfzKrJ>_+@Wfy@Wf]2WocKrJ<!+'@Wg%g/QRl@@Jv`!&awRl<wsfFIzgLu(w*!.*&ShBMwvhIRhI9;RhNx1hK'!#Sn]Mx1hK~0!#:2<H~7cNu+w7D*'1ZtW>Rn1~?rOc:Z&Rn2=<rQ<7wjh&=BSnLMc]#X(6Vz)w[b=a!U#9wzgMc3#&(RgMRitRis<x,gKt`ax!&+SioM=BSilMc3#&(RgKRinRimKurB,!&SiQMzBhDebShDM6BJQ!(P~Efx978B2@@=I}WLrJw!!,a*&@G}O@9wkibRid@@x'fKwC!&SlDMSfLMjUv~Q~EfKKv3@a+!(hFv-]mpx/hYZ(C5RiWz<o/MwkhY?So/M@x,gbvfB*&!SgEM:SoeeehFu3:Rgbda(,^TZa)X/7Sg[eb:2RgI~BrMC@wgkc:wwkcRerx3h(uUvK!&*,SnOM4Sh*MArRg;wHRh(x=h;rJvPwI!a4',a'0@Wg&=BSh/Mg>w=Rh=g3w*wwgGRgGcW(X#;Sg}M2Gzk@Jv`!&awRl=wsfGIz`dKZ*T'Y-:RhR7RhQg5u-p`j6v(us5d,#Y+~Awkia?RicOuNBwkibba}Ld6p~tyu_vbAa'a+!a/'a3aEa8a!>Sh,ebJv{!&Sh@ebSaReb9;SgwebNuPRi(NvdRl)NuPRi'hHu^<Rm^Jvv_@Wl(g;u1Si/ebKu'B&!*Sh?eb@Wl'z@aPeb95Si.ebcpputyvjB)!,&a+0a%ShAMWeK@G}C@WfJ9;RhMwvhH9w{ia}ix,hJvRA1(!zAn[MRhHx1hJ~*!#hFv(BSn[MBJQ!(@@=I~'978B2@@=I}2db.Ua<'X}+T#a0XaG2G}E;wkg|wuh!Rh!x,hZu,@)!&So0MVy)C5RiXACJvB!&5RiY5RiZg8w)cG}*T#2@bU}=KsA>(!a.3wkhZba~(x,h^u(A!&(SoCMRhb5Bz=h[eb?w~hb~6x,h_u(A!&(SoDMRhc5Bz=h]eb?w~hc~6e)aA1T#T,^^^c-bMb&blcPaP(a/!0!bA=b5c@a(!bfbrc#2afwmhARnjwchORnp2Wlf3DtsNvdRl-2@wpa<]m0bx(#:awRk2@Jw3!%RfhwpfgRlnKQB%!(G{V@G|'NuuRl6d='T+Y#VyUg<v~Rl~==G|<Jv+'!aYShC}6@B<5?ba~8@Jw3'!g2QRljhLrpWlOd+#Y'g.w'rIg>w*wgj@g-u0Rj@Lu+wT&)ZtUauq]~GrGci&U#F|39:rELrNvj!.%*RhCwunfw~nf~:9;Ri]>wtnhg;wHRnhx3hDs@v~!/+'@Wfr@9RkSNu&Rlo=@<5GzoKs0@_+@Wl+@awRkmJuh!-3d(}pY#qWJvj!%Rm(:Jw3!%Rm,Rm*de&!1U-U#`)Re;@G|.@9Ri82@wjfvRlq=@<5GzpLvOvr!).&2RlF8Rf`C=x!eE{.Jw3_g2QRlkhLrpWlPde(!#U{s,UXa*Ta'[y'g:v>ReS;x0PZ&RnlRnn~HrKJw1}f!=x!eB|2w]aP(#Xa&a*Ta.Ua2a7=]iOd'#Y&Ro&WnWg;u.RiDg6vjRiBNvdRlzhNvj]nYJuW_2Wm3x)kFze{9d])!a.!,Y01!#&aC!a3RndC=ox~BrC@2b^{pg,rlse7x'ksuq!%Rm.E{xidw(wBRmGx9o+)X#wwo-So-}69:Rl4@xSf@a#XZ'X)X,Ta(/ARl8b[xc>RfY:RlI:RfQwlg.ARl:9;Rlwdn'#^XafaQa1X1TaHTa)@b[{zcZ#X'7RkwWg@Ou4ARn&x)kG#{,g7u/RkGdH'U#Y*Vz'Wm&CARm|bx#(A]gUbUzJj9Q~=d,#Y(56H}l978H{U7d,0#U*2>ABb_xZ978BbU{e~AJQ{g!978BbU{hxMh?ad{oUYZ.x1h?{l!#:2<H{mx3n[t{vl!,&a%3Ro(z=iS}6ARnr=Bwsn^wvn`Rnbd`*T}B0!#^X'BG{c9b]{a>>@=be}F?JvS!&BG{d7BG}(Bde#`a1X,Ya@!a'P~=wxf@2bZ}I56B2@@=aybb}08@55B9;5bb}<j3vLv;<Jw3&!>Rfg=ayb^}&OuNBKuLA!)a!P~=x#fD{f2@>==<bbzl?C972@@=Ix^d6rSu,v7w*C(0a)a6#B+a%!sQ[y?3Dt%3[xn~<5rLOu!5p@Ku+D#'!t7~GrP~?rNKvlaya7'!h+v-5qMg=t|cd,U#5AAaa5Abb{S@52B5@a[@52B5Gx[iXueu;d<#`a(!/549C;ag>23ExY5@Dah89b^~689Jv)!~2b[~1Lv'w(%*!a#bX|aPrmawRe]keu7uhv-q6rxu,q`xTo]/a5aU!bNaDXbi!b-!ao!b<bwA!#5@B932:aV2G|:d-)Y#hJrL>RhG<7@C5<H|_=Cau:5aj5@B932:bJ|ng>vIbs)#?C2F|9jPv0w.vISh-MKvUaz(.!9ABbb|[5;5<H|Eg>unwfh;9:4E|YjQsBt|vjx'hYq3!(?C2F|J:2<BaY?C2F|GOu!5x,g|p{ah!-(?C2F|c9:4E|OjXuvvNr}:Rh&i[w*t|cd+U#jJvsu)vsSn~Mkfrmu9p}u7vwv]So!McW#Xa!ax5@A5aY:5;5<H|>kJv~vYrquJu3x4ib#T)2@SmZM?C2F|Bj:rmu9@xPhI(a*a#U#`a3-5Abb|L~@:RhK9:4E|0@52B5G|#C::aY?C2F|-:2<BaY?C2F|.5Jvk!a)javYrquJu3x4ia#T)2@SmYM?C2F|HAxPhH(!a#U#`a*-5Abb|4~@:RhJ9:4E|R@52B5G|F:2<BaY?C2F|Sc^#Xa2j=Qq5CJvB!-g<v{z;hhM?C2F|Zi[vrv{z;hiM?C2F|XKsA>!a)-g<v{z;h[eb?C2F|]i[vrv{z;h]eb?C2F|^iZu.vix,hZq3ah!.(?C2F|QOu!5ShXM:2<BaY?C2F|P\", 13_494, 2713, 49, 25, 61);\n//# sourceMappingURL=decode-data-html.js.map","/**\n * Bit flags & masks for the binary trie encoding used for entity decoding.\n *\n * The trie is a flat `Uint16Array`. Every node starts with one header word:\n *\n *   15..14 VALUE_LENGTH   Number of words the value occupies, +1.\n *                         0 = no value; 1 = value inline in bits 12..0;\n *                         2/3 = value in the 1/2 words after the header.\n *   13     FLAG13         If VALUE_LENGTH > 0: semicolon required (\"strict\"\n *                         entity; `;` is never stored as a branch).\n *                         If VALUE_LENGTH == 0: this node is a compact run.\n *   12..7  BRANCH_LENGTH  Number of branches (or run length for runs).\n *   6..0   JUMP_TABLE     Jump-table offset / single-branch char / first\n *                         run char (see below).\n *\n * Branch data follows the header and any value words. Its shape is selected\n * by (JUMP_TABLE, BRANCH_LENGTH) in the header:\n *\n *   Single branch  JUMP_TABLE = the only child's char, BRANCH_LENGTH = 0.\n *                  No branch words; the child node follows immediately.\n *   Jump table     JUMP_TABLE = first covered char (> 0), BRANCH_LENGTH =\n *                  table length. One word per covered char: 0 = no branch,\n *                  otherwise the child's offset from the END of the table,\n *                  +1 (so 0 stays the no-branch sentinel).\n *   Dictionary     JUMP_TABLE = 0, BRANCH_LENGTH = number of branches.\n *                  ceil(n/2) words of sorted keys packed two per word\n *                  (low byte first), then n pointer words storing the\n *                  child's offset from the END of the branch data.\n *   Compact run    VALUE_LENGTH = 0, FLAG13 set. BRANCH_LENGTH = run\n *                  length (3..63), JUMP_TABLE = first char; remaining run\n *                  chars packed two per word after the header. The target\n *                  node follows the packed words immediately.\n *\n * Pointers are end-relative (rather than relative to the pointer's own\n * position) because that makes the common \"child encoded right after the\n * branch data\" case a small constant, which compresses far better. Offsets\n * to already-encoded (shared) nodes wrap via uint16 modulo arithmetic; the\n * decoder masks navigation results with `& 0xff_ff` to match.\n */\nexport var BinTrieFlags;\n(function (BinTrieFlags) {\n    BinTrieFlags[BinTrieFlags[\"VALUE_LENGTH\"] = 49152] = \"VALUE_LENGTH\";\n    BinTrieFlags[BinTrieFlags[\"FLAG13\"] = 8192] = \"FLAG13\";\n    BinTrieFlags[BinTrieFlags[\"BRANCH_LENGTH\"] = 8064] = \"BRANCH_LENGTH\";\n    BinTrieFlags[BinTrieFlags[\"JUMP_TABLE\"] = 127] = \"JUMP_TABLE\";\n    /** Bits 12..0: the inline value of a VALUE_LENGTH = 1 header word. */\n    BinTrieFlags[BinTrieFlags[\"VALUE_MASK\"] = 8191] = \"VALUE_MASK\";\n})(BinTrieFlags || (BinTrieFlags = {}));\n//# sourceMappingURL=bin-trie-flags.js.map","import { codePointToString, replaceCodePoint, replaceCodePointXML, } from \"./decode-codepoint.js\";\nimport { htmlDecodeTree } from \"./generated/decode-data-html.js\";\nimport { xmlDecodeTree } from \"./generated/decode-data-xml.js\";\nimport { BinTrieFlags } from \"./internal/bin-trie-flags.js\";\nvar CharCodes;\n(function (CharCodes) {\n    CharCodes[CharCodes[\"AMP\"] = 38] = \"AMP\";\n    CharCodes[CharCodes[\"NUM\"] = 35] = \"NUM\";\n    CharCodes[CharCodes[\"SEMI\"] = 59] = \"SEMI\";\n    CharCodes[CharCodes[\"EQUALS\"] = 61] = \"EQUALS\";\n    CharCodes[CharCodes[\"ZERO\"] = 48] = \"ZERO\";\n    CharCodes[CharCodes[\"NINE\"] = 57] = \"NINE\";\n    CharCodes[CharCodes[\"LOWER_A\"] = 97] = \"LOWER_A\";\n    CharCodes[CharCodes[\"LOWER_X\"] = 120] = \"LOWER_X\";\n})(CharCodes || (CharCodes = {}));\n/** Bit that needs to be set to convert an upper case ASCII character to lower case */\nconst TO_LOWER_BIT = 0b10_0000;\n/*\n * `parseNumericEntity` packs its two results into one 32-bit integer:\n * `(consumed << CONSUMED_SHIFT) | codePoint`. The 21-bit code point field\n * fits any valid Unicode value (max 0x10FFFF, clamped before packing); the\n * consumed count excludes `&` and gets the remaining 11 bits. Extract it\n * with `>>>` so the topmost bit isn't treated as a sign.\n *\n * Plain consts rather than a `const enum`: with `isolatedModules`, enum\n * member reads compile to runtime property loads.\n */\nconst CONSUMED_SHIFT = 21;\nconst CODE_POINT_MASK = 0x1f_ff_ff;\n/**\n * Reserved consumed field for counts of at least 2047 characters after `&`.\n * The true count is in `longNumericConsumed`.\n */\nconst CONSUMED_OVERFLOW = 0x7_ff;\n/**\n * Side channel for numeric entities of at least 2048 characters including\n * `&`. Set by `parseNumericEntity` when its consumed count reaches the\n * reserved value `CONSUMED_OVERFLOW`; callers read the true count from here.\n * A module-level slot avoids a tuple allocation on the hot path.\n */\nlet longNumericConsumed = 0;\n/**\n * Extract the consumed count from a `parseNumericEntity` packed result,\n * recovering the true length from `longNumericConsumed` when the packed\n * field contains the sentinel. Read it before the next `parseNumericEntity`\n * call, which may overwrite the side channel. This helper owns that protocol.\n * @param packed Packed result of `parseNumericEntity`.\n */\nfunction unpackConsumed(packed) {\n    const consumed = packed >>> CONSUMED_SHIFT;\n    return consumed === CONSUMED_OVERFLOW ? longNumericConsumed : consumed;\n}\n/**\n * Unsigned subtraction trick: (code - lo) >>> 0 wraps negatives to large\n * values, so a single `<=` covers the entire [lo..hi] range check.\n * @param code Code point to check.\n */\nfunction isNumber(code) {\n    return (code - CharCodes.ZERO) >>> 0 <= 9;\n}\nfunction isHexadecimalCharacter(code) {\n    return ((code | TO_LOWER_BIT) - CharCodes.LOWER_A) >>> 0 <= 5; // F - a\n}\nfunction isAlpha(code) {\n    return ((code | TO_LOWER_BIT) - CharCodes.LOWER_A) >>> 0 <= 25; // Z - a\n}\n/**\n * Checks if the given character is a valid end character for an entity in an attribute.\n *\n * Attribute values that aren't terminated properly aren't parsed, and shouldn't lead to a parser error.\n * See the example in https://html.spec.whatwg.org/multipage/parsing.html#named-character-reference-state\n * @param code Code point to check.\n */\nfunction isEntityInAttributeInvalidEnd(code) {\n    return code === CharCodes.EQUALS || isAlpha(code) || isNumber(code);\n}\nvar EntityDecoderState;\n(function (EntityDecoderState) {\n    EntityDecoderState[EntityDecoderState[\"EntityStart\"] = 0] = \"EntityStart\";\n    EntityDecoderState[EntityDecoderState[\"NumericStart\"] = 1] = \"NumericStart\";\n    EntityDecoderState[EntityDecoderState[\"NumericDecimal\"] = 2] = \"NumericDecimal\";\n    EntityDecoderState[EntityDecoderState[\"NumericHex\"] = 3] = \"NumericHex\";\n    EntityDecoderState[EntityDecoderState[\"NamedEntity\"] = 4] = \"NamedEntity\";\n})(EntityDecoderState || (EntityDecoderState = {}));\n/**\n * Decoding mode for named entities.\n */\nexport var DecodingMode;\n(function (DecodingMode) {\n    /** Entities in text nodes that can end with any character. */\n    DecodingMode[DecodingMode[\"Legacy\"] = 0] = \"Legacy\";\n    /** Only allow entities terminated with a semicolon. */\n    DecodingMode[DecodingMode[\"Strict\"] = 1] = \"Strict\";\n    /** Entities in attributes have limitations on ending characters. */\n    DecodingMode[DecodingMode[\"Attribute\"] = 2] = \"Attribute\";\n})(DecodingMode || (DecodingMode = {}));\n/**\n * Token decoder with support of writing partial entities.\n */\nexport class EntityDecoder {\n    decodeTree;\n    emitCodePoint;\n    errors;\n    /** The current state of the decoder. */\n    state = EntityDecoderState.EntityStart;\n    /** Characters that were consumed while parsing an entity. */\n    consumed = 1;\n    /**\n     * The result of the entity.\n     *\n     * For named entities: the trie index of the best legacy match so far\n     * (0 = none). For numeric entities: the accumulated code point.\n     */\n    result = 0;\n    /** The current index in the decode tree. */\n    treeIndex = 0;\n    /**\n     * Characters consumed since the last recorded legacy match, plus one.\n     * Invariant at the top of the `stateNamedEntity` loop: `excess` equals\n     * the number of unrecorded consumed characters + 1.\n     */\n    // biome-ignore lint/correctness/noUnusedPrivateClassMembers: False positive (read via destructuring)\n    excess = 1;\n    /** The mode in which the decoder is operating. */\n    decodeMode = DecodingMode.Strict;\n    /** The number of characters that have been consumed in the current run. */\n    // biome-ignore lint/correctness/noUnusedPrivateClassMembers: False positive\n    runConsumed = 0;\n    constructor(\n    /** The predefined HTML or XML decode tree. */\n    decodeTree, \n    /**\n     * The function that is called when a codepoint is decoded.\n     *\n     * For named entities that decode to multiple code points, this will\n     * be called multiple times, with the second codepoint, and the same\n     * `consumed` value.\n     * @param codepoint The decoded codepoint.\n     * @param consumed The number of characters consumed by the decoder.\n     */\n    emitCodePoint, \n    /** An object that is used to produce errors. */\n    errors) {\n        this.decodeTree = decodeTree;\n        this.emitCodePoint = emitCodePoint;\n        this.errors = errors;\n    }\n    /**\n     * Resets the instance to make it reusable.\n     * @param decodeMode Entity decoding mode to use.\n     */\n    startEntity(decodeMode) {\n        this.decodeMode = decodeMode;\n        this.state = EntityDecoderState.EntityStart;\n        this.result = 0;\n        this.treeIndex = 0;\n        this.excess = 1;\n        this.consumed = 1;\n        this.runConsumed = 0;\n    }\n    /**\n     * Write an entity to the decoder. This can be called multiple times with partial entities.\n     * If the entity is incomplete, the decoder will return -1.\n     *\n     * Mirrors the non-streaming `decodeWithTrie`, but with the ability to stop decoding if the\n     * entity is incomplete, and resume when the next string is written.\n     * @param input The string containing the entity (or a continuation of the entity).\n     * @param offset The offset at which the entity begins. Should be 0 if this is not the first call.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    write(input, offset) {\n        switch (this.state) {\n            case EntityDecoderState.EntityStart: {\n                if (input.charCodeAt(offset) === CharCodes.NUM) {\n                    this.state = EntityDecoderState.NumericStart;\n                    this.consumed += 1;\n                    return this.stateNumericStart(input, offset + 1);\n                }\n                this.state = EntityDecoderState.NamedEntity;\n                return this.stateNamedEntity(input, offset);\n            }\n            case EntityDecoderState.NumericStart: {\n                return this.stateNumericStart(input, offset);\n            }\n            case EntityDecoderState.NumericDecimal: {\n                return this.stateNumericDecimal(input, offset);\n            }\n            case EntityDecoderState.NumericHex: {\n                return this.stateNumericHex(input, offset);\n            }\n            default: {\n                // NamedEntity — the only remaining state.\n                return this.stateNamedEntity(input, offset);\n            }\n        }\n    }\n    /**\n     * Switches between the numeric decimal and hexadecimal states.\n     *\n     * Equivalent to the `Numeric character reference state` in the HTML spec.\n     * @param input The string containing the entity (or a continuation of the entity).\n     * @param offset The current offset.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    // eslint-disable-next-line unicorn/consistent-class-member-order\n    stateNumericStart(input, offset) {\n        if (offset >= input.length) {\n            return -1;\n        }\n        if ((input.charCodeAt(offset) | TO_LOWER_BIT) === CharCodes.LOWER_X) {\n            this.state = EntityDecoderState.NumericHex;\n            this.consumed += 1;\n            return this.stateNumericHex(input, offset + 1);\n        }\n        this.state = EntityDecoderState.NumericDecimal;\n        return this.stateNumericDecimal(input, offset);\n    }\n    /**\n     * Parses a hexadecimal numeric entity.\n     *\n     * Equivalent to the `Hexademical character reference state` in the HTML\n     * spec. Digit parsing matches the hex loop in `parseNumericEntity`.\n     * The accumulated value is preserved for numeric validation callbacks.\n     * @param input The string containing the entity (or a continuation of the entity).\n     * @param offset The current offset.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    stateNumericHex(input, offset) {\n        const inputLength = input.length;\n        // Local accumulators; flushed before any exit (see stateNamedEntity).\n        let { result } = this;\n        let { consumed } = this;\n        while (offset < inputLength) {\n            const char = input.charCodeAt(offset);\n            if (isNumber(char) || isHexadecimalCharacter(char)) {\n                // Convert hex digit to value (0-15); 'a'/'A' -> 10.\n                const digit = char <= CharCodes.NINE\n                    ? char - CharCodes.ZERO\n                    : (char | TO_LOWER_BIT) - CharCodes.LOWER_A + 10;\n                result = result * 16 + digit;\n                consumed += 1;\n                offset += 1;\n            }\n            else {\n                this.result = result;\n                this.consumed = consumed;\n                return this.emitNumericEntity(char, 3);\n            }\n        }\n        this.result = result;\n        this.consumed = consumed;\n        return -1; // Incomplete entity\n    }\n    /**\n     * Parses a decimal numeric entity.\n     *\n     * Equivalent to the `Decimal character reference state` in the HTML\n     * spec. Digit parsing matches the decimal loop in `parseNumericEntity`.\n     * The accumulated value is preserved for numeric validation callbacks.\n     * @param input The string containing the entity (or a continuation of the entity).\n     * @param offset The current offset.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    stateNumericDecimal(input, offset) {\n        const inputLength = input.length;\n        // Local accumulators; flushed before any exit (see stateNamedEntity).\n        let { result } = this;\n        let { consumed } = this;\n        while (offset < inputLength) {\n            const digit = input.charCodeAt(offset) - CharCodes.ZERO;\n            if (digit >>> 0 > 9) {\n                this.result = result;\n                this.consumed = consumed;\n                return this.emitNumericEntity(digit + CharCodes.ZERO, 2);\n            }\n            result = result * 10 + digit;\n            consumed += 1;\n            offset += 1;\n        }\n        this.result = result;\n        this.consumed = consumed;\n        return -1; // Incomplete entity\n    }\n    /**\n     * Validate and emit a numeric entity.\n     *\n     * Implements the logic from the `Hexademical character reference start\n     * state` and `Numeric character reference end state` in the HTML spec.\n     * @param lastCp The last code point of the entity. Used to see if the\n     *               entity was terminated with a semicolon.\n     * @param expectedLength The minimum number of characters that should be\n     *                       consumed. Used to validate that at least one digit\n     *                       was consumed.\n     * @returns The number of characters that were consumed.\n     */\n    emitNumericEntity(lastCp, expectedLength) {\n        // Ensure we consumed at least one digit.\n        if (this.consumed <= expectedLength) {\n            this.errors?.absenceOfDigitsInNumericCharacterReference(this.consumed);\n            return 0;\n        }\n        // Figure out if this is a legit end of the entity\n        if (lastCp === CharCodes.SEMI) {\n            this.consumed += 1;\n        }\n        else if (this.decodeMode === DecodingMode.Strict) {\n            return 0;\n        }\n        this.emitCodePoint((this.decodeTree === xmlDecodeTree\n            ? replaceCodePointXML\n            : replaceCodePoint)(this.result), this.consumed);\n        if (this.errors) {\n            if (lastCp !== CharCodes.SEMI) {\n                this.errors.missingSemicolonAfterCharacterReference();\n            }\n            this.errors.validateNumericCharacterReference(this.result);\n        }\n        return this.consumed;\n    }\n    /**\n     * Flush locally-tracked walk state back to the fields, then emit the\n     * recorded legacy match or reject (cold path — at most once per\n     * entity). Called after failed navigation (leaf node, branch miss, or\n     * compact-run mismatch). In attribute mode, reject if no legacy was\n     * recorded at the current node, if we descended past it, or if the\n     * pending input character is an invalid attribute terminator.\n     * @param consumed Locally-tracked consumed count.\n     * @param excess Locally-tracked excess count.\n     * @param char Pending input character (may be the mismatching char).\n     * @param valueLength Value length at the current trie node.\n     */\n    flushAndEmitLegacyOrReject(consumed, excess, char, valueLength) {\n        this.consumed = consumed;\n        this.excess = excess;\n        return this.result === 0 ||\n            (this.decodeMode === DecodingMode.Attribute &&\n                (valueLength === 0 ||\n                    excess > 1 ||\n                    isEntityInAttributeInvalidEnd(char)))\n            ? 0\n            : this.emitNotTerminatedNamedEntity();\n    }\n    /**\n     * Parses a named entity.\n     *\n     * Equivalent to the `Named character reference state` in the HTML spec.\n     * @param input The string containing the entity (or a continuation of the entity).\n     * @param offset The current offset.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    stateNamedEntity(input, offset) {\n        const { decodeTree } = this;\n        const inputLength = input.length;\n        const isStrict = this.decodeMode === DecodingMode.Strict;\n        /*\n         * Local copies of the resumable walk state avoid per-character\n         * field writes. They are flushed back to the fields\n         * on every exit (chunk end, and before any emit helper that reads\n         * them). `this.result` is only written at the (rare) record points,\n         * so it stays a direct field write.\n         *\n         * Legacy-match recording happens in two idempotent places: at the\n         * loop top when sitting on a value node, and in the chunk-end\n         * epilogue (so `end()` sees matches that land exactly on a chunk\n         * boundary). Recording applies `consumed += excess - 1; excess = 1`,\n         * which is a no-op when repeated — the loop-top invariant is\n         * `excess` = unrecorded consumed characters + 1.\n         */\n        let { treeIndex } = this;\n        let { excess } = this;\n        let { consumed } = this;\n        let current = decodeTree[treeIndex];\n        while (offset < inputLength) {\n            /*\n             * Descend through value-less jump-table nodes (including the\n             * single-branch encoding) inline, mirroring `decodeWithTrie`:\n             * this avoids a `determineBranch` call per level for the\n             * dominant node shape — including the root on the first write.\n             */\n            while ((current &\n                (BinTrieFlags.VALUE_LENGTH | BinTrieFlags.FLAG13)) ===\n                0 &&\n                (current & BinTrieFlags.JUMP_TABLE) !== 0) {\n                const char = input.charCodeAt(offset);\n                const jumpOffset = current & BinTrieFlags.JUMP_TABLE;\n                const branchCount = (current & BinTrieFlags.BRANCH_LENGTH) >> 7;\n                if (branchCount === 0) {\n                    // Single branch encoded inline in the jump offset bits.\n                    if (char !== jumpOffset) {\n                        return this.flushAndEmitLegacyOrReject(consumed, excess, char, 0);\n                    }\n                    treeIndex += 1;\n                }\n                else {\n                    const slot = char - jumpOffset;\n                    if (slot >>> 0 >= branchCount) {\n                        return this.flushAndEmitLegacyOrReject(consumed, excess, char, 0);\n                    }\n                    const stored = decodeTree[treeIndex + 1 + slot];\n                    if (stored === 0) {\n                        return this.flushAndEmitLegacyOrReject(consumed, excess, char, 0);\n                    }\n                    // End-relative: branch data ends at treeIndex+1+branchCount.\n                    treeIndex = (treeIndex + branchCount + stored) & 0xff_ff;\n                }\n                current = decodeTree[treeIndex];\n                offset += 1;\n                excess += 1;\n                /*\n                 * `charCodeAt` past the end returns NaN, which would alias\n                 * to slot 0 after `>>> 0` — bail out explicitly.\n                 */\n                // eslint-disable-next-line unicorn/no-break-in-nested-loop\n                if (offset >= inputLength)\n                    break;\n            }\n            if (offset >= inputLength)\n                break;\n            // Handle compact runs (resumable across chunks).\n            if ((current &\n                (BinTrieFlags.VALUE_LENGTH | BinTrieFlags.FLAG13)) ===\n                BinTrieFlags.FLAG13) {\n                const runLength = (current & BinTrieFlags.BRANCH_LENGTH) >> 7; /* 3..63 */\n                let { runConsumed } = this;\n                // If we are starting a run, check the first char.\n                if (runConsumed === 0) {\n                    const char = input.charCodeAt(offset);\n                    if (char !== (current & BinTrieFlags.JUMP_TABLE)) {\n                        return this.flushAndEmitLegacyOrReject(consumed, excess, char, 0);\n                    }\n                    offset += 1;\n                    excess += 1;\n                    runConsumed = 1;\n                }\n                // Check remaining characters in the run (packed two per uint16 word).\n                while (runConsumed < runLength) {\n                    if (offset >= inputLength) {\n                        this.treeIndex = treeIndex;\n                        this.excess = excess;\n                        this.consumed = consumed;\n                        this.runConsumed = runConsumed;\n                        return -1;\n                    }\n                    const charIndexInPacked = runConsumed - 1;\n                    const packedWord = decodeTree[treeIndex + 1 + (charIndexInPacked >> 1)];\n                    const expectedChar = (packedWord >> ((charIndexInPacked & 1) << 3)) & 0xff;\n                    const char = input.charCodeAt(offset);\n                    if (char !== expectedChar) {\n                        this.runConsumed = 0;\n                        return this.flushAndEmitLegacyOrReject(consumed, excess, char, 0);\n                    }\n                    offset += 1;\n                    excess += 1;\n                    runConsumed += 1;\n                }\n                this.runConsumed = 0;\n                treeIndex += 1 + (runLength >> 1);\n                current = decodeTree[treeIndex];\n                // Loop top handles the landed-on node (record/emit/branch).\n                continue;\n            }\n            // Header plus out-of-line value words; 0 means no value.\n            const valueLength = current >>> 14;\n            const char = input.charCodeAt(offset);\n            if (valueLength !== 0) {\n                // Record a legacy match (FLAG13 clear = semicolon optional).\n                if (!isStrict && (current & BinTrieFlags.FLAG13) === 0) {\n                    this.result = treeIndex;\n                    consumed += excess - 1;\n                    excess = 1;\n                }\n                /*\n                 * Implicit semicolon handling: emit immediately. Covers both\n                 * strict (FLAG13 set) and legacy entities — neither stores\n                 * an explicit `;` branch in the trie.\n                 */\n                if (char === CharCodes.SEMI) {\n                    return this.emitNamedEntityData(treeIndex, valueLength, consumed + excess);\n                }\n                /*\n                 * `valueLength === 1` packs the codepoint into the header\n                 * word's low 13 bits, where branch metadata also lives. Skip\n                 * the branch lookup on leaves so those value bits aren't\n                 * reinterpreted as branch offsets.\n                 */\n                if (valueLength === 1) {\n                    return this.flushAndEmitLegacyOrReject(consumed, excess, char, valueLength);\n                }\n            }\n            // Value-bearing or dictionary node: dispatch through determineBranch.\n            const next = determineBranch(decodeTree, current, treeIndex + (valueLength || 1), char);\n            if (next < 0) {\n                return this.flushAndEmitLegacyOrReject(consumed, excess, char, valueLength);\n            }\n            treeIndex = next;\n            current = decodeTree[treeIndex];\n            offset += 1;\n            excess += 1;\n        }\n        /*\n         * Chunk exhausted. Record a legacy match we may be sitting on, so a\n         * subsequent `end()` emits it, then persist the walk state.\n         */\n        if (!isStrict &&\n            current >>> 14 !== 0 &&\n            (current & BinTrieFlags.FLAG13) === 0) {\n            this.result = treeIndex;\n            consumed += excess - 1;\n            excess = 1;\n        }\n        this.treeIndex = treeIndex;\n        this.excess = excess;\n        this.consumed = consumed;\n        return -1;\n    }\n    /**\n     * Emit a named entity that was not terminated with a semicolon.\n     * @returns The number of characters consumed.\n     */\n    emitNotTerminatedNamedEntity() {\n        const { result, decodeTree } = this;\n        const valueLength = decodeTree[result] >>> 14;\n        this.emitNamedEntityData(result, valueLength, this.consumed);\n        this.errors?.missingSemicolonAfterCharacterReference();\n        return this.consumed;\n    }\n    /**\n     * Emit a named entity.\n     * @param result The index of the entity in the decode tree.\n     * @param valueLength Encoded value length (header plus any value words).\n     * @param consumed The number of characters consumed.\n     * @returns The number of characters consumed.\n     */\n    emitNamedEntityData(result, valueLength, consumed) {\n        const { decodeTree } = this;\n        this.emitCodePoint(valueLength === 1\n            ? decodeTree[result] & BinTrieFlags.VALUE_MASK\n            : decodeTree[result + 1], consumed);\n        if (valueLength === 3) {\n            // Emit the second UTF-16 code unit.\n            this.emitCodePoint(decodeTree[result + 2], consumed);\n        }\n        return consumed;\n    }\n    /**\n     * Signal to the parser that the end of the input was reached.\n     *\n     * Remaining data will be emitted and relevant errors will be produced.\n     * @returns The number of characters consumed.\n     */\n    end() {\n        switch (this.state) {\n            case EntityDecoderState.NamedEntity: {\n                // Emit a named entity if we have one.\n                return this.result !== 0 &&\n                    (this.decodeMode !== DecodingMode.Attribute ||\n                        this.result === this.treeIndex)\n                    ? this.emitNotTerminatedNamedEntity()\n                    : 0;\n            }\n            // Otherwise, emit a numeric entity if we have one.\n            case EntityDecoderState.NumericDecimal: {\n                return this.emitNumericEntity(0, 2);\n            }\n            case EntityDecoderState.NumericHex: {\n                return this.emitNumericEntity(0, 3);\n            }\n            case EntityDecoderState.NumericStart: {\n                this.errors?.absenceOfDigitsInNumericCharacterReference(this.consumed);\n                return 0;\n            }\n            default: {\n                // EntityStart or unknown — return 0.\n                return 0;\n            }\n        }\n    }\n}\n/**\n * Determines the branch of the current node that is taken given the current\n * character. This function is used to traverse the trie.\n *\n * See `BinTrieFlags` for the branch-data layouts handled here.\n * @param decodeTree The trie.\n * @param current The current node's header word.\n * @param nodeIndex Index of the node's first branch-data word (the header\n *   plus any value words have been skipped by the caller).\n * @param char The current character.\n * @returns The index of the next node, or -1 if no branch is taken.\n */\nexport function determineBranch(decodeTree, current, nodeIndex, char) {\n    const branchCount = (current & BinTrieFlags.BRANCH_LENGTH) >> 7;\n    const jumpOffset = current & BinTrieFlags.JUMP_TABLE;\n    // Case 1: Single branch or jump table (jumpOffset encodes the first/only char code).\n    if (jumpOffset) {\n        if (branchCount === 0) {\n            // Single branch encoded inline in the jump offset bits.\n            return char === jumpOffset ? nodeIndex : -1;\n        }\n        /*\n         * Jump table: branchCount consecutive slots starting at jumpOffset.\n         * Unsigned comparison handles both < 0 and >= branchCount in one check.\n         */\n        const slot = char - jumpOffset;\n        if (slot >>> 0 >= branchCount)\n            return -1;\n        const stored = decodeTree[nodeIndex + slot];\n        /*\n         * 0 = empty slot (no branch); otherwise the child's offset from the\n         * end of the branch array, +1 (end-relative pointers compress\n         * better). `& 0xff_ff` mirrors the encoder's uint16 wrap for\n         * backreferences to already-encoded nodes.\n         */\n        return stored === 0\n            ? -1\n            : (nodeIndex + branchCount + stored - 1) & 0xff_ff;\n    }\n    /*\n     * Case 2: Packed dictionary. Linear scan — over 90% of dict nodes have\n     * <= 4 branches in the HTML trie, where the constant-factor savings\n     * dominate over binary search's asymptotic edge.\n     */\n    if (branchCount === 0)\n        return -1;\n    const packedKeySlots = (branchCount + 1) >> 1;\n    const branchEnd = nodeIndex + packedKeySlots + branchCount;\n    for (let index = 0; index < branchCount; index++) {\n        const packed = decodeTree[nodeIndex + (index >> 1)];\n        const key = (packed >> ((index & 1) << 3)) & 0xff;\n        if (key === char) {\n            const pointerIndex = nodeIndex + packedKeySlots + index;\n            // Pointers are relative to the end of the branch data.\n            return (branchEnd + decodeTree[pointerIndex]) & 0xff_ff;\n        }\n        // Keys are sorted; if we've passed `char`, no match is possible.\n        if (key > char)\n            return -1;\n    }\n    return -1;\n}\n/**\n * Read the decoded value from a trie node.\n * @param decodeTree The trie.\n * @param nodeIndex The index of the node.\n * @param valueLength The length of the value (1, 2, or 3).\n * @returns The decoded string.\n */\nfunction readTrieValue(decodeTree, nodeIndex, valueLength) {\n    if (valueLength === 1) {\n        return String.fromCharCode(decodeTree[nodeIndex] & BinTrieFlags.VALUE_MASK);\n    }\n    if (valueLength === 2) {\n        return String.fromCharCode(decodeTree[nodeIndex + 1]);\n    }\n    return String.fromCharCode(decodeTree[nodeIndex + 1], decodeTree[nodeIndex + 2]);\n}\n/**\n * Parse a numeric entity (`&#DDD;` or `&#xHHH;`).\n *\n * Encodes the result as `(consumed << CONSUMED_SHIFT) | codepoint` (see\n * the packing comment at the top of the file; overlong entities spill\n * their length into `longNumericConsumed`). Returns 0 when no digits were\n * found.\n *\n * This is the sync counterpart of the streaming\n * `EntityDecoder#stateNumericDecimal` / `#stateNumericHex`. Digit parsing\n * matches those methods; only this packed result needs a value clamp.\n * @param input       The input string.\n * @param numberStart Index of the `#` character.\n * @param inputLength Cached `input.length`.\n */\nfunction parseNumericEntity(input, numberStart, inputLength) {\n    let offset = numberStart + 1; // Skip \"#\"\n    let cp = 0;\n    let digitStart = offset;\n    /*\n     * Separate decimal and hexadecimal loops: each multiplies by a constant\n     * and runs a single digit test, instead of a per-character base check.\n     */\n    if (offset < inputLength &&\n        (input.charCodeAt(offset) | TO_LOWER_BIT) === CharCodes.LOWER_X) {\n        offset += 1;\n        digitStart = offset;\n        while (offset < inputLength) {\n            const char = input.charCodeAt(offset);\n            if (isNumber(char)) {\n                cp = cp * 16 + (char - CharCodes.ZERO);\n            }\n            else if (isHexadecimalCharacter(char)) {\n                cp = cp * 16 + ((char | TO_LOWER_BIT) - CharCodes.LOWER_A + 10);\n            }\n            else {\n                break;\n            }\n            offset += 1;\n        }\n    }\n    else {\n        while (offset < inputLength) {\n            const digit = input.charCodeAt(offset) - CharCodes.ZERO;\n            if (digit >>> 0 > 9)\n                break;\n            cp = cp * 10 + digit;\n            offset += 1;\n        }\n    }\n    if (offset === digitStart)\n        return 0;\n    // Include the semicolon in consumed when present.\n    if (offset < inputLength && input.charCodeAt(offset) === CharCodes.SEMI) {\n        offset += 1;\n    }\n    /*\n     * Clamp out-of-range values to 0x110000 so they fit the 21-bit field\n     * and decode to U+FFFD. Lengths at or above CONSUMED_OVERFLOW use the\n     * side channel described with the packing constants.\n     */\n    if (cp > 0x10_ff_ff)\n        cp = 0x11_00_00;\n    let consumed = offset - numberStart;\n    if (consumed >= CONSUMED_OVERFLOW) {\n        // eslint-disable-next-line unicorn/no-top-level-assignment-in-function -- deliberate side channel, see `longNumericConsumed`\n        longNumericConsumed = consumed;\n        consumed = CONSUMED_OVERFLOW;\n    }\n    return (consumed << CONSUMED_SHIFT) | cp;\n}\n/**\n * Decode all entities in `input` using the HTML trie.\n *\n * Hard-wired to `htmlDecodeTree`: the inline root navigation below assumes\n * the HTML root's jump-table shape, so this must not be generalized to\n * other tries (the XML trie's dictionary root would silently match no\n * entities — `decodeXML` has its own hand-coded fast path instead).\n * @param input      The string to decode.\n * @param isStrict Only match semicolon-terminated entities.\n * @param isAttribute Whether to apply attribute-specific parsing rules (disallowing certain non-semicolon terminators).\n * @returns The decoded string.\n */\nfunction decodeWithTrie(input, isStrict, isAttribute) {\n    const decodeTree = htmlDecodeTree;\n    // Fast path: no entities at all — return input without any allocation.\n    let offset = input.indexOf(\"&\");\n    if (offset < 0)\n        return input;\n    const inputLength = input.length;\n    /*\n     * `chunkStart` marks the start of the next pending slice. Rejected\n     * entities don't advance it, so consecutive rejections are stitched\n     * into a single `slice` once a real match (or end of input) is hit.\n     */\n    let chunkStart = 0;\n    let result = \"\";\n    /*\n     * Root navigation fields, hoisted out of the per-entity loop. The HTML\n     * root is a multi-branch jump-table covering [A-Za-z]; see the inline\n     * first-iteration comment below.\n     */\n    const root = decodeTree[0];\n    const rootJumpOffset = root & BinTrieFlags.JUMP_TABLE;\n    const rootBranchCount = (root & BinTrieFlags.BRANCH_LENGTH) >> 7;\n    do {\n        const entityStart = offset + 1;\n        // Quick check: entity names must start with [A-Za-z], numeric with #.\n        const firstChar = input.charCodeAt(entityStart);\n        let consumed;\n        let value;\n        if (firstChar === CharCodes.NUM) {\n            const packed = parseNumericEntity(input, entityStart, inputLength);\n            consumed = unpackConsumed(packed);\n            // In strict mode, require semicolon termination.\n            if (isStrict &&\n                consumed > 0 &&\n                input.charCodeAt(entityStart + consumed - 1) !== CharCodes.SEMI) {\n                consumed = 0;\n            }\n            value =\n                consumed === 0\n                    ? \"\"\n                    : codePointToString(packed & CODE_POINT_MASK);\n        }\n        else if (isAlpha(firstChar)) {\n            consumed = 0;\n            value = \"\";\n            /*\n             * The generator guarantees a jump-table root. Consume the first\n             * character directly, then walk from its child.\n             */\n            const rootSlotIndex = firstChar - rootJumpOffset;\n            let nodeIndex;\n            if (rootSlotIndex >>> 0 < rootBranchCount) {\n                const stored = decodeTree[1 + rootSlotIndex];\n                nodeIndex =\n                    stored === 0 ? -1 : (rootBranchCount + stored) & 0xff_ff;\n            }\n            else {\n                nodeIndex = -1;\n            }\n            /*\n             * Best legacy (no-semicolon) match so far, as trie coordinates.\n             * Deferring `readTrieValue` to the end avoids allocating a\n             * string for matches that longer matches supersede.\n             */\n            let bestNodeIndex = 0;\n            let bestValueLength = 0;\n            let current = nodeIndex < 0 ? 0 : decodeTree[nodeIndex];\n            let index = entityStart + 1;\n            /*\n             * Walk the trie from the root child. The `trie` label lets the\n             * inner descent and compact-run loops abandon the entity (and\n             * fall through to the legacy/reject handling) directly.\n             */\n            trie: while (index < inputLength) {\n                /*\n                 * Inline value-less jump tables and single branches. A miss\n                 * falls through to the recorded legacy match or rejection.\n                 */\n                while (\n                // Value-less, non-run node with a nonzero jump offset.\n                (current &\n                    (BinTrieFlags.VALUE_LENGTH | BinTrieFlags.FLAG13)) ===\n                    0 &&\n                    (current & BinTrieFlags.JUMP_TABLE) !== 0) {\n                    const jumpOffset = current & BinTrieFlags.JUMP_TABLE;\n                    const branchCount = (current & BinTrieFlags.BRANCH_LENGTH) >> 7;\n                    if (branchCount === 0) {\n                        // Single branch encoded inline in the jump offset bits.\n                        if (input.charCodeAt(index) !== jumpOffset)\n                            break trie;\n                        nodeIndex += 1;\n                    }\n                    else {\n                        const slot = input.charCodeAt(index) - jumpOffset;\n                        if (slot >>> 0 >= branchCount)\n                            break trie;\n                        const stored = decodeTree[nodeIndex + 1 + slot];\n                        if (stored === 0)\n                            break trie;\n                        // End-relative: branch data ends at nodeIndex+1+branchCount.\n                        nodeIndex =\n                            (nodeIndex + branchCount + stored) & 0xff_ff;\n                    }\n                    current = decodeTree[nodeIndex];\n                    index += 1;\n                    /*\n                     * `charCodeAt` past the end returns NaN, which would\n                     * alias to slot 0 after `>>> 0` — bail out explicitly.\n                     */\n                    if (index >= inputLength)\n                        break trie;\n                }\n                // FLAG13 without a value marks a compact run.\n                if ((current &\n                    (BinTrieFlags.VALUE_LENGTH | BinTrieFlags.FLAG13)) ===\n                    BinTrieFlags.FLAG13) {\n                    const runLength = (current & BinTrieFlags.BRANCH_LENGTH) >> 7;\n                    // Check first char (stored in JUMP_TABLE bits).\n                    if (input.charCodeAt(index) !==\n                        (current & BinTrieFlags.JUMP_TABLE)) {\n                        // eslint-disable-next-line unicorn/no-break-in-nested-loop\n                        break;\n                    }\n                    index += 1;\n                    // Check remaining characters (packed two per uint16 word).\n                    const remaining = runLength - 1;\n                    let wordIndex = nodeIndex + 1;\n                    let charIndexInPacked = 0;\n                    /*\n                     * Process pairs: read one packed word, compare low byte then high byte.\n                     * No explicit bounds check needed — charCodeAt returns NaN for OOB,\n                     * which never equals an integer, so the mismatch break fires naturally.\n                     */\n                    for (; charIndexInPacked + 1 < remaining; charIndexInPacked += 2) {\n                        const packed = decodeTree[wordIndex];\n                        if (input.charCodeAt(index) !== (packed & 0xff))\n                            break trie;\n                        index += 1;\n                        if (input.charCodeAt(index) !== ((packed >> 8) & 0xff))\n                            break trie;\n                        index += 1;\n                        wordIndex += 1;\n                    }\n                    // Handle odd trailing char.\n                    if (charIndexInPacked < remaining) {\n                        if (input.charCodeAt(index) !==\n                            (decodeTree[wordIndex] & 0xff))\n                            // eslint-disable-next-line unicorn/no-break-in-nested-loop\n                            break;\n                        index += 1;\n                    }\n                    nodeIndex += 1 + (runLength >> 1);\n                    current = decodeTree[nodeIndex];\n                    // eslint-disable-next-line unicorn/no-break-in-nested-loop\n                    continue;\n                }\n                // Header plus out-of-line value words; 0 means no value.\n                const valueLength = current >>> 14;\n                const char = input.charCodeAt(index);\n                /*\n                 * Check current node for a value before navigating.\n                 * This handles both: (a) values reached via compact runs on the\n                 * previous iteration, and (b) values at regular branch targets.\n                 */\n                if (valueLength !== 0) {\n                    // If char is `;`, emit immediately.\n                    if (char === CharCodes.SEMI) {\n                        consumed = index - entityStart + 1;\n                        // Inline leaves carry the value in the low 13 bits.\n                        value =\n                            valueLength === 1\n                                ? String.fromCharCode(current & BinTrieFlags.VALUE_MASK)\n                                : readTrieValue(decodeTree, nodeIndex, valueLength);\n                        // eslint-disable-next-line unicorn/no-break-in-nested-loop\n                        break;\n                    }\n                    // Record non-terminated (legacy) match (FLAG13 clear = semicolon optional).\n                    if (!isStrict && (current & BinTrieFlags.FLAG13) === 0) {\n                        consumed = index - entityStart;\n                        bestNodeIndex = nodeIndex;\n                        bestValueLength = valueLength;\n                    }\n                    /*\n                     * A valueLength of 1 means the value is packed inline in the header\n                     * word — these are always leaf nodes with no branches, so we can\n                     * stop walking the trie.\n                     */\n                    // eslint-disable-next-line unicorn/no-break-in-nested-loop\n                    if (valueLength === 1)\n                        break;\n                }\n                // Navigate to the next node (valueLength || 1: skip past value words, minimum 1 for header).\n                const next = determineBranch(decodeTree, current, nodeIndex + (valueLength || 1), char);\n                // eslint-disable-next-line unicorn/no-break-in-nested-loop\n                if (next < 0)\n                    break;\n                nodeIndex = next;\n                current = decodeTree[nodeIndex];\n                index += 1;\n            }\n            /*\n             * Post-loop: if the semicolon path didn't set value,\n             * check for a final legacy match. The last navigation may\n             * have landed on a legacy node whose value hasn't been\n             * recorded yet (loop exited before the top-of-loop check\n             * could run).\n             */\n            if (value === \"\") {\n                const finalVL = current >>> 14;\n                if (finalVL !== 0 &&\n                    !isStrict &&\n                    (current & BinTrieFlags.FLAG13) === 0) {\n                    consumed = index - entityStart;\n                    bestNodeIndex = nodeIndex;\n                    bestValueLength = finalVL;\n                }\n                if (consumed > 0) {\n                    value = readTrieValue(decodeTree, bestNodeIndex, bestValueLength);\n                }\n            }\n        }\n        else {\n            consumed = 0;\n            value = \"\";\n        }\n        /*\n         * The attribute end-char rule (HTML spec §13.2.5.73) only applies to\n         * unterminated *named* references.  Semicolon-terminated entities and\n         * numeric entities are always accepted, matching EntityDecoder behavior.\n         *\n         * When `attribute` is false (the common case), short-circuit skips all\n         * the unterminated-named checks entirely.\n         */\n        if (consumed === 0 ||\n            (isAttribute &&\n                firstChar !== CharCodes.NUM &&\n                input.charCodeAt(entityStart + consumed - 1) !==\n                    CharCodes.SEMI &&\n                entityStart + consumed < inputLength &&\n                isEntityInAttributeInvalidEnd(input.charCodeAt(entityStart + consumed)))) {\n            // Rejected: leave `&` in the pending chunk, scan past it.\n            offset = entityStart;\n        }\n        else {\n            if (chunkStart < offset) {\n                result += input.slice(chunkStart, offset);\n            }\n            result += value;\n            offset = chunkStart = entityStart + consumed;\n        }\n        /*\n         * Adjacent entities (`&x;&y;`) are common in entity-dense input;\n         * checking the single character at `offset` first skips the\n         * `indexOf` call (and its per-call overhead) for that case.\n         */\n        if (input.charCodeAt(offset) !== CharCodes.AMP) {\n            offset = input.indexOf(\"&\", offset);\n        }\n    } while (offset >= 0);\n    return result + input.slice(chunkStart);\n}\n/**\n * Decodes an HTML string.\n * @param htmlString The string to decode.\n * @param mode The decoding mode.\n * @returns The decoded string.\n */\nexport function decodeHTML(htmlString, mode = DecodingMode.Legacy) {\n    return decodeWithTrie(htmlString, mode === DecodingMode.Strict, mode === DecodingMode.Attribute);\n}\n/**\n * Decodes an HTML string in an attribute.\n * @param htmlAttribute The string to decode.\n * @returns The decoded string.\n */\nexport function decodeHTMLAttribute(htmlAttribute) {\n    return decodeWithTrie(htmlAttribute, false, true);\n}\n/**\n * Decodes an HTML string, requiring all entities to be terminated by a semicolon.\n * @param htmlString The string to decode.\n * @returns The decoded string.\n */\nexport function decodeHTMLStrict(htmlString) {\n    return decodeWithTrie(htmlString, true, false);\n}\n/**\n * Decodes an XML string, requiring all entities to be terminated by a semicolon.\n *\n * Uses a hand-coded fast path for the 5 XML named entities (amp, lt, gt,\n * quot, apos) plus numeric entities, bypassing the trie entirely.\n * @param xmlString The string to decode.\n * @returns The decoded string.\n */\nexport function decodeXML(xmlString) {\n    let offset = xmlString.indexOf(\"&\");\n    if (offset < 0)\n        return xmlString;\n    let lastIndex = 0;\n    let result = \"\";\n    do {\n        const start = offset + 1;\n        let consumed = 0;\n        let value = \"\";\n        const c1 = xmlString.charCodeAt(start);\n        if (c1 === CharCodes.NUM) {\n            const packed = parseNumericEntity(xmlString, start, xmlString.length);\n            consumed = unpackConsumed(packed);\n            // XML is always strict — require semicolon.\n            if (consumed === 0 ||\n                xmlString.charCodeAt(start + consumed - 1) !== CharCodes.SEMI) {\n                consumed = 0;\n            }\n            else {\n                const codePoint = packed & CODE_POINT_MASK;\n                // Nonzero BMP values below the surrogate range need no replacement.\n                value =\n                    (codePoint - 1) >>> 0 < 0xd7_ff\n                        ? String.fromCharCode(codePoint)\n                        : String.fromCodePoint(replaceCodePointXML(codePoint));\n            }\n        }\n        else {\n            /* eslint-disable unicorn/no-break-in-nested-loop -- Keep XML name dispatch inline with the decode loop. */\n            switch (c1) {\n                // &lt; / &gt;\n                case 0x6c:\n                case 0x67: {\n                    if (xmlString.charCodeAt(start + 1) === 0x74 &&\n                        xmlString.charCodeAt(start + 2) === CharCodes.SEMI) {\n                        consumed = 3;\n                        value = c1 === 0x6c ? \"<\" : \">\";\n                    }\n                    break;\n                }\n                // &amp; / &apos;\n                case 0x61: {\n                    const c2 = xmlString.charCodeAt(start + 1);\n                    if (c2 === 0x6d &&\n                        xmlString.charCodeAt(start + 2) === 0x70 &&\n                        xmlString.charCodeAt(start + 3) === CharCodes.SEMI) {\n                        consumed = 4;\n                        value = \"&\";\n                    }\n                    else if (c2 === 0x70 &&\n                        xmlString.charCodeAt(start + 2) === 0x6f &&\n                        xmlString.charCodeAt(start + 3) === 0x73 &&\n                        xmlString.charCodeAt(start + 4) === CharCodes.SEMI) {\n                        consumed = 5;\n                        value = \"'\";\n                    }\n                    break;\n                }\n                // &quot;\n                case 0x71: {\n                    if (xmlString.charCodeAt(start + 1) === 0x75 &&\n                        xmlString.charCodeAt(start + 2) === 0x6f &&\n                        xmlString.charCodeAt(start + 3) === 0x74 &&\n                        xmlString.charCodeAt(start + 4) === CharCodes.SEMI) {\n                        consumed = 5;\n                        value = '\"';\n                    }\n                    break;\n                }\n            }\n            /* eslint-enable unicorn/no-break-in-nested-loop */\n        }\n        if (consumed > 0) {\n            if (lastIndex < offset)\n                result += xmlString.slice(lastIndex, offset);\n            result += value;\n            offset = lastIndex = start + consumed;\n        }\n        else {\n            offset = start;\n        }\n        /*\n         * Adjacent entities (`&x;&y;`) are common in entity-dense input;\n         * checking the single character at `lastIndex` first skips the\n         * `indexOf` call (and its per-call overhead) for that case.\n         */\n        offset =\n            xmlString.charCodeAt(offset) === CharCodes.AMP\n                ? offset\n                : xmlString.indexOf(\"&\", offset);\n    } while (offset >= 0);\n    return result + xmlString.slice(lastIndex);\n}\nexport { replaceCodePoint, replaceCodePointXML, } from \"./decode-codepoint.js\";\n// Re-export for use by eg. htmlparser2\nexport { htmlDecodeTree } from \"./generated/decode-data-html.js\";\nexport { xmlDecodeTree } from \"./generated/decode-data-xml.js\";\n//# sourceMappingURL=decode.js.map","/**\n * Common utility functions exposed through `md.utils` for use by plugins.\n *\n * @module md.utils\n */\n\nimport * as mdurl from 'mdurl'\nimport * as ucmicro from 'uc.micro'\nimport { decodeHTMLStrict } from 'entities'\n\n/** @hidden */\ntype ClassToWrap = new (...args: any[]) => object\n\n/** Wraps a class so it can be called with or without `new`. */\nfunction callable<T extends ClassToWrap> (\n  cls: T\n): T & ((...args: ConstructorParameters<T>) => InstanceType<T>)\nfunction callable<T extends ClassToWrap> (cls: T) {\n  const wrapper = function (...args: ConstructorParameters<T>) {\n    const newTarget =\n      new.target && new.target !== wrapper\n        ? new.target\n        : cls\n\n    return Reflect.construct(cls, args, newTarget)\n  }\n\n  Object.defineProperty(wrapper, 'name', { value: cls.name })\n  Object.setPrototypeOf(wrapper, cls)\n  wrapper.prototype = cls.prototype\n\n  return wrapper\n}\n\n/**\n * Returns a copy of a token array with the token at `pos` replaced by\n * `newElements`. Used to transform token streams without modifying the\n * original array.\n */\nfunction arrayReplaceAt<T> (src: T[], pos: number, newElements: T[]): T[] {\n  return ([] as T[]).concat(src.slice(0, pos), newElements, src.slice(pos + 1))\n}\n\n/** Checks whether a code point can be decoded from a numeric HTML entity. */\nfunction isValidEntityCode (c: number) {\n  // broken sequence\n  if (c >= 0xD800 && c <= 0xDFFF) { return false }\n  // never used\n  if (c >= 0xFDD0 && c <= 0xFDEF) { return false }\n  if ((c & 0xFFFF) === 0xFFFF || (c & 0xFFFF) === 0xFFFE) { return false }\n  // control codes\n  if (c >= 0x00 && c <= 0x08) { return false }\n  if (c === 0x0B) { return false }\n  if (c >= 0x0E && c <= 0x1F) { return false }\n  if (c >= 0x7F && c <= 0x9F) { return false }\n  // out of range\n  if (c > 0x10FFFF) { return false }\n  return true\n}\n\n/**\n * Converts a Unicode code point to a string, like `String.fromCodePoint()`,\n * but does not throw for invalid input.\n */\nfunction fromCodePoint (c: number) {\n  /* eslint no-bitwise:0 */\n  if (c > 0xffff) {\n    c -= 0x10000\n    const surrogate1 = 0xd800 + (c >> 10)\n    const surrogate2 = 0xdc00 + (c & 0x3ff)\n\n    return String.fromCharCode(surrogate1, surrogate2)\n  }\n  return String.fromCharCode(c)\n}\n\nconst UNESCAPE_MD_RE = /\\\\([!\"#$%&'()*+,\\-./:;<=>?@[\\\\\\]^_`{|}~])/g\nconst ENTITY_RE = /&([a-z#][a-z0-9]{1,31});/gi\nconst UNESCAPE_ALL_RE = new RegExp(`${UNESCAPE_MD_RE.source}|${ENTITY_RE.source}`, 'gi')\n\nconst DIGITAL_ENTITY_TEST_RE = /^#((?:x[a-f0-9]{1,8}|[0-9]{1,8}))$/i\n\nfunction replaceEntityPattern (match: string, name: string) {\n  if (name.charCodeAt(0) === 0x23/* # */ && DIGITAL_ENTITY_TEST_RE.test(name)) {\n    const code = name[1].toLowerCase() === 'x'\n      ? parseInt(name.slice(2), 16)\n      : parseInt(name.slice(1), 10)\n\n    if (isValidEntityCode(code)) {\n      return fromCodePoint(code)\n    }\n\n    return match\n  }\n\n  const decoded = decodeHTMLStrict(match)\n  if (decoded !== match) {\n    return decoded\n  }\n\n  return match\n}\n\n/** Decodes Markdown backslash escapes. */\nfunction unescapeMd (str: string) {\n  if (str.indexOf('\\\\') < 0) { return str }\n  return str.replace(UNESCAPE_MD_RE, '$1')\n}\n\n/**\n * Decodes Markdown backslash escapes and HTML character references in link\n * destinations, link titles, and fenced code info strings.\n */\nfunction unescapeAll (str: string) {\n  if (str.indexOf('\\\\') < 0 && str.indexOf('&') < 0) { return str }\n\n  return str.replace(UNESCAPE_ALL_RE, function (match, escaped, entity) {\n    if (escaped) { return escaped }\n    return replaceEntityPattern(match, entity)\n  })\n}\n\nconst HTML_ESCAPE_TEST_RE = /[&<>\"]/\nconst HTML_ESCAPE_REPLACE_RE = /[&<>\"]/g\nconst HTML_REPLACEMENTS = {\n  '&': '&amp;',\n  '<': '&lt;',\n  '>': '&gt;',\n  '\"': '&quot;'\n}\n\nfunction replaceUnsafeChar (ch: string): string {\n  return HTML_REPLACEMENTS[ch as keyof typeof HTML_REPLACEMENTS]\n}\n\n/** Escapes HTML special characters in a string. */\nfunction escapeHtml (str: string) {\n  if (HTML_ESCAPE_TEST_RE.test(str)) {\n    return str.replace(HTML_ESCAPE_REPLACE_RE, replaceUnsafeChar)\n  }\n  return str\n}\n\nconst REGEXP_ESCAPE_RE = /[.?*+^$[\\]\\\\(){}|-]/g\n\n/** Escapes regular expression metacharacters in a string. */\nfunction escapeRE (str: string) {\n  return str.replace(REGEXP_ESCAPE_RE, '\\\\$&')\n}\n\n/** Checks whether a character code is an ASCII space or tab. */\nfunction isSpace (code: number) {\n  switch (code) {\n    case 0x09:\n    case 0x20:\n      return true\n  }\n  return false\n}\n\n/**\n * Checks whether a character code is whitespace recognized by Markdown.\n *\n * Matches the Unicode `Zs` category or `\\t`, `\\f`, `\\v`, `\\r`, `\\n`.\n */\nfunction isWhiteSpace (code: number) {\n  if (code >= 0x2000 && code <= 0x200A) { return true }\n  switch (code) {\n    case 0x09: // \\t\n    case 0x0A: // \\n\n    case 0x0B: // \\v\n    case 0x0C: // \\f\n    case 0x0D: // \\r\n    case 0x20:\n    case 0xA0:\n    case 0x1680:\n    case 0x202F:\n    case 0x205F:\n    case 0x3000:\n      return true\n  }\n  return false\n}\n\n/**\n * Checks whether a character is Unicode punctuation or a symbol.\n *\n * Does not support astral characters.\n */\nfunction isPunctChar (ch: string) {\n  return ucmicro.P.test(ch) || ucmicro.S.test(ch)\n}\n\n/** Checks whether a Unicode code point is punctuation or a symbol. */\nfunction isPunctCharCode (code: number) {\n  return isPunctChar(fromCodePoint(code))\n}\n\n/**\n * Markdown ASCII punctuation characters.\n *\n *     !, \", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, @,\n *     [, \\, ], ^, _, `, {, |, }, or ~\n *\n * http://spec.commonmark.org/0.15/#ascii-punctuation-character\n *\n * Don't confuse with Unicode punctuation. It lacks some characters in the\n * ASCII range.\n */\nfunction isMdAsciiPunct (ch: number) {\n  switch (ch) {\n    case 0x21/* ! */:\n    case 0x22/* \" */:\n    case 0x23/* # */:\n    case 0x24/* $ */:\n    case 0x25/* % */:\n    case 0x26/* & */:\n    case 0x27/* ' */:\n    case 0x28/* ( */:\n    case 0x29/* ) */:\n    case 0x2A/* * */:\n    case 0x2B/* + */:\n    case 0x2C/* , */:\n    case 0x2D/* - */:\n    case 0x2E/* . */:\n    case 0x2F/* / */:\n    case 0x3A/* : */:\n    case 0x3B/* ; */:\n    case 0x3C/* < */:\n    case 0x3D/* = */:\n    case 0x3E/* > */:\n    case 0x3F/* ? */:\n    case 0x40/* @ */:\n    case 0x5B/* [ */:\n    case 0x5C/* \\ */:\n    case 0x5D/* ] */:\n    case 0x5E/* ^ */:\n    case 0x5F/* _ */:\n    case 0x60/* ` */:\n    case 0x7B/* { */:\n    case 0x7C/* | */:\n    case 0x7D/* } */:\n    case 0x7E/* ~ */:\n      return true\n    default:\n      return false\n  }\n}\n\n/** Normalizes `[reference labels]` for case-insensitive lookup. */\nfunction normalizeReference (str: string) {\n  // Trim and collapse whitespace\n  //\n  str = str.trim().replace(/\\s+/g, ' ')\n\n  // .toLowerCase().toUpperCase() should get rid of all differences\n  // between letter variants.\n  //\n  // Simple .toLowerCase() doesn't normalize 125 code points correctly,\n  // and .toUpperCase doesn't normalize 6 of them (list of exceptions:\n  // İ, ϴ, ẞ, Ω, K, Å - those are already uppercased, but have differently\n  // uppercased versions).\n  //\n  // Here's an example showing how it happens. Lets take greek letter omega:\n  // uppercase U+0398 (Θ), U+03f4 (ϴ) and lowercase U+03b8 (θ), U+03d1 (ϑ)\n  //\n  // Unicode entries:\n  // 0398;GREEK CAPITAL LETTER THETA;Lu;0;L;;;;;N;;;;03B8;\n  // 03B8;GREEK SMALL LETTER THETA;Ll;0;L;;;;;N;;;0398;;0398\n  // 03D1;GREEK THETA SYMBOL;Ll;0;L;<compat> 03B8;;;;N;GREEK SMALL LETTER SCRIPT THETA;;0398;;0398\n  // 03F4;GREEK CAPITAL THETA SYMBOL;Lu;0;L;<compat> 0398;;;;N;;;;03B8;\n  //\n  // Case-insensitive comparison should treat all of them as equivalent.\n  //\n  // But .toLowerCase() doesn't change ϑ (it's already lowercase),\n  // and .toUpperCase() doesn't change ϴ (already uppercase).\n  //\n  // Applying first lower then upper case normalizes any character:\n  // '\\u0398\\u03f4\\u03b8\\u03d1'.toLowerCase().toUpperCase() === '\\u0398\\u0398\\u0398\\u0398'\n  //\n  // Note: this is equivalent to unicode case folding; unicode normalization\n  // is a different step that is not required here.\n  //\n  // Final result should be uppercased, because it's later stored in an object\n  // (this avoid a conflict with Object.prototype members,\n  // most notably, `__proto__`)\n  //\n  return str.toLowerCase().toUpperCase()\n}\n\nfunction isAsciiTrimmable (c: number) {\n  return c === 0x20 || c === 0x09 || c === 0x0a || c === 0x0d\n}\n\n/**\n * \"Light\" `.trim()` for blocks (headings, paragraphs), where Unicode spaces\n * should be preserved.\n */\nfunction asciiTrim (str: string) {\n  let start = 0\n  for (; start < str.length; start++) {\n    if (!isAsciiTrimmable(str.charCodeAt(start))) {\n      break\n    }\n  }\n  let end = str.length - 1\n  for (; end >= start; end--) {\n    if (!isAsciiTrimmable(str.charCodeAt(end))) {\n      break\n    }\n  }\n  return str.slice(start, end + 1)\n}\n\n/**\n * Libraries commonly used by markdown-it and its plugins, re-exported to\n * reduce duplicate dependencies in browser bundles.\n */\nconst lib = { mdurl, ucmicro }\n\nexport {\n  lib,\n  callable,\n  unescapeMd,\n  unescapeAll,\n  isValidEntityCode,\n  fromCodePoint,\n  escapeHtml,\n  arrayReplaceAt,\n  isSpace,\n  isWhiteSpace,\n  isMdAsciiPunct,\n  isPunctChar,\n  isPunctCharCode,\n  escapeRE,\n  normalizeReference,\n  asciiTrim\n}\n","import type StateInline from '../rules_inline/state_inline.ts'\n\n/** Finds the end of a link or image label (`[label]`). */\nexport default function parseLinkLabel (state: StateInline, start: number, disableNested?: boolean): number {\n  let level, found, marker, prevPos\n\n  const max = state.posMax\n  const oldPos = state.pos\n\n  state.pos = start + 1\n  level = 1\n\n  while (state.pos < max) {\n    marker = state.src.charCodeAt(state.pos)\n    if (marker === 0x5D /* ] */) {\n      level--\n      if (level === 0) {\n        found = true\n        break\n      }\n    }\n\n    prevPos = state.pos\n    state.md.inline.skipToken(state)\n    if (marker === 0x5B /* [ */) {\n      if (prevPos === state.pos - 1) {\n        // increase level if we find text `[`, which is not a part of any token\n        level++\n      } else if (disableNested) {\n        state.pos = oldPos\n        return -1\n      }\n    }\n  }\n\n  let labelEnd = -1\n\n  if (found) {\n    labelEnd = state.pos\n  }\n\n  // restore old state\n  state.pos = oldPos\n\n  return labelEnd\n}\n","import { unescapeAll } from '../common/utils.ts'\n\n/** Parses the destination in `[label](destination \"title\")`. */\nexport default function parseLinkDestination (str: string, start: number, max: number) {\n  let code\n  let pos = start\n\n  const result = {\n    ok: false,\n    pos: 0,\n    str: ''\n  }\n\n  if (str.charCodeAt(pos) === 0x3C /* < */) {\n    pos++\n    while (pos < max) {\n      code = str.charCodeAt(pos)\n      if (code === 0x0A /* \\n */) { return result }\n      if (code === 0x3C /* < */) { return result }\n      if (code === 0x3E /* > */) {\n        result.pos = pos + 1\n        result.str = unescapeAll(str.slice(start + 1, pos))\n        result.ok = true\n        return result\n      }\n      if (code === 0x5C /* \\ */ && pos + 1 < max) {\n        pos += 2\n        continue\n      }\n\n      pos++\n    }\n\n    // no closing '>'\n    return result\n  }\n\n  // this should be ... } else { ... branch\n\n  let level = 0\n  while (pos < max) {\n    code = str.charCodeAt(pos)\n\n    if (code === 0x20) { break }\n\n    // ascii control characters\n    if (code < 0x20 || code === 0x7F) { break }\n\n    if (code === 0x5C /* \\ */ && pos + 1 < max) {\n      if (str.charCodeAt(pos + 1) === 0x20) { pos++; continue }\n      pos += 2\n      continue\n    }\n\n    if (code === 0x28 /* ( */) {\n      level++\n      if (level > 32) { return result }\n    }\n\n    if (code === 0x29 /* ) */) {\n      if (level === 0) { break }\n      level--\n    }\n\n    pos++\n  }\n\n  if (start === pos) { return result }\n  if (level !== 0) { return result }\n\n  result.str = unescapeAll(str.slice(start, pos))\n  result.pos = pos\n  result.ok = true\n  return result\n}\n","import { unescapeAll } from '../common/utils.ts'\n\n/** @inline */\ninterface ParseLinkTitleResult {\n  ok: boolean\n  can_continue: boolean\n  pos: number\n  str: string\n  marker: number\n}\n\n/**\n * Parses the optional title in `[label](destination \"title\")` or\n * `[label]: destination \"title\"`.\n *\n * `prev_state` continues a reference title on the next source line.\n */\nexport default function parseLinkTitle (\n  str: string,\n  start: number,\n  max: number,\n  prev_state?: ParseLinkTitleResult\n): ParseLinkTitleResult {\n  let code\n  let pos = start\n\n  const state = {\n    // if `true`, this is a valid link title\n    ok: false,\n    // if `true`, this link can be continued on the next line\n    can_continue: false,\n    // if `ok`, it's the position of the first character after the closing marker\n    pos: 0,\n    // if `ok`, it's the unescaped title\n    str: '',\n    // expected closing marker character code\n    marker: 0\n  }\n\n  if (prev_state) {\n    // this is a continuation of a previous parseLinkTitle call on the next line,\n    // used in reference links only\n    state.str = prev_state.str\n    state.marker = prev_state.marker\n  } else {\n    if (pos >= max) { return state }\n\n    let marker = str.charCodeAt(pos)\n    if (marker !== 0x22 /* \" */ && marker !== 0x27 /* ' */ && marker !== 0x28 /* ( */) { return state }\n\n    start++\n    pos++\n\n    // if opening marker is \"(\", switch it to closing marker \")\"\n    if (marker === 0x28) { marker = 0x29 }\n\n    state.marker = marker\n  }\n\n  while (pos < max) {\n    code = str.charCodeAt(pos)\n    if (code === state.marker) {\n      state.pos = pos + 1\n      state.str += unescapeAll(str.slice(start, pos))\n      state.ok = true\n      return state\n    } else if (code === 0x28 /* ( */ && state.marker === 0x29 /* ) */) {\n      return state\n    } else if (code === 0x5C /* \\ */ && pos + 1 < max) {\n      pos++\n    }\n\n    pos++\n  }\n\n  // no closing marker found, but this link title may continue on the next line (for references)\n  state.can_continue = true\n  state.str += unescapeAll(str.slice(start, pos))\n  return state\n}\n","/**\n * Functions used to parse links and images, split out of parser rules because\n * of their size.\n *\n * @module md.helpers\n */\n\n// Just a shortcut for bulk export\n\nimport parseLinkLabel from './parse_link_label.ts'\nimport parseLinkDestination from './parse_link_destination.ts'\nimport parseLinkTitle from './parse_link_title.ts'\n\nexport {\n  parseLinkLabel,\n  parseLinkDestination,\n  parseLinkTitle\n}\n","// Token class\n\n/** @inline */\ntype TokenNesting = -1 | 0 | 1\n\n/** @inline */\ntype TokenAttribute = [name: string, value: string | number]\n\n/**\n * Represents one item in the parsed token stream, storing parsed data and\n * providing helpers for managing HTML attributes.\n */\nclass Token {\n  /**\n   * Type of the token (string, e.g. \"paragraph_open\")\n   */\n  declare type: string\n\n  /**\n   * html tag name, e.g. \"p\"\n   */\n  declare tag: string\n\n  /** Html attributes. Format: `[ [ name1, value1 ], [ name2, value2 ] ]` */\n  declare attrs: TokenAttribute[] | null\n\n  /**\n   * Source map info. Format: `[ line_begin, line_end ]`\n   */\n  map: [number, number] | null = null\n\n  /**\n   * Level change (number in {-1, 0, 1} set), where:\n   *\n   * -  `1` means the tag is opening\n   * -  `0` means the tag is self-closing\n   * - `-1` means the tag is closing\n   */\n  declare nesting: TokenNesting\n\n  /**\n   * nesting level, the same as `state.level`\n   */\n  level = 0\n\n  /**\n   * An array of child nodes (inline and img tokens)\n   */\n  children: Token[] | null = null\n\n  /**\n   * In a case of self-closing tag (code, html, fence, etc.),\n   * it has contents of this tag.\n   */\n  content = ''\n\n  /**\n   * '*' or '_' for emphasis, fence string for fence, etc.\n   */\n  markup = ''\n\n  /**\n   * Additional information:\n   *\n   * - Info string for \"fence\" tokens\n   * - The value \"auto\" for autolink \"link_open\" and \"link_close\" tokens\n   * - The string value of the item marker for ordered-list \"list_item_open\" tokens\n   */\n  info = ''\n\n  /** A place for plugins to store an arbitrary data */\n  declare meta: Record<string, unknown> | null\n\n  /**\n   * True for block-level tokens, false for inline tokens.\n   * Used in renderer to calculate line breaks\n   */\n  block = false\n\n  /**\n   * If it's true, ignore this element when rendering. Used for tight lists\n   * to hide paragraphs.\n   */\n  hidden = false\n\n  constructor (type: string, tag: string, nesting: TokenNesting) {\n    this.type = type\n    this.tag = tag\n\n    this.attrs = null\n\n    this.nesting = nesting\n\n    this.meta = null\n  }\n\n  /**\n   * Search attribute index by name.\n   */\n  attrIndex (name: string): number {\n    if (!this.attrs) { return -1 }\n\n    const attrs = this.attrs\n\n    for (let i = 0, len = attrs.length; i < len; i++) {\n      if (attrs[i][0] === name) { return i }\n    }\n    return -1\n  }\n\n  /**\n   * Add `[ name, value ]` attribute to list. Init attrs if necessary\n   */\n  attrPush (attrData: TokenAttribute): void {\n    if (this.attrs) {\n      this.attrs.push(attrData)\n    } else {\n      this.attrs = [attrData]\n    }\n  }\n\n  /**\n   * Set `name` attribute to `value`. Override old value if exists.\n   */\n  attrSet (name: string, value: string | number): void {\n    const idx = this.attrIndex(name)\n    const attrData: TokenAttribute = [name, value]\n\n    if (idx < 0) {\n      this.attrPush(attrData)\n    } else {\n      this.attrs![idx] = attrData\n    }\n  }\n\n  /**\n   * Get the value of attribute `name`, or null if it does not exist.\n   */\n  attrGet (name: string): string | number | null {\n    const idx = this.attrIndex(name)\n    let value = null\n    if (idx >= 0) {\n      value = this.attrs![idx][1]\n    }\n    return value\n  }\n\n  /**\n   * Join value to existing attribute via space. Or create new attribute if not\n   * exists. Useful to operate with token classes.\n   */\n  attrJoin (name: string, value: string | number): void {\n    const idx = this.attrIndex(name)\n\n    if (idx < 0) {\n      this.attrPush([name, value])\n    } else {\n      this.attrs![idx][1] = `${this.attrs![idx][1]} ${value}`\n    }\n  }\n}\n\nexport default Token\n","/** @inline */\ntype RuleOptions = { alt?: string[] }\n\n/**\n * Helper class, used by {@link MarkdownIt.core}, {@link MarkdownIt.block} and\n * {@link MarkdownIt.inline} to manage sequences of functions (rules):\n *\n * - keep rules in defined order\n * - assign the name to each rule\n * - enable/disable rules\n * - add/replace rules\n * - allow assign rules to additional named chains (in the same)\n * - cacheing lists of active rules\n *\n * You will not need use this class directly until write plugins. For simple\n * rules control use {@link MarkdownIt.disable}, {@link MarkdownIt.enable} and\n * {@link MarkdownIt.use}.\n */\nclass Ruler<Args extends unknown[], Result> {\n  /** @internal */\n  __rules__: Array<{\n    name: string\n    enabled: boolean\n    fn: (...args: Args) => Result\n    alt: string[]\n  }> = []\n\n  // Cached rule chains.\n  //\n  // First level - chain name, '' for default.\n  // Second level - diginal anchor for fast filtering by charcodes.\n  //\n  /** @internal */\n  __cache__: Record<string, Array<(...args: Args) => Result>> | null = null\n\n  /** @internal */\n  __find__ (name: string): number {\n    for (let i = 0; i < this.__rules__.length; i++) {\n      if (this.__rules__[i].name === name) {\n        return i\n      }\n    }\n    return -1\n  }\n\n  /** @internal */\n  __compile__ (): void {\n    const chains = new Set<string>()\n\n    // collect unique names\n    this.__rules__.forEach(rule => {\n      if (!rule.enabled) return\n      rule.alt.forEach(altName => {\n        if (altName) chains.add(altName)\n      })\n    })\n\n    this.__cache__ = Object.create(null)\n\n    // Collect default chain\n    this.__cache__![''] = []\n    this.__rules__.forEach(rule => {\n      if (rule.enabled) this.__cache__![''].push(rule.fn)\n    })\n\n    // Collect alt chains\n    chains.forEach(chain => {\n      this.__cache__![chain] = []\n\n      this.__rules__.forEach(rule => {\n        if (rule.enabled && rule.alt.indexOf(chain) >= 0) {\n          this.__cache__![chain].push(rule.fn)\n        }\n      })\n    })\n  }\n\n  /**\n   * Replace rule by name with new function & options. Throws error if name not\n   * found.\n   *\n   * @example Replace existing typographer replacement rule with new one\n   * ```javascript\n   * import MarkdownIt from 'markdown-it'\n   * const md = new MarkdownIt()\n   *\n   * md.core.ruler.at('replacements', function replace(state) {\n   *   //...\n   * });\n   * ```\n   */\n  at (name: string, fn: (...args: Args) => Result, options: RuleOptions = {}): void {\n    const index = this.__find__(name)\n\n    if (index === -1) { throw new Error(`Parser rule not found: ${name}`) }\n\n    this.__rules__[index].fn = fn\n    this.__rules__[index].alt = options.alt || []\n    this.__cache__ = null\n  }\n\n  /**\n   * Add new rule to chain before one with given name. See also\n   * {@link Ruler.after}, {@link Ruler.push}.\n   *\n   * @example\n   * ```javascript\n   * import MarkdownIt from 'markdown-it'\n   * const md = new MarkdownIt()\n   *\n   * md.block.ruler.before('paragraph', 'my_rule', function replace(state) {\n   *   //...\n   * });\n   * ```\n   */\n  before (beforeName: string, ruleName: string, fn: (...args: Args) => Result, options: RuleOptions = {}): void {\n    const index = this.__find__(beforeName)\n\n    if (index === -1) { throw new Error(`Parser rule not found: ${beforeName}`) }\n\n    this.__rules__.splice(index, 0, {\n      name: ruleName,\n      enabled: true,\n      fn,\n      alt: options.alt || []\n    })\n\n    this.__cache__ = null\n  }\n\n  /**\n   * Add new rule to chain after one with given name. See also\n   * {@link Ruler.before}, {@link Ruler.push}.\n   *\n   * @example\n   * ```javascript\n   * import MarkdownIt from 'markdown-it'\n   * const md = new MarkdownIt()\n   *\n   * md.inline.ruler.after('text', 'my_rule', function replace(state) {\n   *   //...\n   * });\n   * ```\n   */\n  after (afterName: string, ruleName: string, fn: (...args: Args) => Result, options: RuleOptions = {}): void {\n    const index = this.__find__(afterName)\n\n    if (index === -1) { throw new Error(`Parser rule not found: ${afterName}`) }\n\n    this.__rules__.splice(index + 1, 0, {\n      name: ruleName,\n      enabled: true,\n      fn,\n      alt: options.alt || []\n    })\n\n    this.__cache__ = null\n  }\n\n  /**\n   * Push new rule to the end of chain. See also\n   * {@link Ruler.before}, {@link Ruler.after}.\n   *\n   * @example\n   * ```javascript\n   * import MarkdownIt from 'markdown-it'\n   * const md = new MarkdownIt()\n   *\n   * md.core.ruler.push('my_rule', function replace(state) {\n   *   //...\n   * });\n   * ```\n   */\n  push (ruleName: string, fn: (...args: Args) => Result, options: RuleOptions = {}): void {\n    this.__rules__.push({\n      name: ruleName,\n      enabled: true,\n      fn,\n      alt: options.alt || []\n    })\n\n    this.__cache__ = null\n  }\n\n  /**\n   * Enable rules with given names. If any rule name not found - throw Error.\n   * Errors can be disabled by second param.\n   *\n   * See also {@link Ruler.disable}, {@link Ruler.enableOnly}.\n   *\n   * Returns list of found rule names (if no exception happened).\n   */\n  enable (list: string | string[], ignoreInvalid = false): string[] {\n    if (!Array.isArray(list)) { list = [list] }\n\n    const result: string[] = []\n\n    // Search by name and enable\n    list.forEach(name => {\n      const idx = this.__find__(name)\n\n      if (idx < 0) {\n        if (ignoreInvalid) { return }\n        throw new Error(`Rules manager: invalid rule name ${name}`)\n      }\n      this.__rules__[idx].enabled = true\n      result.push(name)\n    })\n\n    this.__cache__ = null\n    return result\n  }\n\n  /**\n   * Enable rules with given names, and disable everything else. If any rule name\n   * not found - throw Error. Errors can be disabled by second param.\n   *\n   * See also {@link Ruler.disable}, {@link Ruler.enable}.\n   */\n  enableOnly (list: string | string[], ignoreInvalid = false): void {\n    if (!Array.isArray(list)) { list = [list] }\n\n    this.__rules__.forEach(rule => { rule.enabled = false })\n\n    this.enable(list, ignoreInvalid)\n  }\n\n  /**\n   * Disable rules with given names. If any rule name not found - throw Error.\n   * Errors can be disabled by second param.\n   *\n   * See also {@link Ruler.enable}, {@link Ruler.enableOnly}.\n   *\n   * Returns list of found rule names (if no exception happened).\n   */\n  disable (list: string | string[], ignoreInvalid = false): string[] {\n    if (!Array.isArray(list)) { list = [list] }\n\n    const result: string[] = []\n\n    // Search by name and disable\n    list.forEach(name => {\n      const idx = this.__find__(name)\n\n      if (idx < 0) {\n        if (ignoreInvalid) { return }\n        throw new Error(`Rules manager: invalid rule name ${name}`)\n      }\n      this.__rules__[idx].enabled = false\n      result.push(name)\n    })\n\n    this.__cache__ = null\n    return result\n  }\n\n  /**\n   * Return array of active functions (rules) for given chain name. It analyzes\n   * rules configuration, compiles caches if not exists and returns result.\n   *\n   * Default chain name is `''` (empty string). It can't be skipped. That's\n   * done intentionally, to keep signature monomorphic for high speed.\n   */\n  getRules (chainName: string): Array<(...args: Args) => Result> {\n    if (!this.__cache__) this.__compile__()\n\n    // Chain can be empty, if rules disabled. But we still have to return Array.\n    return this.__cache__![chainName] || []\n  }\n}\n\nexport default Ruler\n","import { unescapeAll, escapeHtml } from './common/utils.ts'\nimport type Token from './token.ts'\nimport type { Env, MarkdownItOptions } from './types.ts'\n\n/** Function that renders a token at a given position in a token stream. */\nexport type RendererRule = (\n  tokens: Token[],\n  idx: number,\n  options: Required<MarkdownItOptions>,\n  env: Env | undefined,\n  renderer: Renderer\n) => string\n\nconst default_rules: Record<string, RendererRule> = {}\n\ndefault_rules.code_inline = function (\n  tokens: Token[],\n  idx: number,\n  options: Required<MarkdownItOptions>,\n  env: Env | undefined,\n  slf: Renderer\n): string {\n  const token = tokens[idx]\n\n  return `<code${slf.renderAttrs(token)}>${escapeHtml(token.content)}</code>`\n}\n\ndefault_rules.code_block = function (\n  tokens: Token[],\n  idx: number,\n  options: Required<MarkdownItOptions>,\n  env: Env | undefined,\n  slf: Renderer\n): string {\n  const token = tokens[idx]\n\n  return `<pre${slf.renderAttrs(token)}><code>${escapeHtml(tokens[idx].content)}</code></pre>\\n`\n}\n\ndefault_rules.fence = function (\n  tokens: Token[],\n  idx: number,\n  options: Required<MarkdownItOptions>,\n  env: Env | undefined,\n  slf: Renderer\n): string {\n  const token = tokens[idx]\n  const info = token.info ? unescapeAll(token.info).trim() : ''\n  let langName = ''\n  let langAttrs = ''\n\n  if (info) {\n    const arr = info.split(/(\\s+)/g)\n    langName = arr[0]\n    langAttrs = arr.slice(2).join('')\n  }\n\n  let highlighted\n  if (options.highlight) {\n    highlighted = options.highlight(token.content, langName, langAttrs) || escapeHtml(token.content)\n  } else {\n    highlighted = escapeHtml(token.content)\n  }\n\n  if (highlighted.indexOf('<pre') === 0) {\n    return highlighted + '\\n'\n  }\n\n  // If language exists, inject class gently, without modifying original token.\n  // May be, one day we will add .deepClone() for token and simplify this part, but\n  // now we prefer to keep things local.\n  if (info) {\n    const i = token.attrIndex('class')\n    const tmpAttrs = token.attrs ? token.attrs.slice() : []\n\n    if (i < 0) {\n      tmpAttrs.push(['class', `${options.langPrefix}${langName}`])\n    } else {\n      tmpAttrs[i] = [tmpAttrs[i][0], tmpAttrs[i][1]] // shallow clone\n      tmpAttrs[i][1] += ` ${options.langPrefix}${langName}`\n    }\n\n    // Fake token just to render attributes\n    const tmpToken = {\n      attrs: tmpAttrs\n    }\n\n    return `<pre><code${slf.renderAttrs(tmpToken)}>${highlighted}</code></pre>\\n`\n  }\n\n  return `<pre><code${slf.renderAttrs(token)}>${highlighted}</code></pre>\\n`\n}\n\ndefault_rules.image = function (\n  tokens: Token[],\n  idx: number,\n  options: Required<MarkdownItOptions>,\n  env: Env | undefined,\n  slf: Renderer\n): string {\n  const token = tokens[idx]\n\n  // \"alt\" attr MUST be set, even if empty. Because it's mandatory and\n  // should be placed on proper position for tests.\n  //\n  // Replace content with actual value\n\n  token.attrs![token.attrIndex('alt')][1] =\n    slf.renderInlineAsText(token.children!, options, env)\n\n  return slf.renderToken(tokens, idx, options)\n}\n\ndefault_rules.hardbreak = function (\n  tokens: Token[],\n  idx: number,\n  options: Required<MarkdownItOptions>\n): string {\n  return options.xhtmlOut ? '<br />\\n' : '<br>\\n'\n}\ndefault_rules.softbreak = function (\n  tokens: Token[],\n  idx: number,\n  options: Required<MarkdownItOptions>\n): string {\n  return options.breaks ? (options.xhtmlOut ? '<br />\\n' : '<br>\\n') : '\\n'\n}\n\ndefault_rules.text = function (tokens: Token[], idx: number): string {\n  return escapeHtml(tokens[idx].content)\n}\n\ndefault_rules.html_block = function (tokens: Token[], idx: number): string {\n  return tokens[idx].content\n}\ndefault_rules.html_inline = function (tokens: Token[], idx: number): string {\n  return tokens[idx].content\n}\n\n/**\n * Generates HTML from parsed token stream. Each instance has independent\n * copy of rules. Those can be rewritten with ease. Also, you can add new\n * rules if you create plugin and adds new token types.\n *\n * Creates new renderer instance and fills {@link Renderer.rules} with defaults.\n */\nclass Renderer {\n  /**\n   * Contains render rules for tokens. Can be updated and extended.\n   *\n   * See [source code](https://github.com/markdown-it/markdown-it/blob/master/src/renderer.ts)\n   * for more details and examples.\n   *\n   * @example Custom render rules\n   * ```javascript\n   * import MarkdownIt from 'markdown-it'\n   * const md = new MarkdownIt()\n   *\n   * md.renderer.rules.strong_open  = function () { return '<b>'; };\n   * md.renderer.rules.strong_close = function () { return '</b>'; };\n   *\n   * const result = md.renderInline(...);\n   * ```\n   *\n   * @example Each rule is called as independent static function with fixed signature\n   * ```javascript\n   * function my_token_render(tokens, idx, options, env, renderer) {\n   *   // ...\n   *   return renderedHTML;\n   * }\n   * ```\n   */\n  rules: Record<string, RendererRule> = Object.assign({}, default_rules)\n\n  /**\n   * Render token attributes to string.\n   */\n  renderAttrs (token: Pick<Token, 'attrs'>): string {\n    let i, l, result\n\n    if (!token.attrs) { return '' }\n\n    result = ''\n\n    for (i = 0, l = token.attrs.length; i < l; i++) {\n      result += ` ${escapeHtml(token.attrs[i][0])}=\"${escapeHtml(String(token.attrs[i][1]))}\"`\n    }\n\n    return result\n  }\n\n  /**\n   * Default token renderer. Can be overriden by custom function\n   * in {@link Renderer.rules}.\n   */\n  renderToken (tokens: Token[], idx: number, options: Required<MarkdownItOptions>): string {\n    const token = tokens[idx]\n    let result = ''\n\n    // Tight list paragraphs\n    if (token.hidden) {\n      return ''\n    }\n\n    // Insert a newline between hidden paragraph and subsequent opening\n    // block-level tag.\n    //\n    // For example, here we should insert a newline before blockquote:\n    //  - a\n    //    >\n    //\n    // Only closing hidden tokens count, to not break on other hidden ones.\n    //\n    // Hidden tokens without nesting (`reference_definition`) are skipped here\n    // and below, or they would break line feeds around neighbour blocks.\n    //\n    let prev = idx - 1\n    while (prev >= 0 && tokens[prev].hidden && tokens[prev].nesting === 0) { prev-- }\n\n    if (token.block && token.nesting !== -1 && prev >= 0 &&\n        tokens[prev].hidden && tokens[prev].nesting === -1) {\n      result += '\\n'\n    }\n\n    // Add token name, e.g. `<img`\n    result += (token.nesting === -1 ? '</' : '<') + token.tag\n\n    // Encode attributes, e.g. `<img src=\"foo\"`\n    result += this.renderAttrs(token)\n\n    // Add a slash for self-closing tags, e.g. `<img src=\"foo\" /`\n    if (token.nesting === 0 && options.xhtmlOut) {\n      result += ' /'\n    }\n\n    // Check if we need to add a newline after this tag\n    let needLf = false\n    if (token.block) {\n      needLf = true\n\n      if (token.nesting === 1) {\n        let next = idx + 1\n        while (next < tokens.length && tokens[next].hidden && tokens[next].nesting === 0) { next++ }\n\n        if (next < tokens.length) {\n          const nextToken = tokens[next]\n\n          if (nextToken.type === 'inline' || nextToken.hidden) {\n          // Block-level tag containing an inline tag.\n          //\n            needLf = false\n          } else if (nextToken.nesting === -1 && nextToken.tag === token.tag) {\n          // Opening tag + closing tag of the same type. E.g. `<li></li>`.\n          //\n            needLf = false\n          }\n        }\n      }\n    }\n\n    result += needLf ? '>\\n' : '>'\n\n    return result\n  }\n\n  /**\n   * The same as {@link Renderer.render}, but for single token of `inline` type.\n   */\n  renderInline (tokens: Token[], options: Required<MarkdownItOptions>, env: Env | undefined): string {\n    let result = ''\n    const rules = this.rules\n\n    for (let i = 0, len = tokens.length; i < len; i++) {\n      const type = tokens[i].type\n\n      if (typeof rules[type] !== 'undefined') {\n        result += rules[type](tokens, i, options, env, this)\n      } else {\n        result += this.renderToken(tokens, i, options)\n      }\n    }\n\n    return result\n  }\n\n  /**\n   * Special kludge for image `alt` attributes to conform CommonMark spec.\n   * Don't try to use it! Spec requires to show `alt` content with stripped markup,\n   * instead of simple escaping.\n   */\n  renderInlineAsText (tokens: Token[], options: Required<MarkdownItOptions>, env: Env | undefined): string {\n    let result = ''\n\n    for (let i = 0, len = tokens.length; i < len; i++) {\n      switch (tokens[i].type) {\n        case 'text':\n        case 'code_inline':\n          // code content is added as plain text, without backticks\n          result += tokens[i].content\n          break\n        case 'image':\n          result += this.renderInlineAsText(tokens[i].children!, options, env)\n          break\n        case 'html_inline':\n        case 'html_block':\n          result += tokens[i].content\n          break\n        case 'softbreak':\n        case 'hardbreak':\n          result += '\\n'\n          break\n        default:\n        // all other tokens are skipped\n      }\n    }\n\n    return result\n  }\n\n  /**\n   * Takes token stream and generates HTML. Probably, you will never need to call\n   * this method directly.\n   */\n  render (tokens: Token[], options: Required<MarkdownItOptions>, env?: Env): string {\n    let result = ''\n    const rules = this.rules\n\n    for (let i = 0, len = tokens.length; i < len; i++) {\n      const type = tokens[i].type\n\n      if (type === 'inline') {\n        result += this.renderInline(tokens[i].children!, options, env)\n      } else if (typeof rules[type] !== 'undefined') {\n        result += rules[type](tokens, i, options, env, this)\n      } else {\n        result += this.renderToken(tokens, i, options)\n      }\n    }\n\n    return result\n  }\n}\n\nexport default Renderer\n","import Token from '../token.ts'\nimport type MarkdownIt from '../markdownit.ts'\nimport type { Env } from '../types.ts'\n\n/** Mutable state passed through the core rules chain. */\nclass StateCore {\n  declare src: string\n  declare env: Env\n  tokens: Token[] = []\n  inlineMode = false\n  declare md: MarkdownIt\n\n  // re-export Token class to use in core rules\n  Token = Token\n\n  constructor (src: string, md: MarkdownIt, env: Env) {\n    this.src = src\n    this.env = env\n    this.md = md // link to parser instance\n  }\n}\n\nexport default StateCore\n","// Normalize input string\n\nimport type StateCore from './state_core.ts'\n\n// https://spec.commonmark.org/0.29/#line-ending\nconst UNNORMALIZED_NEWLINE_RE = /\\r\\n?/g\nconst NULL_RE = /\\0/g\n\nexport default function normalize (state: StateCore): void {\n  let str\n\n  // Normalize newlines\n  str = state.src.replace(UNNORMALIZED_NEWLINE_RE, '\\n')\n\n  // Replace NULL characters\n  str = str.replace(NULL_RE, '\\uFFFD')\n\n  state.src = str\n}\n","import type StateCore from './state_core.ts'\n\nexport default function block (state: StateCore): void {\n  let token\n\n  if (state.inlineMode) {\n    token = new state.Token('inline', '', 0)\n    token.content = state.src\n    token.map = [0, 1]\n    token.children = []\n    state.tokens.push(token)\n  } else {\n    state.md.block.parse(state.src, state.md, state.env, state.tokens)\n  }\n}\n","// Drop `reference_definition` tokens to keep the stream backward compatible\n//\n// Those tokens mark places link definitions took in the source. They are new,\n// and plugins walking block tokens may not expect them, so by default the\n// stream stays as it always was. Disable this rule to opt in.\n//\n\nimport type StateCore from './state_core.ts'\n\nexport default function strip_references (state: StateCore): void {\n  const tokens = state.tokens\n  let last = 0\n\n  for (let curr = 0; curr < tokens.length; curr++) {\n    if (tokens[curr].type === 'reference_definition') continue\n\n    if (curr !== last) { tokens[last] = tokens[curr] }\n\n    last++\n  }\n\n  if (tokens.length !== last) { tokens.length = last }\n}\n","import type StateCore from './state_core.ts'\n\nexport default function inline (state: StateCore): void {\n  const tokens = state.tokens\n\n  // Parse inlines\n  for (let i = 0, l = tokens.length; i < l; i++) {\n    const tok = tokens[i]\n    if (tok.type === 'inline') {\n      state.md.inline.parse(tok.content, state.md, state.env, tok.children!)\n    }\n  }\n}\n","// Replace link-like texts with link nodes.\n//\n// Currently restricted by `md.validateLink()` to http/https/ftp\n//\n\nimport type StateCore from './state_core.ts'\n\nfunction isLinkOpen (str: string) {\n  return /^<a[>\\s]/i.test(str)\n}\nfunction isLinkClose (str: string) {\n  return /^<\\/a\\s*>/i.test(str)\n}\n\nexport default function linkify (state: StateCore): void {\n  const blockTokens = state.tokens\n\n  if (!state.md.options.linkify) { return }\n\n  for (let j = 0, l = blockTokens.length; j < l; j++) {\n    if (blockTokens[j].type !== 'inline' ||\n        !state.md.linkify.test(blockTokens[j].content)) {\n      continue\n    }\n\n    const tokens = blockTokens[j].children!\n    const replacements: Array<{ index: number, nodes: typeof tokens }> = []\n\n    let htmlLinkLevel = 0\n\n    // We scan from the end, to keep position when new tags added.\n    // Use reversed logic in links start/end match\n    for (let i = tokens.length - 1; i >= 0; i--) {\n      const currentToken = tokens[i]\n\n      // Skip content of markdown links\n      if (currentToken.type === 'link_close') {\n        i--\n        while (tokens[i].level !== currentToken.level && tokens[i].type !== 'link_open') {\n          i--\n        }\n        continue\n      }\n\n      // Skip content of html tag links\n      if (currentToken.type === 'html_inline') {\n        if (isLinkOpen(currentToken.content) && htmlLinkLevel > 0) {\n          htmlLinkLevel--\n        }\n        if (isLinkClose(currentToken.content)) {\n          htmlLinkLevel++\n        }\n      }\n      if (htmlLinkLevel > 0) { continue }\n\n      if (currentToken.type === 'text' && state.md.linkify.test(currentToken.content)) {\n        const text = currentToken.content\n        let links = state.md.linkify.match(text)!\n\n        // Now split string to nodes\n        const nodes = []\n        let level = currentToken.level\n        let lastPos = 0\n\n        // forbid escape sequence at the start of the string,\n        // this avoids http\\://example.com/ from being linkified as\n        // http:<a href=\"//example.com/\">//example.com/</a>\n        if (links.length > 0 &&\n            links[0].index === 0 &&\n            i > 0 &&\n            tokens[i - 1].type === 'text_special') {\n          links = links.slice(1)\n        }\n\n        for (let ln = 0; ln < links.length; ln++) {\n          const url = links[ln].url\n          const fullUrl = state.md.normalizeLink(url)\n          if (!state.md.validateLink(fullUrl)) { continue }\n\n          let urlText = links[ln].text\n\n          // Linkifier might send raw hostnames like \"example.com\", where url\n          // starts with domain name. So we prepend http:// in those cases,\n          // and remove it afterwards.\n          //\n          if (!links[ln].schema) {\n            urlText = state.md.normalizeLinkText(`http://${urlText}`).replace(/^http:\\/\\//, '')\n          } else if (links[ln].schema === 'mailto:' && !/^mailto:/i.test(urlText)) {\n            urlText = state.md.normalizeLinkText(`mailto:${urlText}`).replace(/^mailto:/, '')\n          } else {\n            urlText = state.md.normalizeLinkText(urlText)\n          }\n\n          const pos = links[ln].index\n\n          if (pos > lastPos) {\n            const token = new state.Token('text', '', 0)\n            token.content = text.slice(lastPos, pos)\n            token.level = level\n            nodes.push(token)\n          }\n\n          const token_o = new state.Token('link_open', 'a', 1)\n          token_o.attrs = [['href', fullUrl]]\n          token_o.level = level++\n          token_o.markup = 'linkify'\n          token_o.info = 'auto'\n          nodes.push(token_o)\n\n          const token_t = new state.Token('text', '', 0)\n          token_t.content = urlText\n          token_t.level = level\n          nodes.push(token_t)\n\n          const token_c = new state.Token('link_close', 'a', -1)\n          token_c.level = --level\n          token_c.markup = 'linkify'\n          token_c.info = 'auto'\n          nodes.push(token_c)\n\n          lastPos = links[ln].lastIndex\n        }\n        if (lastPos < text.length) {\n          const token = new state.Token('text', '', 0)\n          token.content = text.slice(lastPos)\n          token.level = level\n          nodes.push(token)\n        }\n\n        replacements.push({ index: i, nodes })\n      }\n    }\n\n    if (replacements.length > 0) {\n      let newTokensLength = tokens.length\n      for (const replacement of replacements) {\n        newTokensLength += replacement.nodes.length - 1\n      }\n\n      const newTokens = new Array<(typeof tokens)[number]>(newTokensLength)\n      let replacementIndex = 0\n      let newTokenIndex = 0\n\n      replacements.reverse()\n\n      for (let i = 0; i < tokens.length; i++) {\n        const replacement = replacements[replacementIndex]\n\n        if (replacement?.index === i) {\n          for (const node of replacement.nodes) {\n            newTokens[newTokenIndex++] = node\n          }\n          replacementIndex++\n        } else {\n          newTokens[newTokenIndex++] = tokens[i]\n        }\n      }\n\n      blockTokens[j].children = newTokens\n    }\n  }\n}\n","// Simple typographic replacements\n//\n// (c) (C) → ©\n// (tm) (TM) → ™\n// (r) (R) → ®\n// +- → ±\n// ... → … (also ?.... → ?.., !.... → !..)\n// ???????? → ???, !!!!! → !!!, `,,` → `,`\n// -- → &ndash;, --- → &mdash;\n//\n\n// TODO:\n// - fractionals 1/2, 1/4, 3/4 -> ½, ¼, ¾\n// - multiplications 2 x 4 -> 2 × 4\n\nimport type StateCore from './state_core.ts'\nimport type Token from '../token.ts'\n\nconst RARE_RE = /\\+-|\\.\\.|\\?\\?\\?\\?|!!!!|,,|--/\n\n// Workaround for phantomjs - need regex without /g flag,\n// or root check will fail every second time\nconst SCOPED_ABBR_TEST_RE = /\\((c|tm|r)\\)/i\n\nconst SCOPED_ABBR_RE = /\\((c|tm|r)\\)/ig\nconst SCOPED_ABBR: Record<string, string> = {\n  c: '©',\n  r: '®',\n  tm: '™'\n}\n\nfunction replaceFn (match: string, name: string) {\n  return SCOPED_ABBR[name.toLowerCase()]\n}\n\nfunction replace_scoped (inlineTokens: Token[]) {\n  let inside_autolink = 0\n\n  for (let i = inlineTokens.length - 1; i >= 0; i--) {\n    const token = inlineTokens[i]\n\n    if (token.type === 'text' && !inside_autolink) {\n      token.content = token.content.replace(SCOPED_ABBR_RE, replaceFn)\n    }\n\n    if (token.type === 'link_open' && token.info === 'auto') {\n      inside_autolink--\n    }\n\n    if (token.type === 'link_close' && token.info === 'auto') {\n      inside_autolink++\n    }\n  }\n}\n\nfunction replace_rare (inlineTokens: Token[]) {\n  let inside_autolink = 0\n\n  for (let i = inlineTokens.length - 1; i >= 0; i--) {\n    const token = inlineTokens[i]\n\n    if (token.type === 'text' && !inside_autolink) {\n      if (RARE_RE.test(token.content)) {\n        token.content = token.content\n          .replace(/\\+-/g, '±')\n          // .., ..., ....... -> …\n          // but ?..... & !..... -> ?.. & !..\n          .replace(/\\.{2,}/g, '…').replace(/([?!])…/g, '$1..')\n          .replace(/([?!]){4,}/g, '$1$1$1').replace(/,{2,}/g, ',')\n          // em-dash\n          .replace(/(^|[^-])---(?=[^-]|$)/mg, '$1\\u2014')\n          // en-dash\n          .replace(/(^|\\s)--(?=\\s|$)/mg, '$1\\u2013')\n          .replace(/(^|[^-\\s])--(?=[^-\\s]|$)/mg, '$1\\u2013')\n      }\n    }\n\n    if (token.type === 'link_open' && token.info === 'auto') {\n      inside_autolink--\n    }\n\n    if (token.type === 'link_close' && token.info === 'auto') {\n      inside_autolink++\n    }\n  }\n}\n\nexport default function replace (state: StateCore): void {\n  let blkIdx\n\n  if (!state.md.options.typographer) { return }\n\n  for (blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {\n    if (state.tokens[blkIdx].type !== 'inline') { continue }\n\n    if (SCOPED_ABBR_TEST_RE.test(state.tokens[blkIdx].content)) {\n      replace_scoped(state.tokens[blkIdx].children!)\n    }\n\n    if (RARE_RE.test(state.tokens[blkIdx].content)) {\n      replace_rare(state.tokens[blkIdx].children!)\n    }\n  }\n}\n","// Convert straight quotation marks to typographic ones\n//\n\nimport { isWhiteSpace, isPunctCharCode, isMdAsciiPunct } from '../common/utils.ts'\nimport type Token from '../token.ts'\nimport type StateCore from './state_core.ts'\n\nconst QUOTE_TEST_RE = /['\"]/\nconst QUOTE_RE = /['\"]/g\nconst APOSTROPHE = '\\u2019' /* ’ */\n// Caps memory on malicious input\nconst MAX_OPENERS = 1000\n\ninterface Replacement {\n  pos: number\n  ch: string\n}\n\ntype ReplacementMap = Record<string, Replacement[]>\n\ninterface QuoteOpener {\n  tokenIdx: number\n  contentPos: number\n  isSingleQuote: boolean\n  level: number\n  // stack index of the previous opener of the same quote type, -1 if none\n  prevSameQuoteIdx: number\n}\n\n// stack indexes of topmost openers of each type (-1 if none)\ninterface QuoteHeads {\n  single: number\n  double: number\n}\n\nfunction truncateStack (stack: QuoteOpener[], heads: QuoteHeads, length: number) {\n  while (stack.length > length) {\n    const item = stack.pop()!\n    if (item.isSingleQuote) {\n      heads.single = item.prevSameQuoteIdx\n    } else {\n      heads.double = item.prevSameQuoteIdx\n    }\n  }\n}\n\nfunction addReplacement (\n  replacements: ReplacementMap,\n  tokenIdx: number,\n  pos: number,\n  ch: string\n) {\n  if (!replacements[tokenIdx]) {\n    replacements[tokenIdx] = []\n  }\n\n  replacements[tokenIdx].push({ pos, ch })\n}\n\nfunction applyReplacements (str: string, replacements: Replacement[]) {\n  let result = ''\n  let lastPos = 0\n\n  replacements.sort((a, b) => a.pos - b.pos)\n\n  for (let i = 0; i < replacements.length; i++) {\n    const replacement = replacements[i]\n\n    result += str.slice(lastPos, replacement.pos) + replacement.ch\n    lastPos = replacement.pos + 1\n  }\n\n  return result + str.slice(lastPos)\n}\n\nfunction process_inlines (tokens: Token[], state: StateCore) {\n  let j\n\n  const stack: QuoteOpener[] = []\n  const heads: QuoteHeads = { single: -1, double: -1 }\n  // token index -> list of replacements in the original token content\n  const replacements: ReplacementMap = {}\n\n  for (let i = 0; i < tokens.length; i++) {\n    const token = tokens[i]\n\n    const thisLevel = tokens[i].level\n\n    for (j = stack.length - 1; j >= 0; j--) {\n      if (stack[j].level <= thisLevel) { break }\n    }\n    truncateStack(stack, heads, j + 1)\n\n    if (token.type !== 'text') { continue }\n\n    const text = token.content\n    let pos = 0\n    const max = text.length\n\n    /* eslint no-labels:0,block-scoped-var:0 */\n    OUTER:\n    while (pos < max) {\n      QUOTE_RE.lastIndex = pos\n      const t = QUOTE_RE.exec(text)\n      if (!t) { break }\n\n      let canOpen = true\n      let canClose = true\n      pos = t.index + 1\n      const isSingle = (t[0] === \"'\")\n\n      // Find previous character,\n      // default to space if it's the beginning of the line\n      //\n      let lastChar = 0x20\n\n      if (t.index - 1 >= 0) {\n        lastChar = text.charCodeAt(t.index - 1)\n      } else {\n        for (j = i - 1; j >= 0; j--) {\n          if (tokens[j].type === 'softbreak' || tokens[j].type === 'hardbreak') break // lastChar defaults to 0x20\n          if (!tokens[j].content) continue // should skip all tokens except 'text', 'html_inline' or 'code_inline'\n\n          lastChar = tokens[j].content.charCodeAt(tokens[j].content.length - 1)\n          break\n        }\n      }\n\n      // Find next character,\n      // default to space if it's the end of the line\n      //\n      let nextChar = 0x20\n\n      if (pos < max) {\n        nextChar = text.charCodeAt(pos)\n      } else {\n        for (j = i + 1; j < tokens.length; j++) {\n          if (tokens[j].type === 'softbreak' || tokens[j].type === 'hardbreak') break // nextChar defaults to 0x20\n          if (!tokens[j].content) continue // should skip all tokens except 'text', 'html_inline' or 'code_inline'\n\n          nextChar = tokens[j].content.charCodeAt(0)\n          break\n        }\n      }\n\n      const isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctCharCode(lastChar)\n      const isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctCharCode(nextChar)\n\n      const isLastWhiteSpace = isWhiteSpace(lastChar)\n      const isNextWhiteSpace = isWhiteSpace(nextChar)\n\n      if (isNextWhiteSpace) {\n        canOpen = false\n      } else if (isNextPunctChar) {\n        if (!(isLastWhiteSpace || isLastPunctChar)) {\n          canOpen = false\n        }\n      }\n\n      if (isLastWhiteSpace) {\n        canClose = false\n      } else if (isLastPunctChar) {\n        if (!(isNextWhiteSpace || isNextPunctChar)) {\n          canClose = false\n        }\n      }\n\n      if (nextChar === 0x22 /* \" */ && t[0] === '\"') {\n        if (lastChar >= 0x30 /* 0 */ && lastChar <= 0x39 /* 9 */) {\n          // special case: 1\"\" - count first quote as an inch\n          canClose = canOpen = false\n        }\n      }\n\n      if (canOpen && canClose) {\n        // Replace quotes in the middle of punctuation sequence, but not\n        // in the middle of the words, i.e.:\n        //\n        // 1. foo \" bar \" baz - not replaced\n        // 2. foo-\"-bar-\"-baz - replaced\n        // 3. foo\"bar\"baz     - not replaced\n        //\n        canOpen = isLastPunctChar\n        canClose = isNextPunctChar\n      }\n\n      if (!canOpen && !canClose) {\n        // middle of word\n        if (isSingle) {\n          addReplacement(replacements, i, t.index, APOSTROPHE)\n        }\n        continue\n      }\n\n      if (canClose) {\n        // Stack levels never decrease, so an opener of this type below\n        // the current level means there is no match\n        j = isSingle ? heads.single : heads.double\n        if (j >= 0 && stack[j].level === thisLevel) {\n          const item = stack[j]\n\n          let openQuote\n          let closeQuote\n          if (isSingle) {\n            openQuote = state.md.options.quotes[2]\n            closeQuote = state.md.options.quotes[3]\n          } else {\n            openQuote = state.md.options.quotes[0]\n            closeQuote = state.md.options.quotes[1]\n          }\n\n          addReplacement(replacements, i, t.index, closeQuote)\n          addReplacement(replacements, item.tokenIdx, item.contentPos, openQuote)\n\n          truncateStack(stack, heads, j)\n          continue OUTER\n        }\n      }\n\n      if (canOpen) {\n        if (stack.length >= MAX_OPENERS) { return }\n        stack.push({\n          tokenIdx: i,\n          contentPos: t.index,\n          isSingleQuote: isSingle,\n          level: thisLevel,\n          prevSameQuoteIdx: isSingle ? heads.single : heads.double\n        })\n        if (isSingle) {\n          heads.single = stack.length - 1\n        } else {\n          heads.double = stack.length - 1\n        }\n      } else if (canClose && isSingle) {\n        addReplacement(replacements, i, t.index, APOSTROPHE)\n      }\n    }\n  }\n\n  Object.keys(replacements).forEach(function (tokenIdx) {\n    const idx = Number(tokenIdx)\n    tokens[idx].content = applyReplacements(tokens[idx].content, replacements[tokenIdx])\n  })\n}\n\nexport default function smartquotes (state: StateCore): void {\n  /* eslint max-depth:0 */\n  if (!state.md.options.typographer) { return }\n\n  for (let blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {\n    if (state.tokens[blkIdx].type !== 'inline' ||\n        !QUOTE_TEST_RE.test(state.tokens[blkIdx].content)) {\n      continue\n    }\n\n    process_inlines(state.tokens[blkIdx].children!, state)\n  }\n}\n","// Join raw text tokens with the rest of the text\n//\n// This is set as a separate rule to provide an opportunity for plugins\n// to run text replacements after text join, but before escape join.\n//\n// For example, `\\:)` shouldn't be replaced with an emoji.\n//\n\nimport type StateCore from './state_core.ts'\nimport type Token from '../token.ts'\n\nfunction join_alt (tokens: Token[]): void {\n  let curr, last\n  const max = tokens.length\n\n  for (curr = 0; curr < max; curr++) {\n    if (tokens[curr].type === 'text_special') tokens[curr].type = 'text'\n  }\n\n  for (curr = last = 0; curr < max; curr++) {\n    if (tokens[curr].type === 'text' &&\n        curr + 1 < max &&\n        tokens[curr + 1].type === 'text') {\n      tokens[curr + 1].content = tokens[curr].content + tokens[curr + 1].content\n    } else {\n      if (curr !== last) { tokens[last] = tokens[curr] }\n\n      last++\n    }\n  }\n\n  if (curr !== last) tokens.length = last\n}\n\nexport default function text_join (state: StateCore): void {\n  let curr, last\n  const blockTokens = state.tokens\n  const l = blockTokens.length\n\n  for (let j = 0; j < l; j++) {\n    if (blockTokens[j].type !== 'inline') continue\n\n    const tokens = blockTokens[j].children!\n    const max = tokens.length\n\n    for (curr = 0; curr < max; curr++) {\n      if (tokens[curr].type === 'text_special') tokens[curr].type = 'text'\n\n      // image `alt` is parsed into its own token tree\n      if (tokens[curr].children) join_alt(tokens[curr].children!)\n    }\n\n    for (curr = last = 0; curr < max; curr++) {\n      if (tokens[curr].type === 'text' &&\n          curr + 1 < max &&\n          tokens[curr + 1].type === 'text') {\n        // collapse two adjacent text nodes\n        tokens[curr + 1].content = tokens[curr].content + tokens[curr + 1].content\n      } else {\n        if (curr !== last) { tokens[last] = tokens[curr] }\n\n        last++\n      }\n    }\n\n    if (curr !== last) tokens.length = last\n  }\n}\n","import Ruler from './ruler.ts'\nimport StateCore from './rules_core/state_core.ts'\n\nimport r_normalize from './rules_core/normalize.ts'\nimport r_block from './rules_core/block.ts'\nimport r_strip_references from './rules_core/strip_references.ts'\nimport r_inline from './rules_core/inline.ts'\nimport r_linkify from './rules_core/linkify.ts'\nimport r_replacements from './rules_core/replacements.ts'\nimport r_smartquotes from './rules_core/smartquotes.ts'\nimport r_text_join from './rules_core/text_join.ts'\n\nconst _rules: Array<[\n  name: string,\n  rule: (state: StateCore) => void\n]> = [\n  ['normalize', r_normalize],\n  ['block', r_block],\n  ['strip_references', r_strip_references],\n  ['inline', r_inline],\n  ['linkify', r_linkify],\n  ['replacements', r_replacements],\n  ['smartquotes', r_smartquotes],\n  // `text_join` finds `text_special` tokens (for escape sequences)\n  // and joins them with the rest of the text\n  ['text_join', r_text_join]\n]\n\n/**\n * Top-level rules executor. Glues block/inline parsers and does intermediate\n * transformations.\n */\nclass ParserCore {\n  /**\n   * {@link Ruler} instance. Keep configuration of core rules.\n   */\n  ruler = new Ruler<[StateCore], void>()\n\n  State = StateCore\n\n  constructor () {\n    for (let i = 0; i < _rules.length; i++) {\n      this.ruler.push(_rules[i][0], _rules[i][1])\n    }\n  }\n\n  /**\n   * Executes core chain rules.\n   */\n  process (state: StateCore): void {\n    const rules = this.ruler.getRules('')\n\n    for (let i = 0, l = rules.length; i < l; i++) {\n      rules[i](state)\n    }\n  }\n}\n\nexport default ParserCore\n","import Token from '../token.ts'\nimport { isSpace } from '../common/utils.ts'\nimport type MarkdownIt from '../markdownit.ts'\nimport type { Env } from '../types.ts'\n\n/** Mutable state passed to block rules while tokenizing a source document. */\nclass StateBlock {\n  declare src: string\n  declare md: MarkdownIt\n  declare env: Env\n  declare tokens: Token[]\n\n  bMarks: number[] = [] // line begin offsets for fast jumps\n  eMarks: number[] = [] // line end offsets for fast jumps\n  tShift: number[] = [] // offsets of the first non-space characters (tabs not expanded)\n  sCount: number[] = [] // indents for each line (tabs expanded)\n\n  // An amount of virtual spaces (tabs expanded) between beginning\n  // of each line (bMarks) and real beginning of that line.\n  //\n  // It exists only as a hack because blockquotes override bMarks\n  // losing information in the process.\n  //\n  // It's used only when expanding tabs, you can think about it as\n  // an initial tab length, e.g. bsCount=21 applied to string `\\t123`\n  // means first tab should be expanded to 4-21%4 === 3 spaces.\n  //\n  bsCount: number[] = []\n\n  // block parser variables\n\n  // required block content indent (for example, if we are\n  // inside a list, it would be positioned after list marker)\n  blkIndent = 0\n  line = 0 // line index in src\n  lineMax = 0 // lines count\n  tight = false // loose/tight mode for lists\n  listIndent = -1 // indent of the current list block (-1 if there isn't any)\n\n  // can be 'blockquote', 'list', 'root', 'paragraph' or 'reference'\n  // used in lists to determine if they interrupt a paragraph\n  parentType = 'root'\n\n  level = 0\n\n  // re-export Token class to use in block rules\n  Token = Token\n\n  constructor (src: string, md: MarkdownIt, env: Env, tokens: Token[]) {\n    this.src = src\n\n    // link to parser instance\n    this.md = md\n\n    this.env = env\n\n    //\n    // Internal state vartiables\n    //\n\n    this.tokens = tokens\n\n    // Create caches\n    // Generate markers.\n    const s = this.src\n\n    for (let start = 0, pos = 0, indent = 0, offset = 0, len = s.length, indent_found = false; pos < len; pos++) {\n      const ch = s.charCodeAt(pos)\n\n      if (!indent_found) {\n        if (isSpace(ch)) {\n          indent++\n\n          if (ch === 0x09) {\n            offset += 4 - offset % 4\n          } else {\n            offset++\n          }\n          continue\n        } else {\n          indent_found = true\n        }\n      }\n\n      if (ch === 0x0A || pos === len - 1) {\n        if (ch !== 0x0A) { pos++ }\n        this.bMarks.push(start)\n        this.eMarks.push(pos)\n        this.tShift.push(indent)\n        this.sCount.push(offset)\n        this.bsCount.push(0)\n\n        indent_found = false\n        indent = 0\n        offset = 0\n        start = pos + 1\n      }\n    }\n\n    // Push fake entry to simplify cache bounds checks\n    this.bMarks.push(s.length)\n    this.eMarks.push(s.length)\n    this.tShift.push(0)\n    this.sCount.push(0)\n    this.bsCount.push(0)\n\n    this.lineMax = this.bMarks.length - 1 // don't count last fake line\n  }\n\n  // Push new token to \"stream\".\n  //\n  push (type: string, tag: string, nesting: -1 | 0 | 1): Token {\n    const token = new Token(type, tag, nesting)\n    token.block = true\n\n    if (nesting < 0) this.level-- // closing tag\n    token.level = this.level\n    if (nesting > 0) this.level++ // opening tag\n\n    this.tokens.push(token)\n    return token\n  }\n\n  isEmpty (line: number): boolean {\n    return this.bMarks[line] + this.tShift[line] >= this.eMarks[line]\n  }\n\n  skipEmptyLines (from: number): number {\n    for (let max = this.lineMax; from < max; from++) {\n      if (this.bMarks[from] + this.tShift[from] < this.eMarks[from]) {\n        break\n      }\n    }\n    return from\n  }\n\n  // Skip spaces from given position.\n  skipSpaces (pos: number): number {\n    for (let max = this.src.length; pos < max; pos++) {\n      const ch = this.src.charCodeAt(pos)\n      if (!isSpace(ch)) { break }\n    }\n    return pos\n  }\n\n  // Skip spaces from given position in reverse.\n  skipSpacesBack (pos: number, min: number): number {\n    if (pos <= min) { return pos }\n\n    while (pos > min) {\n      if (!isSpace(this.src.charCodeAt(--pos))) { return pos + 1 }\n    }\n    return pos\n  }\n\n  // Skip char codes from given position\n  skipChars (pos: number, code: number): number {\n    for (let max = this.src.length; pos < max; pos++) {\n      if (this.src.charCodeAt(pos) !== code) { break }\n    }\n    return pos\n  }\n\n  // Skip char codes reverse from given position - 1\n  skipCharsBack (pos: number, code: number, min: number): number {\n    if (pos <= min) { return pos }\n\n    while (pos > min) {\n      if (code !== this.src.charCodeAt(--pos)) { return pos + 1 }\n    }\n    return pos\n  }\n\n  // cut lines range from source.\n  getLines (begin: number, end: number, indent: number, keepLastLF: boolean): string {\n    if (begin >= end) {\n      return ''\n    }\n\n    const queue = new Array(end - begin)\n\n    for (let i = 0, line = begin; line < end; line++, i++) {\n      let lineIndent = 0\n      const lineStart = this.bMarks[line]\n      let first = lineStart\n      let last\n\n      if (line + 1 < end || keepLastLF) {\n        // No need for bounds check because we have fake entry on tail.\n        last = this.eMarks[line] + 1\n      } else {\n        last = this.eMarks[line]\n      }\n\n      while (first < last && lineIndent < indent) {\n        const ch = this.src.charCodeAt(first)\n\n        if (isSpace(ch)) {\n          if (ch === 0x09) {\n            lineIndent += 4 - (lineIndent + this.bsCount[line]) % 4\n          } else {\n            lineIndent++\n          }\n        } else if (first - lineStart < this.tShift[line]) {\n          // patched tShift masked characters to look like spaces (blockquotes, list markers)\n          lineIndent++\n        } else {\n          break\n        }\n\n        first++\n      }\n\n      if (lineIndent > indent) {\n        // partially expanding tabs in code blocks, e.g '\\t\\tfoobar'\n        // with indent=2 becomes '  \\tfoobar'\n        queue[i] = new Array(lineIndent - indent + 1).join(' ') + this.src.slice(first, last)\n      } else {\n        queue[i] = this.src.slice(first, last)\n      }\n    }\n\n    return queue.join('')\n  }\n}\n\nexport default StateBlock\n","// GFM table, https://github.github.com/gfm/#tables-extension-\n\nimport { isSpace } from '../common/utils.ts'\nimport type StateBlock from './state_block.ts'\n\n// Limit the amount of empty autocompleted cells in a table,\n// see https://github.com/markdown-it/markdown-it/issues/1000,\n//\n// Both pulldown-cmark and commonmark-hs limit the number of cells this way to ~200k.\n// We set it to 65k, which can expand user input by a factor of x370\n// (256x256 square is 1.8kB expanded into 650kB).\nconst MAX_AUTOCOMPLETED_CELLS = 0x10000\n\nfunction getLine (state: StateBlock, line: number) {\n  const pos = state.bMarks[line] + state.tShift[line]\n  const max = state.eMarks[line]\n\n  return state.src.slice(pos, max)\n}\n\nfunction escapedSplit (str: string) {\n  const result = []\n  const max = str.length\n\n  let pos = 0\n  let ch = str.charCodeAt(pos)\n  let isEscaped = false\n  let lastPos = 0\n  let current = ''\n\n  while (pos < max) {\n    if (ch === 0x7c/* | */) {\n      if (!isEscaped) {\n        // pipe separating cells, '|'\n        result.push(current + str.substring(lastPos, pos))\n        current = ''\n        lastPos = pos + 1\n      } else {\n        // escaped pipe, '\\|'\n        current += str.substring(lastPos, pos - 1)\n        lastPos = pos\n      }\n    }\n\n    isEscaped = (ch === 0x5c/* \\ */)\n    pos++\n\n    ch = str.charCodeAt(pos)\n  }\n\n  result.push(current + str.substring(lastPos))\n\n  return result\n}\n\nexport default function table (state: StateBlock, startLine: number, endLine: number, silent: boolean): boolean {\n  // should have at least two lines\n  if (startLine + 2 > endLine) { return false }\n\n  let nextLine = startLine + 1\n\n  if (state.sCount[nextLine] < state.blkIndent) { return false }\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[nextLine] - state.blkIndent >= 4) { return false }\n\n  // first character of the second line should be '|', '-', ':',\n  // and no other characters are allowed but spaces;\n  // basically, this is the equivalent of /^[-:|][-:|\\s]*$/ regexp\n\n  let pos = state.bMarks[nextLine] + state.tShift[nextLine]\n  if (pos >= state.eMarks[nextLine]) { return false }\n\n  const firstCh = state.src.charCodeAt(pos++)\n  if (firstCh !== 0x7C/* | */ && firstCh !== 0x2D/* - */ && firstCh !== 0x3A/* : */) { return false }\n\n  if (pos >= state.eMarks[nextLine]) { return false }\n\n  const secondCh = state.src.charCodeAt(pos++)\n  if (secondCh !== 0x7C/* | */ && secondCh !== 0x2D/* - */ && secondCh !== 0x3A/* : */ && !isSpace(secondCh)) {\n    return false\n  }\n\n  // if first character is '-', then second character must not be a space\n  // (due to parsing ambiguity with list)\n  if (firstCh === 0x2D/* - */ && isSpace(secondCh)) { return false }\n\n  while (pos < state.eMarks[nextLine]) {\n    const ch = state.src.charCodeAt(pos)\n\n    if (ch !== 0x7C/* | */ && ch !== 0x2D/* - */ && ch !== 0x3A/* : */ && !isSpace(ch)) { return false }\n\n    pos++\n  }\n\n  let lineText = getLine(state, startLine + 1)\n  let columns = lineText.split('|')\n  const aligns = []\n  for (let i = 0; i < columns.length; i++) {\n    const t = columns[i].trim()\n    if (!t) {\n      // allow empty columns before and after table, but not in between columns;\n      // e.g. allow ` |---| `, disallow ` ---||--- `\n      if (i === 0 || i === columns.length - 1) {\n        continue\n      } else {\n        return false\n      }\n    }\n\n    if (!/^:?-+:?$/.test(t)) { return false }\n    if (t.charCodeAt(t.length - 1) === 0x3A/* : */) {\n      aligns.push(t.charCodeAt(0) === 0x3A/* : */ ? 'center' : 'right')\n    } else if (t.charCodeAt(0) === 0x3A/* : */) {\n      aligns.push('left')\n    } else {\n      aligns.push('')\n    }\n  }\n\n  lineText = getLine(state, startLine).trim()\n  if (lineText.indexOf('|') === -1) { return false }\n  if (state.sCount[startLine] - state.blkIndent >= 4) { return false }\n  columns = escapedSplit(lineText)\n  if (columns.length && columns[0] === '') columns.shift()\n  if (columns.length && columns[columns.length - 1] === '') columns.pop()\n\n  // header row will define an amount of columns in the entire table,\n  // and align row should be exactly the same (the rest of the rows can differ)\n  const columnCount = columns.length\n  if (columnCount === 0 || columnCount !== aligns.length) { return false }\n\n  if (silent) { return true }\n\n  const oldParentType = state.parentType\n  state.parentType = 'table'\n\n  // use 'blockquote' lists for termination because it's\n  // the most similar to tables\n  const terminatorRules = state.md.block.ruler.getRules('blockquote')\n\n  const token_to = state.push('table_open', 'table', 1)\n  const tableLines: [number, number] = [startLine, 0]\n  token_to.map = tableLines\n\n  const token_tho = state.push('thead_open', 'thead', 1)\n  token_tho.map = [startLine, startLine + 1]\n\n  const token_htro = state.push('tr_open', 'tr', 1)\n  token_htro.map = [startLine, startLine + 1]\n\n  for (let i = 0; i < columns.length; i++) {\n    const token_ho = state.push('th_open', 'th', 1)\n    if (aligns[i]) {\n      token_ho.attrs = [['style', `text-align:${aligns[i]}`]]\n    }\n\n    const token_il = state.push('inline', '', 0)\n    token_il.content = columns[i].trim()\n    token_il.children = []\n\n    state.push('th_close', 'th', -1)\n  }\n\n  state.push('tr_close', 'tr', -1)\n  state.push('thead_close', 'thead', -1)\n\n  let tbodyLines: [number, number] | undefined\n  let autocompletedCells = 0\n\n  for (nextLine = startLine + 2; nextLine < endLine; nextLine++) {\n    if (state.sCount[nextLine] < state.blkIndent) { break }\n\n    let terminate = false\n    for (let i = 0, l = terminatorRules.length; i < l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true\n        break\n      }\n    }\n\n    if (terminate) { break }\n    lineText = getLine(state, nextLine).trim()\n    if (!lineText) { break }\n    if (state.sCount[nextLine] - state.blkIndent >= 4) { break }\n    columns = escapedSplit(lineText)\n    if (columns.length && columns[0] === '') columns.shift()\n    if (columns.length && columns[columns.length - 1] === '') columns.pop()\n\n    // note: autocomplete count can be negative if user specifies more columns than header,\n    // but that does not affect intended use (which is limiting expansion)\n    autocompletedCells += columnCount - columns.length\n    if (autocompletedCells > MAX_AUTOCOMPLETED_CELLS) { break }\n\n    if (nextLine === startLine + 2) {\n      const token_tbo = state.push('tbody_open', 'tbody', 1)\n      token_tbo.map = tbodyLines = [startLine + 2, 0]\n    }\n\n    const token_tro = state.push('tr_open', 'tr', 1)\n    token_tro.map = [nextLine, nextLine + 1]\n\n    for (let i = 0; i < columnCount; i++) {\n      const token_tdo = state.push('td_open', 'td', 1)\n      if (aligns[i]) {\n        token_tdo.attrs = [['style', `text-align:${aligns[i]}`]]\n      }\n\n      const token_il = state.push('inline', '', 0)\n      token_il.content = columns[i] ? columns[i].trim() : ''\n      token_il.children = []\n\n      state.push('td_close', 'td', -1)\n    }\n    state.push('tr_close', 'tr', -1)\n  }\n\n  if (tbodyLines) {\n    state.push('tbody_close', 'tbody', -1)\n    tbodyLines[1] = nextLine\n  }\n\n  state.push('table_close', 'table', -1)\n  tableLines[1] = nextLine\n\n  state.parentType = oldParentType\n  state.line = nextLine\n  return true\n}\n","// Code block (4 spaces padded)\n\nimport type StateBlock from './state_block.ts'\n\nexport default function code (state: StateBlock, startLine: number, endLine: number/*, silent */): boolean {\n  if (state.sCount[startLine] - state.blkIndent < 4) { return false }\n\n  let nextLine = startLine + 1\n  let last = nextLine\n\n  while (nextLine < endLine) {\n    if (state.isEmpty(nextLine)) {\n      nextLine++\n      continue\n    }\n\n    if (state.sCount[nextLine] - state.blkIndent >= 4) {\n      nextLine++\n      last = nextLine\n      continue\n    }\n    break\n  }\n\n  state.line = last\n\n  const token = state.push('code_block', 'code', 0)\n  token.content = state.getLines(startLine, last, 4 + state.blkIndent, false) + '\\n'\n  token.map = [startLine, state.line]\n\n  return true\n}\n","// fences (``` lang, ~~~ lang)\n\nimport type StateBlock from './state_block.ts'\n\nexport default function fence (state: StateBlock, startLine: number, endLine: number, silent: boolean): boolean {\n  let pos = state.bMarks[startLine] + state.tShift[startLine]\n  let max = state.eMarks[startLine]\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent >= 4) { return false }\n\n  if (pos + 3 > max) { return false }\n\n  const marker = state.src.charCodeAt(pos)\n\n  if (marker !== 0x7E/* ~ */ && marker !== 0x60 /* ` */) {\n    return false\n  }\n\n  // scan marker length\n  let mem = pos\n  pos = state.skipChars(pos, marker)\n\n  let len = pos - mem\n\n  if (len < 3) { return false }\n\n  const markup = state.src.slice(mem, pos)\n  const params = state.src.slice(pos, max)\n\n  if (marker === 0x60 /* ` */) {\n    if (params.indexOf(String.fromCharCode(marker)) >= 0) {\n      return false\n    }\n  }\n\n  // Since start is found, we can report success here in validation mode\n  if (silent) { return true }\n\n  // search end of block\n  let nextLine = startLine\n  let haveEndMarker = false\n\n  for (;;) {\n    nextLine++\n    if (nextLine >= endLine) {\n      // unclosed block should be autoclosed by end of document.\n      // also block seems to be autoclosed by end of parent\n      break\n    }\n\n    pos = mem = state.bMarks[nextLine] + state.tShift[nextLine]\n    max = state.eMarks[nextLine]\n\n    if (pos < max && state.sCount[nextLine] < state.blkIndent) {\n      // non-empty line with negative indent should stop the list:\n      // - ```\n      //  test\n      break\n    }\n\n    if (state.src.charCodeAt(pos) !== marker) { continue }\n\n    if (state.sCount[nextLine] - state.blkIndent >= 4) {\n      // closing fence should be indented less than 4 spaces\n      continue\n    }\n\n    pos = state.skipChars(pos, marker)\n\n    // closing code fence must be at least as long as the opening one\n    if (pos - mem < len) { continue }\n\n    // make sure tail has spaces only\n    pos = state.skipSpaces(pos)\n\n    if (pos < max) { continue }\n\n    haveEndMarker = true\n    // found!\n    break\n  }\n\n  // If a fence has heading spaces, they should be removed from its inner block\n  len = state.sCount[startLine]\n\n  state.line = nextLine + (haveEndMarker ? 1 : 0)\n\n  const token = state.push('fence', 'code', 0)\n  token.info = params\n  token.content = state.getLines(startLine + 1, nextLine, len, true)\n  token.markup = markup\n  token.map = [startLine, state.line]\n\n  return true\n}\n","// Block quotes\n\nimport { isSpace } from '../common/utils.ts'\nimport type StateBlock from './state_block.ts'\n\nexport default function blockquote (state: StateBlock, startLine: number, endLine: number, silent: boolean): boolean {\n  let pos = state.bMarks[startLine] + state.tShift[startLine]\n  let max = state.eMarks[startLine]\n\n  const oldLineMax = state.lineMax\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent >= 4) { return false }\n\n  // check the block quote marker\n  if (state.src.charCodeAt(pos) !== 0x3E/* > */) { return false }\n\n  // we know that it's going to be a valid blockquote,\n  // so no point trying to find the end of it in silent mode\n  if (silent) { return true }\n\n  const oldBMarks = []\n  const oldBSCount = []\n  const oldSCount = []\n  const oldTShift = []\n\n  const terminatorRules = state.md.block.ruler.getRules('blockquote')\n\n  const oldParentType = state.parentType\n  state.parentType = 'blockquote'\n  let lastLineEmpty = false\n  let nextLine\n\n  // Search the end of the block\n  //\n  // Block ends with either:\n  //  1. an empty line outside:\n  //     ```\n  //     > test\n  //\n  //     ```\n  //  2. an empty line inside:\n  //     ```\n  //     >\n  //     test\n  //     ```\n  //  3. another tag:\n  //     ```\n  //     > test\n  //      - - -\n  //     ```\n  for (nextLine = startLine; nextLine < endLine; nextLine++) {\n    // check if it's outdented, i.e. it's inside list item and indented\n    // less than said list item:\n    //\n    // ```\n    // 1. anything\n    //    > current blockquote\n    // 2. checking this line\n    // ```\n    const isOutdented = state.sCount[nextLine] < state.blkIndent\n\n    pos = state.bMarks[nextLine] + state.tShift[nextLine]\n    max = state.eMarks[nextLine]\n\n    if (pos >= max) {\n      // Case 1: line is not inside the blockquote, and this line is empty.\n      break\n    }\n\n    if (state.src.charCodeAt(pos++) === 0x3E/* > */ && !isOutdented) {\n      // This line is inside the blockquote.\n\n      // set offset past spaces and \">\"\n      let initial = state.sCount[nextLine] + 1\n      let spaceAfterMarker\n      let adjustTab\n\n      // skip one optional space after '>'\n      if (state.src.charCodeAt(pos) === 0x20 /* space */) {\n        // ' >   test '\n        //     ^ -- position start of line here:\n        pos++\n        initial++\n        adjustTab = false\n        spaceAfterMarker = true\n      } else if (state.src.charCodeAt(pos) === 0x09 /* tab */) {\n        spaceAfterMarker = true\n\n        if ((state.bsCount[nextLine] + initial) % 4 === 3) {\n          // '  >\\t  test '\n          //       ^ -- position start of line here (tab has width===1)\n          pos++\n          initial++\n          adjustTab = false\n        } else {\n          // ' >\\t  test '\n          //    ^ -- position start of line here + shift bsCount slightly\n          //         to make extra space appear\n          adjustTab = true\n        }\n      } else {\n        spaceAfterMarker = false\n      }\n\n      let offset = initial\n      oldBMarks.push(state.bMarks[nextLine])\n      state.bMarks[nextLine] = pos\n\n      while (pos < max) {\n        const ch = state.src.charCodeAt(pos)\n\n        if (isSpace(ch)) {\n          if (ch === 0x09) {\n            offset += 4 - (offset + state.bsCount[nextLine] + (adjustTab ? 1 : 0)) % 4\n          } else {\n            offset++\n          }\n        } else {\n          break\n        }\n\n        pos++\n      }\n\n      lastLineEmpty = pos >= max\n\n      oldBSCount.push(state.bsCount[nextLine])\n      state.bsCount[nextLine] = state.sCount[nextLine] + 1 + (spaceAfterMarker ? 1 : 0)\n\n      oldSCount.push(state.sCount[nextLine])\n      state.sCount[nextLine] = offset - initial\n\n      oldTShift.push(state.tShift[nextLine])\n      state.tShift[nextLine] = pos - state.bMarks[nextLine]\n      continue\n    }\n\n    // Case 2: line is not inside the blockquote, and the last line was empty.\n    if (lastLineEmpty) { break }\n\n    // Case 3: another tag found.\n    let terminate = false\n    for (let i = 0, l = terminatorRules.length; i < l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true\n        break\n      }\n    }\n\n    if (terminate) {\n      // Quirk to enforce \"hard termination mode\" for paragraphs;\n      // normally if you call `tokenize(state, startLine, nextLine)`,\n      // paragraphs will look below nextLine for paragraph continuation,\n      // but if blockquote is terminated by another tag, they shouldn't\n      state.lineMax = nextLine\n\n      if (state.blkIndent !== 0) {\n        // state.blkIndent was non-zero, we now set it to zero,\n        // so we need to re-calculate all offsets to appear as\n        // if indent wasn't changed\n        oldBMarks.push(state.bMarks[nextLine])\n        oldBSCount.push(state.bsCount[nextLine])\n        oldTShift.push(state.tShift[nextLine])\n        oldSCount.push(state.sCount[nextLine])\n        state.sCount[nextLine] -= state.blkIndent\n      }\n\n      break\n    }\n\n    oldBMarks.push(state.bMarks[nextLine])\n    oldBSCount.push(state.bsCount[nextLine])\n    oldTShift.push(state.tShift[nextLine])\n    oldSCount.push(state.sCount[nextLine])\n\n    // A negative indentation means that this is a paragraph continuation\n    //\n    state.sCount[nextLine] = -1\n  }\n\n  const oldIndent = state.blkIndent\n  state.blkIndent = 0\n\n  const token_o = state.push('blockquote_open', 'blockquote', 1)\n  token_o.markup = '>'\n  const lines: [number, number] = [startLine, 0]\n  token_o.map = lines\n\n  state.md.block.tokenize(state, startLine, nextLine)\n\n  const token_c = state.push('blockquote_close', 'blockquote', -1)\n  token_c.markup = '>'\n\n  state.lineMax = oldLineMax\n  state.parentType = oldParentType\n  lines[1] = state.line\n\n  // Restore original tShift; this might not be necessary since the parser\n  // has already been here, but just to make sure we can do that.\n  for (let i = 0; i < oldTShift.length; i++) {\n    state.bMarks[i + startLine] = oldBMarks[i]\n    state.tShift[i + startLine] = oldTShift[i]\n    state.sCount[i + startLine] = oldSCount[i]\n    state.bsCount[i + startLine] = oldBSCount[i]\n  }\n  state.blkIndent = oldIndent\n\n  return true\n}\n","// Horizontal rule\n\nimport { isSpace } from '../common/utils.ts'\nimport type StateBlock from './state_block.ts'\n\nexport default function hr (state: StateBlock, startLine: number, endLine: number, silent: boolean): boolean {\n  const max = state.eMarks[startLine]\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent >= 4) { return false }\n\n  let pos = state.bMarks[startLine] + state.tShift[startLine]\n  const marker = state.src.charCodeAt(pos++)\n\n  // Check hr marker\n  if (marker !== 0x2A/* * */ &&\n      marker !== 0x2D/* - */ &&\n      marker !== 0x5F/* _ */) {\n    return false\n  }\n\n  // markers can be mixed with spaces, but there should be at least 3 of them\n\n  let cnt = 1\n  while (pos < max) {\n    const ch = state.src.charCodeAt(pos++)\n    if (ch !== marker && !isSpace(ch)) { return false }\n    if (ch === marker) { cnt++ }\n  }\n\n  if (cnt < 3) { return false }\n\n  if (silent) { return true }\n\n  state.line = startLine + 1\n\n  const token = state.push('hr', 'hr', 0)\n  token.map = [startLine, state.line]\n  token.markup = Array(cnt + 1).join(String.fromCharCode(marker))\n\n  return true\n}\n","// Lists\n\nimport { isSpace } from '../common/utils.ts'\nimport type StateBlock from './state_block.ts'\n\n// Search `[-+*][\\n ]`, returns next pos after marker on success\n// or -1 on fail.\nfunction skipBulletListMarker (state: StateBlock, startLine: number) {\n  const max = state.eMarks[startLine]\n  let pos = state.bMarks[startLine] + state.tShift[startLine]\n\n  const marker = state.src.charCodeAt(pos++)\n  // Check bullet\n  if (marker !== 0x2A/* * */ &&\n      marker !== 0x2D/* - */ &&\n      marker !== 0x2B/* + */) {\n    return -1\n  }\n\n  if (pos < max) {\n    const ch = state.src.charCodeAt(pos)\n\n    if (!isSpace(ch)) {\n      // \" -test \" - is not a list item\n      return -1\n    }\n  }\n\n  return pos\n}\n\n// Search `\\d+[.)][\\n ]`, returns next pos after marker on success\n// or -1 on fail.\nfunction skipOrderedListMarker (state: StateBlock, startLine: number) {\n  const start = state.bMarks[startLine] + state.tShift[startLine]\n  const max = state.eMarks[startLine]\n  let pos = start\n\n  // List marker should have at least 2 chars (digit + dot)\n  if (pos + 1 >= max) { return -1 }\n\n  let ch = state.src.charCodeAt(pos++)\n\n  if (ch < 0x30/* 0 */ || ch > 0x39/* 9 */) { return -1 }\n\n  for (;;) {\n    // EOL -> fail\n    if (pos >= max) { return -1 }\n\n    ch = state.src.charCodeAt(pos++)\n\n    if (ch >= 0x30/* 0 */ && ch <= 0x39/* 9 */) {\n      // List marker should have no more than 9 digits\n      // (prevents integer overflow in browsers)\n      if (pos - start >= 10) { return -1 }\n\n      continue\n    }\n\n    // found valid marker\n    if (ch === 0x29/* ) */ || ch === 0x2e/* . */) {\n      break\n    }\n\n    return -1\n  }\n\n  if (pos < max) {\n    ch = state.src.charCodeAt(pos)\n\n    if (!isSpace(ch)) {\n      // \" 1.test \" - is not a list item\n      return -1\n    }\n  }\n  return pos\n}\n\nfunction markTightParagraphs (state: StateBlock, idx: number) {\n  const level = state.level + 2\n\n  for (let i = idx + 2, l = state.tokens.length - 2; i < l; i++) {\n    if (state.tokens[i].level === level && state.tokens[i].type === 'paragraph_open') {\n      state.tokens[i + 2].hidden = true\n      state.tokens[i].hidden = true\n      i += 2\n    }\n  }\n}\n\nexport default function list (state: StateBlock, startLine: number, endLine: number, silent: boolean): boolean {\n  let max, pos, start, token\n  let nextLine = startLine\n  let tight = true\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[nextLine] - state.blkIndent >= 4) { return false }\n\n  // Special case:\n  //  - item 1\n  //   - item 2\n  //    - item 3\n  //     - item 4\n  //      - this one is a paragraph continuation\n  if (state.listIndent >= 0 &&\n      state.sCount[nextLine] - state.listIndent >= 4 &&\n      state.sCount[nextLine] < state.blkIndent) {\n    return false\n  }\n\n  let isTerminatingParagraph = false\n\n  // limit conditions when list can interrupt\n  // a paragraph (validation mode only)\n  if (silent && state.parentType === 'paragraph') {\n    // Next list item should still terminate previous list item;\n    //\n    // This code can fail if plugins use blkIndent as well as lists,\n    // but I hope the spec gets fixed long before that happens.\n    //\n    if (state.sCount[nextLine] >= state.blkIndent) {\n      isTerminatingParagraph = true\n    }\n  }\n\n  // Detect list type and position after marker\n  let isOrdered\n  let markerValue\n  let posAfterMarker\n  if ((posAfterMarker = skipOrderedListMarker(state, nextLine)) >= 0) {\n    isOrdered = true\n    start = state.bMarks[nextLine] + state.tShift[nextLine]\n    markerValue = Number(state.src.slice(start, posAfterMarker - 1))\n\n    // If we're starting a new ordered list right after\n    // a paragraph, it should start with 1.\n    if (isTerminatingParagraph && markerValue !== 1) return false\n  } else if ((posAfterMarker = skipBulletListMarker(state, nextLine)) >= 0) {\n    isOrdered = false\n  } else {\n    return false\n  }\n\n  // If we're starting a new unordered list right after\n  // a paragraph, first line should not be empty.\n  if (isTerminatingParagraph) {\n    if (state.skipSpaces(posAfterMarker) >= state.eMarks[nextLine]) return false\n  }\n\n  // For validation mode we can terminate immediately\n  if (silent) { return true }\n\n  // We should terminate list on style change. Remember first one to compare.\n  const markerCharCode = state.src.charCodeAt(posAfterMarker - 1)\n\n  // Start list\n  const listTokIdx = state.tokens.length\n\n  if (isOrdered) {\n    token = state.push('ordered_list_open', 'ol', 1)\n    if (markerValue !== 1) {\n      token.attrs = [['start', markerValue!]]\n    }\n  } else {\n    token = state.push('bullet_list_open', 'ul', 1)\n  }\n\n  const listLines: [number, number] = [nextLine, 0]\n  token.map = listLines\n  token.markup = String.fromCharCode(markerCharCode)\n\n  //\n  // Iterate list items\n  //\n\n  let prevEmptyEnd = false\n  const terminatorRules = state.md.block.ruler.getRules('list')\n\n  const oldParentType = state.parentType\n  state.parentType = 'list'\n\n  while (nextLine < endLine) {\n    pos = posAfterMarker\n    max = state.eMarks[nextLine]\n\n    const initial = state.sCount[nextLine] + posAfterMarker - (state.bMarks[nextLine] + state.tShift[nextLine])\n    let offset = initial\n\n    while (pos < max) {\n      const ch = state.src.charCodeAt(pos)\n\n      if (ch === 0x09) {\n        offset += 4 - (offset + state.bsCount[nextLine]) % 4\n      } else if (ch === 0x20) {\n        offset++\n      } else {\n        break\n      }\n\n      pos++\n    }\n\n    const contentStart = pos\n    let indentAfterMarker\n\n    if (contentStart >= max) {\n      // trimming space in \"-    \\n  3\" case, indent is 1 here\n      indentAfterMarker = 1\n    } else {\n      indentAfterMarker = offset - initial\n    }\n\n    // If we have more than 4 spaces, the indent is 1\n    // (the rest is just indented code block)\n    if (indentAfterMarker > 4) { indentAfterMarker = 1 }\n\n    // \"  -  test\"\n    //  ^^^^^ - calculating total length of this thing\n    const indent = initial + indentAfterMarker\n\n    // Run subparser & write tokens\n    token = state.push('list_item_open', 'li', 1)\n    token.markup = String.fromCharCode(markerCharCode)\n    const itemLines: [number, number] = [nextLine, 0]\n    token.map = itemLines\n    if (isOrdered) {\n      token.info = state.src.slice(start, posAfterMarker - 1)\n    }\n\n    // change current state, then restore it after parser subcall\n    const oldTight = state.tight\n    const oldTShift = state.tShift[nextLine]\n    const oldSCount = state.sCount[nextLine]\n\n    //  - example list\n    // ^ listIndent position will be here\n    //   ^ blkIndent position will be here\n    //\n    const oldListIndent = state.listIndent\n    state.listIndent = state.blkIndent\n    state.blkIndent = indent\n\n    state.tight = true\n    state.tShift[nextLine] = contentStart - state.bMarks[nextLine]\n    state.sCount[nextLine] = offset\n\n    if (contentStart >= max && state.isEmpty(nextLine + 1)) {\n      // workaround for this case\n      // (list item is empty, list terminates before \"foo\"):\n      // ~~~~~~~~\n      //   -\n      //\n      //     foo\n      // ~~~~~~~~\n      state.line = Math.min(state.line + 2, endLine)\n    } else {\n      state.md.block.tokenize(state, nextLine, endLine)\n    }\n\n    // If any of list item is tight, mark list as tight\n    if (!state.tight || prevEmptyEnd) {\n      tight = false\n    }\n    // Item become loose if finish with empty line,\n    // but we should filter last element, because it means list finish\n    prevEmptyEnd = (state.line - nextLine) > 1 && state.isEmpty(state.line - 1)\n\n    state.blkIndent = state.listIndent\n    state.listIndent = oldListIndent\n    state.tShift[nextLine] = oldTShift\n    state.sCount[nextLine] = oldSCount\n    state.tight = oldTight\n\n    token = state.push('list_item_close', 'li', -1)\n    token.markup = String.fromCharCode(markerCharCode)\n\n    nextLine = state.line\n    itemLines[1] = nextLine\n\n    if (nextLine >= endLine) { break }\n\n    //\n    // Try to check if list is terminated or continued.\n    //\n    if (state.sCount[nextLine] < state.blkIndent) { break }\n\n    // if it's indented more than 3 spaces, it should be a code block\n    if (state.sCount[nextLine] - state.blkIndent >= 4) { break }\n\n    // fail if terminating block found\n    let terminate = false\n    for (let i = 0, l = terminatorRules.length; i < l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true\n        break\n      }\n    }\n    if (terminate) { break }\n\n    // fail if list has another type\n    if (isOrdered) {\n      posAfterMarker = skipOrderedListMarker(state, nextLine)\n      if (posAfterMarker < 0) { break }\n      start = state.bMarks[nextLine] + state.tShift[nextLine]\n    } else {\n      posAfterMarker = skipBulletListMarker(state, nextLine)\n      if (posAfterMarker < 0) { break }\n    }\n\n    if (markerCharCode !== state.src.charCodeAt(posAfterMarker - 1)) { break }\n  }\n\n  // Finalize list\n  if (isOrdered) {\n    token = state.push('ordered_list_close', 'ol', -1)\n  } else {\n    token = state.push('bullet_list_close', 'ul', -1)\n  }\n  token.markup = String.fromCharCode(markerCharCode)\n\n  listLines[1] = nextLine\n  state.line = nextLine\n\n  state.parentType = oldParentType\n\n  // mark paragraphs tight if needed\n  if (tight) {\n    markTightParagraphs(state, listTokIdx)\n  }\n\n  return true\n}\n","import { isSpace, normalizeReference } from '../common/utils.ts'\nimport type StateBlock from './state_block.ts'\n\n// CommonMark limits reference labels to 999 Unicode code points.\nconst MAX_LABEL_LENGTH = 999\n\nfunction countCodePoints (str: string) {\n  let length = str.length\n\n  for (let i = 0; i < str.length - 1; i++) {\n    const high = str.charCodeAt(i)\n    if (high < 0xD800 || high > 0xDBFF) { continue }\n\n    const low = str.charCodeAt(i + 1)\n    if (low >= 0xDC00 && low <= 0xDFFF) {\n      length--\n      i++\n    }\n  }\n\n  return length\n}\n\n// Exclusive end offset of the line, after its newline if present\nfunction lineEnd (state: StateBlock, line: number) {\n  return Math.min(state.eMarks[line] + 1, state.src.length)\n}\n\n// Returns -1 if the reference can't continue on this line\nfunction getNextLinePos (state: StateBlock, nextLine: number) {\n  const endLine = state.lineMax\n\n  if (nextLine >= endLine || state.isEmpty(nextLine)) {\n    // empty line or end of input\n    return -1\n  }\n\n  let isContinuation = false\n\n  // this would be a code block normally, but after paragraph\n  // it's considered a lazy continuation regardless of what's there\n  if (state.sCount[nextLine] - state.blkIndent > 3) { isContinuation = true }\n\n  // quirk for blockquotes, this line should already be checked by that rule\n  if (state.sCount[nextLine] < 0) { isContinuation = true }\n\n  if (!isContinuation) {\n    const terminatorRules = state.md.block.ruler.getRules('reference')\n    const oldParentType = state.parentType\n    state.parentType = 'reference'\n\n    // Some tags can terminate paragraph without empty line.\n    let terminate = false\n    for (let i = 0, l = terminatorRules.length; i < l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true\n        break\n      }\n    }\n\n    state.parentType = oldParentType\n    if (terminate) {\n      // terminated by another block\n      return -1\n    }\n  }\n\n  return state.bMarks[nextLine] + state.tShift[nextLine]\n}\n\nexport default function reference (state: StateBlock, startLine: number, _endLine: number, silent: boolean): boolean {\n  const src = state.src\n  let pos = state.bMarks[startLine] + state.tShift[startLine]\n  let nextLine = startLine + 1\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent >= 4) { return false }\n\n  if (src.charCodeAt(pos) !== 0x5B/* [ */) { return false }\n\n  // Scan the source directly: indexing a string after each appended line\n  // can make V8 copy the accumulated prefix on every continuation.\n  let max = lineEnd(state, startLine)\n\n  let rawLabel = ''\n  let labelEnd = -1\n  let segmentStart = ++pos\n\n  while (pos < max) {\n    if (rawLabel.length + pos - segmentStart > MAX_LABEL_LENGTH * 2) { return false }\n\n    let ch = src.charCodeAt(pos)\n    if (ch === 0x5B /* [ */) { return false }\n    if (ch === 0x5D /* ] */) {\n      labelEnd = pos\n      break\n    }\n    if (ch === 0x5C /* \\ */) { ch = src.charCodeAt(++pos) }\n\n    if (ch === 0x0A /* \\n */ && pos < max) {\n      const nextPos = getNextLinePos(state, nextLine)\n      if (nextPos < 0) { return false }\n      rawLabel += src.slice(segmentStart, max)\n      pos = segmentStart = nextPos\n      max = lineEnd(state, nextLine++)\n      continue\n    }\n    pos++\n  }\n\n  if (labelEnd < 0 || src.charCodeAt(labelEnd + 1) !== 0x3A/* : */) { return false }\n\n  rawLabel += src.slice(segmentStart, labelEnd)\n\n  if (rawLabel.length > MAX_LABEL_LENGTH && countCodePoints(rawLabel) > MAX_LABEL_LENGTH) {\n    return false\n  }\n\n  // [label]:   destination   'title'\n  //         ^^^ skip optional whitespace here\n  pos = labelEnd + 2\n  while (pos < max) {\n    const ch = src.charCodeAt(pos)\n    if (ch === 0x0A) {\n      const nextPos = getNextLinePos(state, nextLine)\n      if (nextPos < 0) { break }\n      pos = nextPos\n      max = lineEnd(state, nextLine++)\n    } else if (isSpace(ch)) {\n      pos++\n    } else {\n      break\n    }\n  }\n\n  // [label]:   destination   'title'\n  //            ^^^^^^^^^^^ parse this\n  const destRes = state.md.helpers.parseLinkDestination(src, pos, max)\n  if (!destRes.ok) { return false }\n\n  const href = state.md.normalizeLink(destRes.str)\n  if (!state.md.validateLink(href)) { return false }\n\n  pos = destRes.pos\n\n  // save cursor state, we could require to rollback later\n  const destEndPos = pos\n  const destEndMax = max\n  const destEndLineNo = nextLine\n\n  // [label]:   destination   'title'\n  //                       ^^^ skipping those spaces\n  while (pos < max) {\n    const ch = src.charCodeAt(pos)\n    if (ch === 0x0A) {\n      const nextPos = getNextLinePos(state, nextLine)\n      if (nextPos < 0) { break }\n      pos = nextPos\n      max = lineEnd(state, nextLine++)\n    } else if (isSpace(ch)) {\n      pos++\n    } else {\n      break\n    }\n  }\n\n  // [label]:   destination   'title'\n  //                          ^^^^^^^ parse this\n  const titleStart = pos\n  let titleRes = state.md.helpers.parseLinkTitle(src, pos, max)\n  while (titleRes.can_continue) {\n    const nextPos = getNextLinePos(state, nextLine)\n    if (nextPos < 0) break\n    pos = nextPos\n    max = lineEnd(state, nextLine++)\n    titleRes = state.md.helpers.parseLinkTitle(src, pos, max, titleRes)\n  }\n  let title\n\n  if (titleStart !== destEndPos && titleRes.ok) {\n    title = titleRes.str\n    pos = titleRes.pos\n  } else {\n    title = ''\n    pos = destEndPos\n    max = destEndMax\n    nextLine = destEndLineNo\n  }\n\n  // skip trailing spaces until the rest of the line\n  while (pos < max) {\n    const ch = src.charCodeAt(pos)\n    if (!isSpace(ch)) { break }\n    pos++\n  }\n\n  if (pos < max && src.charCodeAt(pos) !== 0x0A) {\n    if (title) {\n      // garbage at the end of the line after title,\n      // but it could still be a valid reference if we roll back\n      title = ''\n      pos = destEndPos\n      max = destEndMax\n      nextLine = destEndLineNo\n      while (pos < max) {\n        const ch = src.charCodeAt(pos)\n        if (!isSpace(ch)) { break }\n        pos++\n      }\n    }\n  }\n\n  if (pos < max && src.charCodeAt(pos) !== 0x0A) {\n    // garbage at the end of the line\n    return false\n  }\n\n  const label = normalizeReference(rawLabel)\n  if (!label) {\n    // CommonMark 0.20 disallows empty labels\n    return false\n  }\n\n  // Reference can not terminate anything. This check is for safety only.\n  /* istanbul ignore if */\n  if (silent) { return true }\n\n  if (typeof state.env.references === 'undefined') {\n    state.env.references = {}\n  }\n  if (typeof state.env.references[label] === 'undefined') {\n    state.env.references[label] = { title, href }\n  }\n\n  // Marks the place definition took in the source. Renders to nothing,\n  // href/title stay in `env.references`.\n  const token = state.push('reference_definition', '', 0)\n  token.map = [startLine, nextLine]\n  token.hidden = true\n\n  const meta: Record<string, unknown> = Object.create(null)\n  meta.label = label\n  token.meta = meta\n\n  state.line = nextLine\n  return true\n}\n","// List of valid html blocks names, according to commonmark spec\n// https://spec.commonmark.org/0.30/#html-blocks\n\nexport default [\n  'address',\n  'article',\n  'aside',\n  'base',\n  'basefont',\n  'blockquote',\n  'body',\n  'caption',\n  'center',\n  'col',\n  'colgroup',\n  'dd',\n  'details',\n  'dialog',\n  'dir',\n  'div',\n  'dl',\n  'dt',\n  'fieldset',\n  'figcaption',\n  'figure',\n  'footer',\n  'form',\n  'frame',\n  'frameset',\n  'h1',\n  'h2',\n  'h3',\n  'h4',\n  'h5',\n  'h6',\n  'head',\n  'header',\n  'hr',\n  'html',\n  'iframe',\n  'legend',\n  'li',\n  'link',\n  'main',\n  'menu',\n  'menuitem',\n  'nav',\n  'noframes',\n  'ol',\n  'optgroup',\n  'option',\n  'p',\n  'param',\n  'search',\n  'section',\n  'summary',\n  'table',\n  'tbody',\n  'td',\n  'tfoot',\n  'th',\n  'thead',\n  'title',\n  'tr',\n  'track',\n  'ul'\n]\n","// Regexps to match html elements\n\nconst attr_name = '[a-zA-Z_:][a-zA-Z0-9:._-]*'\n\nconst unquoted = '[^\"\\'=<>`\\\\x00-\\\\x20]+'\nconst single_quoted = \"'[^']*'\"\nconst double_quoted = '\"[^\"]*\"'\n\nconst attr_value = `(?:${unquoted}|${single_quoted}|${double_quoted})`\n\nconst attribute = `(?:\\\\s+${attr_name}(?:\\\\s*=\\\\s*${attr_value})?)`\n\nconst open_tag = `<[A-Za-z][A-Za-z0-9\\\\-]*${attribute}*\\\\s*\\\\/?>`\n\nconst close_tag = '<\\\\/[A-Za-z][A-Za-z0-9\\\\-]*\\\\s*>'\nconst comment = '<!---?>|<!--(?:[^-]|-[^-]|--[^>])*-->'\nconst processing = '<[?][\\\\s\\\\S]*?[?]>'\nconst declaration = '<![A-Za-z][^>]*>'\nconst cdata = '<!\\\\[CDATA\\\\[[\\\\s\\\\S]*?\\\\]\\\\]>'\n\n/** @deprecated Will be removed in future versions. */\nconst HTML_TAG_RE = new RegExp(\n  `^(?:${open_tag}|${close_tag}|${comment}|${processing}|${declaration}|${cdata})`\n)\nconst HTML_OPEN_CLOSE_TAG_RE = new RegExp(`^(?:${open_tag}|${close_tag})`)\n\nexport { HTML_TAG_RE, HTML_OPEN_CLOSE_TAG_RE }\n","// HTML block\n\nimport block_names from '../common/html_blocks.ts'\nimport { HTML_OPEN_CLOSE_TAG_RE } from '../common/html_re.ts'\nimport type StateBlock from './state_block.ts'\n\n// An array of opening and corresponding closing sequences for html tags,\n// last argument defines whether it can terminate a paragraph or not\n//\nconst HTML_SEQUENCES: Array<[\n  open: RegExp,\n  close: RegExp,\n  canTerminateParagraph: boolean\n]> = [\n  [/^<(script|pre|style|textarea)(?=(\\s|>|$))/i, /<\\/(script|pre|style|textarea)>/i, true],\n  [/^<!--/, /-->/, true],\n  [/^<\\?/, /\\?>/, true],\n  [/^<![A-Za-z]/, />/, true],\n  [/^<!\\[CDATA\\[/, /\\]\\]>/, true],\n  [new RegExp(`^</?(${block_names.join('|')})(?=(\\\\s|/?>|$))`, 'i'), /^$/, true],\n  [new RegExp(`${HTML_OPEN_CLOSE_TAG_RE.source}\\\\s*$`), /^$/, false]\n]\n\nexport default function html_block (state: StateBlock, startLine: number, endLine: number, silent: boolean): boolean {\n  let pos = state.bMarks[startLine] + state.tShift[startLine]\n  let max = state.eMarks[startLine]\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent >= 4) { return false }\n\n  if (!state.md.options.html) { return false }\n\n  if (state.src.charCodeAt(pos) !== 0x3C/* < */) { return false }\n\n  let lineText = state.src.slice(pos, max)\n\n  let i = 0\n  for (; i < HTML_SEQUENCES.length; i++) {\n    if (HTML_SEQUENCES[i][0].test(lineText)) { break }\n  }\n  if (i === HTML_SEQUENCES.length) { return false }\n\n  if (silent) {\n    // true if this sequence can be a terminator, false otherwise\n    return HTML_SEQUENCES[i][2]\n  }\n\n  let nextLine = startLine + 1\n\n  // Block types 6 and 7 (the only ones whose end condition is a blank line)\n  // have `/^$/` as their closing regexp. For all other types (1-5, e.g.\n  // `<!--` comments), a blank line is regular content and must not terminate\n  // the block - it ends only when its closing sequence is found.\n  const endsOnBlankLine = HTML_SEQUENCES[i][1].test('')\n\n  // If we are here - we detected HTML block.\n  // Let's roll down till block end.\n  if (!HTML_SEQUENCES[i][1].test(lineText)) {\n    for (; nextLine < endLine; nextLine++) {\n      if (state.sCount[nextLine] < state.blkIndent) {\n        // An outdented blank line shouldn't end a block that doesn't end on a\n        // blank line (e.g. a `<!--` comment inside a list item). Such blocks\n        // must continue until their closing sequence regardless of indent.\n        if (endsOnBlankLine || !state.isEmpty(nextLine)) { break }\n      }\n\n      pos = state.bMarks[nextLine] + state.tShift[nextLine]\n      max = state.eMarks[nextLine]\n      lineText = state.src.slice(pos, max)\n\n      if (HTML_SEQUENCES[i][1].test(lineText)) {\n        if (lineText.length !== 0) { nextLine++ }\n        break\n      }\n    }\n  }\n\n  state.line = nextLine\n\n  const token = state.push('html_block', '', 0)\n  token.map = [startLine, nextLine]\n  token.content = state.getLines(startLine, nextLine, state.blkIndent, true)\n\n  return true\n}\n","// heading (#, ##, ...)\n\nimport { isSpace, asciiTrim } from '../common/utils.ts'\nimport type StateBlock from './state_block.ts'\n\nexport default function heading (state: StateBlock, startLine: number, endLine: number, silent: boolean): boolean {\n  let pos = state.bMarks[startLine] + state.tShift[startLine]\n  let max = state.eMarks[startLine]\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent >= 4) { return false }\n\n  let ch = state.src.charCodeAt(pos)\n\n  if (ch !== 0x23/* # */ || pos >= max) { return false }\n\n  // count heading level\n  let level = 1\n  ch = state.src.charCodeAt(++pos)\n  while (ch === 0x23/* # */ && pos < max && level <= 6) {\n    level++\n    ch = state.src.charCodeAt(++pos)\n  }\n\n  if (level > 6 || (pos < max && !isSpace(ch))) { return false }\n\n  if (silent) { return true }\n\n  // Let's cut tails like '    ###  ' from the end of string\n\n  max = state.skipSpacesBack(max, pos)\n  const tmp = state.skipCharsBack(max, 0x23, pos) // #\n  if (tmp > pos && isSpace(state.src.charCodeAt(tmp - 1))) {\n    max = tmp\n  }\n\n  state.line = startLine + 1\n\n  const token_o = state.push('heading_open', `h${level}`, 1)\n  token_o.markup = '########'.slice(0, level)\n  token_o.map = [startLine, state.line]\n\n  const token_i = state.push('inline', '', 0)\n  token_i.content = asciiTrim(state.src.slice(pos, max))\n  token_i.map = [startLine, state.line]\n  token_i.children = []\n\n  const token_c = state.push('heading_close', `h${level}`, -1)\n  token_c.markup = '########'.slice(0, level)\n\n  return true\n}\n","// lheading (---, ===)\n\nimport { asciiTrim } from '../common/utils.ts'\nimport type StateBlock from './state_block.ts'\n\nexport default function lheading (state: StateBlock, startLine: number, endLine: number/*, silent */): boolean {\n  const terminatorRules = state.md.block.ruler.getRules('paragraph')\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent >= 4) { return false }\n\n  const oldParentType = state.parentType\n  state.parentType = 'paragraph' // use paragraph to match terminatorRules\n\n  // jump line-by-line until empty one or EOF\n  let level = 0\n  let marker\n  let nextLine = startLine + 1\n\n  for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {\n    // this would be a code block normally, but after paragraph\n    // it's considered a lazy continuation regardless of what's there\n    if (state.sCount[nextLine] - state.blkIndent > 3) { continue }\n\n    //\n    // Check for underline in setext header\n    //\n    if (state.sCount[nextLine] >= state.blkIndent) {\n      let pos = state.bMarks[nextLine] + state.tShift[nextLine]\n      const max = state.eMarks[nextLine]\n\n      if (pos < max) {\n        marker = state.src.charCodeAt(pos)\n\n        if (marker === 0x2D/* - */ || marker === 0x3D/* = */) {\n          pos = state.skipChars(pos, marker)\n          pos = state.skipSpaces(pos)\n\n          if (pos >= max) {\n            level = (marker === 0x3D/* = */ ? 1 : 2)\n            break\n          }\n        }\n      }\n    }\n\n    // quirk for blockquotes, this line should already be checked by that rule\n    if (state.sCount[nextLine] < 0) { continue }\n\n    // Some tags can terminate paragraph without empty line.\n    let terminate = false\n    for (let i = 0, l = terminatorRules.length; i < l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true\n        break\n      }\n    }\n    if (terminate) { break }\n  }\n\n  if (!level) {\n    // Didn't find valid underline\n    state.parentType = oldParentType\n    return false\n  }\n\n  const content = asciiTrim(state.getLines(startLine, nextLine, state.blkIndent, false))\n\n  state.line = nextLine + 1\n\n  const token_o = state.push('heading_open', `h${level}`, 1)\n  token_o.markup = String.fromCharCode(marker!)\n  token_o.map = [startLine, state.line]\n\n  const token_i = state.push('inline', '', 0)\n  token_i.content = content\n  token_i.map = [startLine, state.line - 1]\n  token_i.children = []\n\n  const token_c = state.push('heading_close', `h${level}`, -1)\n  token_c.markup = String.fromCharCode(marker!)\n\n  state.parentType = oldParentType\n\n  return true\n}\n","// Paragraph\n\nimport { asciiTrim } from '../common/utils.ts'\nimport type StateBlock from './state_block.ts'\n\nexport default function paragraph (state: StateBlock, startLine: number, endLine: number): boolean {\n  const terminatorRules = state.md.block.ruler.getRules('paragraph')\n  const oldParentType = state.parentType\n  let nextLine = startLine + 1\n  state.parentType = 'paragraph'\n\n  // jump line-by-line until empty one or EOF\n  for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {\n    // this would be a code block normally, but after paragraph\n    // it's considered a lazy continuation regardless of what's there\n    if (state.sCount[nextLine] - state.blkIndent > 3) { continue }\n\n    // quirk for blockquotes, this line should already be checked by that rule\n    if (state.sCount[nextLine] < 0) { continue }\n\n    // Some tags can terminate paragraph without empty line.\n    let terminate = false\n    for (let i = 0, l = terminatorRules.length; i < l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true\n        break\n      }\n    }\n    if (terminate) { break }\n  }\n\n  const content = asciiTrim(state.getLines(startLine, nextLine, state.blkIndent, false))\n\n  state.line = nextLine\n\n  const token_o = state.push('paragraph_open', 'p', 1)\n  token_o.map = [startLine, state.line]\n\n  const token_i = state.push('inline', '', 0)\n  token_i.content = content\n  token_i.map = [startLine, state.line]\n  token_i.children = []\n\n  state.push('paragraph_close', 'p', -1)\n\n  state.parentType = oldParentType\n\n  return true\n}\n","import Ruler from './ruler.ts'\nimport StateBlock from './rules_block/state_block.ts'\nimport type Token from './token.ts'\nimport type MarkdownIt from './markdownit.ts'\nimport type { Env } from './types.ts'\n\nimport r_table from './rules_block/table.ts'\nimport r_code from './rules_block/code.ts'\nimport r_fence from './rules_block/fence.ts'\nimport r_blockquote from './rules_block/blockquote.ts'\nimport r_hr from './rules_block/hr.ts'\nimport r_list from './rules_block/list.ts'\nimport r_reference from './rules_block/reference.ts'\nimport r_html_block from './rules_block/html_block.ts'\nimport r_heading from './rules_block/heading.ts'\nimport r_lheading from './rules_block/lheading.ts'\nimport r_paragraph from './rules_block/paragraph.ts'\n\nconst _rules: Array<[\n  name: string,\n  rule: (state: StateBlock, startLine: number, endLine: number, silent: boolean) => boolean,\n  alt?: string[]\n]> = [\n  // First 2 params - rule name & source. Secondary array - list of rules,\n  // which can be terminated by this one.\n  ['table', r_table, ['paragraph', 'reference']],\n  ['code', r_code],\n  ['fence', r_fence, ['paragraph', 'reference', 'blockquote', 'list']],\n  ['blockquote', r_blockquote, ['paragraph', 'reference', 'blockquote', 'list']],\n  ['hr', r_hr, ['paragraph', 'reference', 'blockquote', 'list']],\n  ['list', r_list, ['paragraph', 'reference', 'blockquote']],\n  ['reference', r_reference],\n  ['html_block', r_html_block, ['paragraph', 'reference', 'blockquote']],\n  ['heading', r_heading, ['paragraph', 'reference', 'blockquote']],\n  ['lheading', r_lheading],\n  ['paragraph', r_paragraph]\n]\n\n/**\n * Block-level tokenizer.\n */\nclass ParserBlock {\n  /**\n   * {@link Ruler} instance. Keep configuration of block rules.\n   */\n  ruler = new Ruler<[StateBlock, number, number, boolean], boolean>()\n\n  State = StateBlock\n\n  constructor () {\n    for (let i = 0; i < _rules.length; i++) {\n      this.ruler.push(_rules[i][0], _rules[i][1], { alt: (_rules[i][2] || []).slice() })\n    }\n  }\n\n  // Generate tokens for input range\n  //\n  tokenize (state: StateBlock, startLine: number, endLine: number): void {\n    const rules = this.ruler.getRules('')\n    const len = rules.length\n    const maxNesting = state.md.options.maxNesting\n    let line = startLine\n    let hasEmptyLines = false\n\n    while (line < endLine) {\n      state.line = line = state.skipEmptyLines(line)\n      if (line >= endLine) { break }\n\n      // Termination condition for nested calls.\n      // Nested calls currently used for blockquotes & lists\n      if (state.sCount[line] < state.blkIndent) { break }\n\n      // If nesting level exceeded - skip tail to the end. That's not ordinary\n      // situation and we should not care about content.\n      if (state.level >= maxNesting) {\n        state.line = endLine\n        break\n      }\n\n      // Try all possible rules.\n      // On success, rule should:\n      //\n      // - update `state.line`\n      // - update `state.tokens`\n      // - return true\n      const prevLine = state.line\n      let ok = false\n\n      for (let i = 0; i < len; i++) {\n        ok = rules[i](state, line, endLine, false)\n        if (ok) {\n          if (prevLine >= state.line) {\n            throw new Error(\"block rule didn't increment state.line\")\n          }\n          break\n        }\n      }\n\n      // this can only happen if user disables paragraph rule\n      if (!ok) throw new Error('none of the block rules matched')\n\n      // set state.tight if we had an empty line before current tag\n      // i.e. latest empty line should not count\n      state.tight = !hasEmptyLines\n\n      // paragraph might \"eat\" one newline after it in nested lists\n      if (state.isEmpty(state.line - 1)) {\n        hasEmptyLines = true\n      }\n\n      line = state.line\n\n      if (line < endLine && state.isEmpty(line)) {\n        hasEmptyLines = true\n        line++\n        state.line = line\n      }\n    }\n  }\n\n  /**\n   * Process input string and push block tokens into `outTokens`\n   */\n  parse (src: string, md: MarkdownIt, env: Env, outTokens: Token[]): void {\n    if (!src) { return }\n\n    const state = new this.State(src, md, env, outTokens)\n\n    this.tokenize(state, state.line, state.lineMax)\n  }\n}\n\nexport default ParserBlock\n","import Token from '../token.ts'\nimport { isWhiteSpace, isPunctCharCode, isMdAsciiPunct } from '../common/utils.ts'\nimport type MarkdownIt from '../markdownit.ts'\nimport type { Delimiter, Env } from '../types.ts'\n\n/** @inline */\ninterface ScannedDelimiters {\n  can_open: boolean\n  can_close: boolean\n  length: number\n}\n\n/** @inline */\ntype StateTokenMeta = Record<string, unknown> & {\n  delimiters?: Delimiter[]\n}\n\n/** Mutable state passed to inline rules while tokenizing inline content. */\nclass StateInline {\n  declare src: string\n  declare env: Env\n  declare md: MarkdownIt\n  declare tokens: Token[]\n  declare tokens_meta: Array<StateTokenMeta | undefined>\n\n  pos = 0\n  declare posMax: number\n  level = 0\n  pending = ''\n  pendingLevel = 0\n\n  // Stores { start: end } pairs. Useful for backtrack\n  // optimization of pairs parse (emphasis, strikes).\n  cache: Record<number, number> = {}\n\n  // backtick run length => position of its last run, built lazily on first use\n  backticks: Record<number, number> = {}\n  backticksScanned = false\n\n  // Set when html comment / PI / declaration / CDATA has no terminator,\n  // to skip further scans of these constructs\n  skipHtmlSpecial = false\n\n  // Counter used to disable inline linkify-it execution\n  // inside <a> and markdown links\n  linkLevel = 0\n\n  // List of emphasis-like delimiters for current tag\n  delimiters: Delimiter[] = []\n\n  // Stack of delimiter lists for upper level tags\n  _prev_delimiters: Delimiter[][] = []\n\n  // re-export Token class to use in block rules\n  Token = Token\n\n  constructor (src: string, md: MarkdownIt, env: Env, outTokens: Token[]) {\n    this.src = src\n    this.env = env\n    this.md = md\n    this.tokens = outTokens\n    this.tokens_meta = Array(outTokens.length)\n\n    this.posMax = this.src.length\n  }\n\n  // Flush pending text\n  //\n  pushPending (): Token {\n    const token = new Token('text', '', 0)\n    token.content = this.pending\n    token.level = this.pendingLevel\n    this.tokens.push(token)\n    this.pending = ''\n    return token\n  }\n\n  // Push new token to \"stream\".\n  // If pending text exists - flush it as text token\n  //\n  push (type: string, tag: string, nesting: -1 | 0 | 1): Token {\n    if (this.pending) {\n      this.pushPending()\n    }\n\n    const token = new Token(type, tag, nesting)\n    let token_meta = undefined\n\n    if (nesting < 0) {\n      // closing tag\n      this.level--\n      this.delimiters = this._prev_delimiters.pop()!\n    }\n\n    token.level = this.level\n\n    if (nesting > 0) {\n      // opening tag\n      this.level++\n      this._prev_delimiters.push(this.delimiters)\n      this.delimiters = []\n      token_meta = { delimiters: this.delimiters }\n    }\n\n    this.pendingLevel = this.level\n    this.tokens.push(token)\n    this.tokens_meta.push(token_meta)\n    return token\n  }\n\n  // Scan a sequence of emphasis-like markers, and determine whether\n  // it can start an emphasis sequence or end an emphasis sequence.\n  //\n  //  - start - position to scan from (it should point at a valid marker);\n  //  - canSplitWord - determine if these markers can be found inside a word\n  //\n  scanDelims (start: number, canSplitWord: boolean): ScannedDelimiters {\n    const max = this.posMax\n    const marker = this.src.charCodeAt(start)\n\n    // Astral characters below are combined manually, because .codePointAt()\n    // does not guarantee numeric type output. And we don't wish JIT cache issues.\n    // The broken surrogate pairs are evaluated as U+FFFD to prevent possible\n    // crashes.\n\n    let lastChar\n    if (start === 0) {\n      // treat beginning of the line as a whitespace\n      lastChar = 0x20\n    } else if (start === 1) {\n      lastChar = this.src.charCodeAt(0)\n      if ((lastChar & 0xF800) === 0xD800) { lastChar = 0xFFFD }\n    } else {\n      lastChar = this.src.charCodeAt(start - 1)\n      if ((lastChar & 0xFC00) === 0xDC00) {\n        // low surrogate => add high one, replace broken pair with U+FFFD\n        const highSurr = this.src.charCodeAt(start - 2)\n        lastChar = (highSurr & 0xFC00) === 0xD800\n          ? 0x10000 + ((highSurr - 0xD800) << 10) + (lastChar - 0xDC00)\n          : 0xFFFD\n      } else if ((lastChar & 0xFC00) === 0xD800) {\n        lastChar = 0xFFFD\n      }\n    }\n\n    let pos = start\n    while (pos < max && this.src.charCodeAt(pos) === marker) { pos++ }\n\n    const count = pos - start\n\n    // treat end of the line as a whitespace\n    let nextChar = pos < max ? this.src.charCodeAt(pos) : 0x20\n    if ((nextChar & 0xFC00) === 0xD800) {\n      // high surrogate => add low one, replace broken pair with U+FFFD\n      const lowSurr = this.src.charCodeAt(pos + 1)\n      nextChar = (lowSurr & 0xFC00) === 0xDC00\n        ? 0x10000 + ((nextChar - 0xD800) << 10) + (lowSurr - 0xDC00)\n        : 0xFFFD\n    } else if ((nextChar & 0xFC00) === 0xDC00) {\n      nextChar = 0xFFFD\n    }\n\n    const isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctCharCode(lastChar)\n    const isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctCharCode(nextChar)\n\n    const isLastWhiteSpace = isWhiteSpace(lastChar)\n    const isNextWhiteSpace = isWhiteSpace(nextChar)\n\n    const left_flanking =\n      !isNextWhiteSpace && (!isNextPunctChar || isLastWhiteSpace || isLastPunctChar)\n    const right_flanking =\n      !isLastWhiteSpace && (!isLastPunctChar || isNextWhiteSpace || isNextPunctChar)\n\n    const can_open = left_flanking && (canSplitWord || !right_flanking || isLastPunctChar)\n    const can_close = right_flanking && (canSplitWord || !left_flanking || isNextPunctChar)\n\n    return { can_open, can_close, length: count }\n  }\n}\n\nexport default StateInline\n","// Skip text characters for text token, place those to pending buffer\n// and increment current pos\n\nimport type StateInline from './state_inline.ts'\n\n// Rule to skip pure text\n// '{}$%@~+=:' reserved for extentions\n\n// !, \", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, @, [, \\, ], ^, _, `, {, |, }, or ~\n\n// !!!! Don't confuse with \"Markdown ASCII Punctuation\" chars\n// http://spec.commonmark.org/0.15/#ascii-punctuation-character\nfunction isTerminatorChar (ch: number) {\n  switch (ch) {\n    case 0x0A/* \\n */:\n    case 0x21/* ! */:\n    case 0x23/* # */:\n    case 0x24/* $ */:\n    case 0x25/* % */:\n    case 0x26/* & */:\n    case 0x2A/* * */:\n    case 0x2B/* + */:\n    case 0x2D/* - */:\n    case 0x3A/* : */:\n    case 0x3C/* < */:\n    case 0x3D/* = */:\n    case 0x3E/* > */:\n    case 0x40/* @ */:\n    case 0x5B/* [ */:\n    case 0x5C/* \\ */:\n    case 0x5D/* ] */:\n    case 0x5E/* ^ */:\n    case 0x5F/* _ */:\n    case 0x60/* ` */:\n    case 0x7B/* { */:\n    case 0x7D/* } */:\n    case 0x7E/* ~ */:\n      return true\n    default:\n      return false\n  }\n}\n\nexport default function text (state: StateInline, silent: boolean): boolean {\n  let pos = state.pos\n\n  while (pos < state.posMax && !isTerminatorChar(state.src.charCodeAt(pos))) {\n    pos++\n  }\n\n  if (pos === state.pos) { return false }\n\n  if (!silent) { state.pending += state.src.slice(state.pos, pos) }\n\n  state.pos = pos\n\n  return true\n}\n\n// Alternative implementation, for memory.\n//\n// It costs 10% of performance, but allows extend terminators list, if place it\n// to `ParserInline` property. Probably, will switch to it sometime, such\n// flexibility required.\n\n/*\nvar TERMINATOR_RE = /[\\n!#$%&*+\\-:<=>@[\\\\\\]^_`{}~]/;\n\nmodule.exports = function text(state, silent) {\n  var pos = state.pos,\n      idx = state.src.slice(pos).search(TERMINATOR_RE);\n\n  // first char is terminator -> empty text\n  if (idx === 0) { return false; }\n\n  // no terminator -> text till end of string\n  if (idx < 0) {\n    if (!silent) { state.pending += state.src.slice(pos); }\n    state.pos = state.src.length;\n    return true;\n  }\n\n  if (!silent) { state.pending += state.src.slice(pos, pos + idx); }\n\n  state.pos += idx;\n\n  return true;\n}; */\n","// Early process links like https://example.org/ to have priority\n// over emphasis, etc.\n\nimport type StateInline from './state_inline.ts'\n\n// RFC3986: scheme = ALPHA *( ALPHA / DIGIT / \"+\" / \"-\" / \".\" )\nfunction isAsciiAlpha (code: number): boolean {\n  return (code >= 0x41 && code <= 0x5A) || (code >= 0x61 && code <= 0x7A)\n}\n\nfunction isSchemeChar (code: number): boolean {\n  return (code >= 0x41 && code <= 0x5A) ||\n    (code >= 0x61 && code <= 0x7A) ||\n    (code >= 0x30 && code <= 0x39) ||\n    code === 0x2B || code === 0x2D || code === 0x2E\n}\n\nexport default function linkify (state: StateInline, silent: boolean): boolean {\n  if (!state.md.options.linkify) return false\n  if (state.linkLevel > 0) return false\n\n  const pos = state.pos\n  const max = state.posMax\n\n  if (pos + 3 > max) return false\n  if (state.src.charCodeAt(pos) !== 0x3A/* : */) return false\n  if (state.src.charCodeAt(pos + 1) !== 0x2F/* / */) return false\n  if (state.src.charCodeAt(pos + 2) !== 0x2F/* / */) return false\n\n  // Search backwards for the scheme, but no more than 10 characters, the length\n  // of the pending string, or the length of the source prefix.\n  // Use state.src instead of state.pending because it is faster to access.\n  const protoMin = pos - Math.min(10, state.pending.length, pos)\n  let protoStart = pos\n  while (protoStart > protoMin && isSchemeChar(state.src.charCodeAt(protoStart - 1))) {\n    protoStart--\n  }\n\n  if (protoStart === pos || !isAsciiAlpha(state.src.charCodeAt(protoStart))) return false\n\n  const protoLength = pos - protoStart\n\n  const link = state.md.linkify.matchAtStart(state.src.slice(protoStart))\n  if (!link) return false\n\n  let url = link.url\n\n  // invalid link, but still detected by linkify somehow;\n  // need to check to prevent infinite loop below\n  if (url.length <= protoLength) return false\n\n  // disallow '*' at the end of the link (conflicts with emphasis)\n  // do manual backsearch to avoid perf issues with regex /\\*+$/ on \"****...****a\".\n  let urlEnd = url.length\n  while (urlEnd > 0 && url.charCodeAt(urlEnd - 1) === 0x2A/* * */) {\n    urlEnd--\n  }\n  if (urlEnd !== url.length) {\n    url = url.slice(0, urlEnd)\n  }\n\n  const fullUrl = state.md.normalizeLink(url)\n  if (!state.md.validateLink(fullUrl)) return false\n\n  if (!silent) {\n    state.pending = state.pending.slice(0, -protoLength)\n\n    const token_o = state.push('link_open', 'a', 1)\n    token_o.attrs = [['href', fullUrl]]\n    token_o.markup = 'linkify'\n    token_o.info = 'auto'\n\n    const token_t = state.push('text', '', 0)\n    token_t.content = state.md.normalizeLinkText(url)\n\n    const token_c = state.push('link_close', 'a', -1)\n    token_c.markup = 'linkify'\n    token_c.info = 'auto'\n  }\n\n  state.pos += url.length - protoLength\n  return true\n}\n","// Proceess '\\n'\n\nimport { isSpace } from '../common/utils.ts'\nimport type StateInline from './state_inline.ts'\n\nexport default function newline (state: StateInline, silent: boolean): boolean {\n  let pos = state.pos\n\n  if (state.src.charCodeAt(pos) !== 0x0A/* \\n */) { return false }\n\n  const pmax = state.pending.length - 1\n  const max = state.posMax\n\n  // '  \\n' -> hardbreak\n  // Lookup in pending chars is bad practice! Don't copy to other rules!\n  // Pending string is stored in concat mode, indexed lookups will cause\n  // convertion to flat mode.\n  if (!silent) {\n    if (pmax >= 0 && state.pending.charCodeAt(pmax) === 0x20) {\n      if (pmax >= 1 && state.pending.charCodeAt(pmax - 1) === 0x20) {\n        // Find whitespaces tail of pending chars.\n        let ws = pmax - 1\n        while (ws >= 1 && state.pending.charCodeAt(ws - 1) === 0x20) ws--\n\n        state.pending = state.pending.slice(0, ws)\n        state.push('hardbreak', 'br', 0)\n      } else {\n        state.pending = state.pending.slice(0, -1)\n        state.push('softbreak', 'br', 0)\n      }\n    } else {\n      state.push('softbreak', 'br', 0)\n    }\n  }\n\n  pos++\n\n  // skip heading spaces for next line\n  while (pos < max && isSpace(state.src.charCodeAt(pos))) { pos++ }\n\n  state.pos = pos\n  return true\n}\n","// Process escaped chars and hardbreaks\n\nimport { isSpace } from '../common/utils.ts'\nimport type StateInline from './state_inline.ts'\n\nconst ESCAPED: number[] = []\n\nfor (let i = 0; i < 256; i++) { ESCAPED.push(0) }\n\n'\\\\!\"#$%&\\'()*+,./:;<=>?@[]^_`{|}~-'\n  .split('').forEach(function (ch) { ESCAPED[ch.charCodeAt(0)] = 1 })\n\nexport default function escape (state: StateInline, silent: boolean): boolean {\n  let pos = state.pos\n  const max = state.posMax\n\n  if (state.src.charCodeAt(pos) !== 0x5C/* \\ */) return false\n  pos++\n\n  // '\\' at the end of the inline block\n  if (pos >= max) return false\n\n  let ch1 = state.src.charCodeAt(pos)\n\n  if (ch1 === 0x0A) {\n    if (!silent) {\n      state.push('hardbreak', 'br', 0)\n    }\n\n    pos++\n    // skip leading whitespaces from next line\n    while (pos < max) {\n      ch1 = state.src.charCodeAt(pos)\n      if (!isSpace(ch1)) break\n      pos++\n    }\n\n    state.pos = pos\n    return true\n  }\n\n  // '\\' before a space is a literal backslash. Don't consume the space, so a\n  // trailing two-space hard line break is still detected by the newline rule.\n  if (ch1 === 0x20) {\n    if (!silent) {\n      const token = state.push('text_special', '', 0)\n      token.content = '\\\\'\n      token.markup = '\\\\'\n      token.info = 'escape'\n    }\n\n    state.pos = pos\n    return true\n  }\n\n  let escapedStr = state.src[pos]\n\n  if (ch1 >= 0xD800 && ch1 <= 0xDBFF && pos + 1 < max) {\n    const ch2 = state.src.charCodeAt(pos + 1)\n\n    if (ch2 >= 0xDC00 && ch2 <= 0xDFFF) {\n      escapedStr += state.src[pos + 1]\n      pos++\n    }\n  }\n\n  const origStr = '\\\\' + escapedStr\n\n  if (!silent) {\n    const token = state.push('text_special', '', 0)\n\n    if (ch1 < 256 && ESCAPED[ch1] !== 0) {\n      token.content = escapedStr\n    } else {\n      token.content = origStr\n    }\n\n    token.markup = origStr\n    token.info = 'escape'\n  }\n\n  state.pos = pos + 1\n  return true\n}\n","// Parse backticks\n\nimport type StateInline from './state_inline.ts'\n\n// Position of the last backtick run of each length. Derived from the string in\n// one pass, so unlike an incremental cache it never depends on how the parser\n// walks it, and stays valid across lookaheads and narrowed ranges.\nfunction buildLastRuns (src: string): Record<number, number> {\n  const lastRuns: Record<number, number> = {}\n  let pos = 0\n\n  while ((pos = src.indexOf('`', pos)) !== -1) {\n    const start = pos\n    while (src.charCodeAt(++pos) === 0x60/* ` */) { /* scan run length */ }\n    lastRuns[pos - start] = start\n  }\n\n  return lastRuns\n}\n\nexport default function backtick (state: StateInline, silent: boolean): boolean {\n  const start = state.pos\n\n  if (state.src.charCodeAt(start) !== 0x60/* ` */) { return false }\n\n  const max = state.posMax\n  let pos = start + 1\n\n  // scan marker length\n  while (pos < max && state.src.charCodeAt(pos) === 0x60/* ` */) { pos++ }\n\n  const marker = state.src.slice(start, pos)\n  const openerLength = marker.length\n\n  if (!state.backticksScanned) {\n    state.backticks = buildLastRuns(state.src)\n    state.backticksScanned = true\n  }\n\n  // Nothing of the same length left in the string, so no closer can exist\n  if ((state.backticks[openerLength] ?? -1) >= pos) {\n    let matchEnd = pos\n    let matchStart\n\n    while ((matchStart = state.src.indexOf('`', matchEnd)) !== -1 && matchStart < max) {\n      // Measure the whole run, not just its part inside the current range,\n      // otherwise a run straddling `max` would be mistaken for a shorter one\n      matchEnd = matchStart + 1\n      while (state.src.charCodeAt(matchEnd) === 0x60/* ` */) { matchEnd++ }\n\n      if (matchEnd > max) break\n\n      if (matchEnd - matchStart === openerLength) {\n        if (!silent) {\n          const token = state.push('code_inline', 'code', 0)\n          token.markup = marker\n          let content = state.src.slice(pos, matchStart).replace(/\\n/g, ' ')\n\n          // Strip one space from each side, unless the content is all spaces\n          if (content.startsWith(' ') && content.endsWith(' ') && /[^ ]/.test(content)) {\n            content = content.slice(1, -1)\n          }\n\n          token.content = content\n        }\n        state.pos = matchEnd\n        return true\n      }\n    }\n  }\n\n  if (!silent) state.pending += marker\n  state.pos = pos\n  return true\n}\n","// ~~strike through~~\n//\n\nimport type { Delimiter } from '../types.ts'\nimport type StateInline from './state_inline.ts'\n\n// Insert each marker as a separate text token, and add it to delimiter list\n//\nfunction strikethrough_tokenize (state: StateInline, silent: boolean): boolean {\n  const start = state.pos\n  const marker = state.src.charCodeAt(start)\n\n  if (silent) { return false }\n\n  if (marker !== 0x7E/* ~ */) { return false }\n\n  const scanned = state.scanDelims(state.pos, true)\n  let len = scanned.length\n  const ch = String.fromCharCode(marker)\n\n  if (len < 2) { return false }\n\n  let token\n\n  if (len % 2) {\n    token = state.push('text', '', 0)\n    token.content = ch\n    len--\n  }\n\n  for (let i = 0; i < len; i += 2) {\n    token = state.push('text', '', 0)\n    token.content = ch + ch\n\n    state.delimiters.push({\n      marker,\n      length: 0,     // disable \"rule of 3\" length checks meant for emphasis\n      token: state.tokens.length - 1,\n      end: -1,\n      open: scanned.can_open,\n      close: scanned.can_close\n    })\n  }\n\n  state.pos += scanned.length\n\n  return true\n}\n\nfunction postProcess (state: StateInline, delimiters: Delimiter[]) {\n  let token\n  const loneMarkers = []\n  const max = delimiters.length\n\n  for (let i = 0; i < max; i++) {\n    const startDelim = delimiters[i]\n\n    if (startDelim.marker !== 0x7E/* ~ */) {\n      continue\n    }\n\n    if (startDelim.end === -1) {\n      continue\n    }\n\n    const endDelim = delimiters[startDelim.end]\n\n    token = state.tokens[startDelim.token]\n    token.type = 's_open'\n    token.tag = 's'\n    token.nesting = 1\n    token.markup = '~~'\n    token.content = ''\n\n    token = state.tokens[endDelim.token]\n    token.type = 's_close'\n    token.tag = 's'\n    token.nesting = -1\n    token.markup = '~~'\n    token.content = ''\n\n    if (state.tokens[endDelim.token - 1].type === 'text' &&\n        state.tokens[endDelim.token - 1].content === '~') {\n      loneMarkers.push(endDelim.token - 1)\n    }\n  }\n\n  // If a marker sequence has an odd number of characters, it's splitted\n  // like this: `~~~~~` -> `~` + `~~` + `~~`, leaving one marker at the\n  // start of the sequence.\n  //\n  // So, we have to move all those markers after subsequent s_close tags.\n  //\n  while (loneMarkers.length) {\n    const i = loneMarkers.pop()!\n    let j = i + 1\n\n    while (j < state.tokens.length && state.tokens[j].type === 's_close') {\n      j++\n    }\n\n    j--\n\n    if (i !== j) {\n      token = state.tokens[j]\n      state.tokens[j] = state.tokens[i]\n      state.tokens[i] = token\n    }\n  }\n}\n\n// Walk through delimiter list and replace text tokens with tags\n//\nfunction strikethrough_postProcess (state: StateInline): void {\n  const tokens_meta = state.tokens_meta\n  const max = state.tokens_meta.length\n\n  postProcess(state, state.delimiters)\n\n  for (let curr = 0; curr < max; curr++) {\n    const delimiters = tokens_meta[curr]?.delimiters\n    if (delimiters) {\n      postProcess(state, delimiters)\n    }\n  }\n}\n\nexport default {\n  tokenize: strikethrough_tokenize,\n  postProcess: strikethrough_postProcess\n}\n","// Process *this* and _that_\n//\n\nimport type { Delimiter } from '../types.ts'\nimport type StateInline from './state_inline.ts'\n\n// Insert each marker as a separate text token, and add it to delimiter list\n//\nfunction emphasis_tokenize (state: StateInline, silent: boolean): boolean {\n  const start = state.pos\n  const marker = state.src.charCodeAt(start)\n\n  if (silent) { return false }\n\n  if (marker !== 0x5F /* _ */ && marker !== 0x2A /* * */) { return false }\n\n  const scanned = state.scanDelims(state.pos, marker === 0x2A)\n\n  for (let i = 0; i < scanned.length; i++) {\n    const token = state.push('text', '', 0)\n    token.content = String.fromCharCode(marker)\n\n    state.delimiters.push({\n      // Char code of the starting marker (number).\n      //\n      marker,\n\n      // Total length of these series of delimiters.\n      //\n      length: scanned.length,\n\n      // A position of the token this delimiter corresponds to.\n      //\n      token: state.tokens.length - 1,\n\n      // If this delimiter is matched as a valid opener, `end` will be\n      // equal to its position, otherwise it's `-1`.\n      //\n      end: -1,\n\n      // Boolean flags that determine if this delimiter could open or close\n      // an emphasis.\n      //\n      open: scanned.can_open,\n      close: scanned.can_close\n    })\n  }\n\n  state.pos += scanned.length\n\n  return true\n}\n\nfunction postProcess (state: StateInline, delimiters: Delimiter[]) {\n  const max = delimiters.length\n\n  for (let i = max - 1; i >= 0; i--) {\n    const startDelim = delimiters[i]\n\n    if (startDelim.marker !== 0x5F/* _ */ && startDelim.marker !== 0x2A/* * */) {\n      continue\n    }\n\n    // Process only opening markers\n    if (startDelim.end === -1) {\n      continue\n    }\n\n    const endDelim = delimiters[startDelim.end]\n\n    // If the previous delimiter has the same marker and is adjacent to this one,\n    // merge those into one strong delimiter.\n    //\n    // `<em><em>whatever</em></em>` -> `<strong>whatever</strong>`\n    //\n    const isStrong = i > 0 &&\n               delimiters[i - 1].end === startDelim.end + 1 &&\n               // check that first two markers match and adjacent\n               delimiters[i - 1].marker === startDelim.marker &&\n               delimiters[i - 1].token === startDelim.token - 1 &&\n               // check that last two markers are adjacent (we can safely assume they match)\n               delimiters[startDelim.end + 1].token === endDelim.token + 1\n\n    const ch = String.fromCharCode(startDelim.marker)\n\n    const token_o = state.tokens[startDelim.token]\n    token_o.type = isStrong ? 'strong_open' : 'em_open'\n    token_o.tag = isStrong ? 'strong' : 'em'\n    token_o.nesting = 1\n    token_o.markup = isStrong ? ch + ch : ch\n    token_o.content = ''\n\n    const token_c = state.tokens[endDelim.token]\n    token_c.type = isStrong ? 'strong_close' : 'em_close'\n    token_c.tag = isStrong ? 'strong' : 'em'\n    token_c.nesting = -1\n    token_c.markup = isStrong ? ch + ch : ch\n    token_c.content = ''\n\n    if (isStrong) {\n      state.tokens[delimiters[i - 1].token].content = ''\n      state.tokens[delimiters[startDelim.end + 1].token].content = ''\n      i--\n    }\n  }\n}\n\n// Walk through delimiter list and replace text tokens with tags\n//\nfunction emphasis_post_process (state: StateInline): void {\n  const tokens_meta = state.tokens_meta\n  const max = state.tokens_meta.length\n\n  postProcess(state, state.delimiters)\n\n  for (let curr = 0; curr < max; curr++) {\n    const delimiters = tokens_meta[curr]?.delimiters\n    if (delimiters) {\n      postProcess(state, delimiters)\n    }\n  }\n}\n\nexport default {\n  tokenize: emphasis_tokenize,\n  postProcess: emphasis_post_process\n}\n","// Process [link](<to> \"stuff\")\n\nimport { normalizeReference, isSpace } from '../common/utils.ts'\nimport type StateInline from './state_inline.ts'\n\nexport default function link (state: StateInline, silent: boolean): boolean {\n  let code, label, res, ref\n  let href = ''\n  let title = ''\n  let start = state.pos\n  let parseReference = true\n\n  if (state.src.charCodeAt(state.pos) !== 0x5B/* [ */) { return false }\n\n  const oldPos = state.pos\n  const max = state.posMax\n  const labelStart = state.pos + 1\n  const labelEnd = state.md.helpers.parseLinkLabel(state, state.pos, true)\n\n  // parser failed to find ']', so it's not a valid link\n  if (labelEnd < 0) { return false }\n\n  let pos = labelEnd + 1\n  if (pos < max && state.src.charCodeAt(pos) === 0x28/* ( */) {\n    //\n    // Inline link\n    //\n\n    // might have found a valid shortcut link, disable reference parsing\n    parseReference = false\n\n    // [link](  <href>  \"title\"  )\n    //        ^^ skipping these spaces\n    pos++\n    for (; pos < max; pos++) {\n      code = state.src.charCodeAt(pos)\n      if (!isSpace(code) && code !== 0x0A) { break }\n    }\n    if (pos >= max) { return false }\n\n    // [link](  <href>  \"title\"  )\n    //          ^^^^^^ parsing link destination\n    start = pos\n    res = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax)\n    if (res.ok) {\n      href = state.md.normalizeLink(res.str)\n      if (state.md.validateLink(href)) {\n        pos = res.pos\n      } else {\n        href = ''\n      }\n\n      // [link](  <href>  \"title\"  )\n      //                ^^ skipping these spaces\n      start = pos\n      for (; pos < max; pos++) {\n        code = state.src.charCodeAt(pos)\n        if (!isSpace(code) && code !== 0x0A) { break }\n      }\n\n      // [link](  <href>  \"title\"  )\n      //                  ^^^^^^^ parsing link title\n      res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax)\n      if (pos < max && start !== pos && res.ok) {\n        title = res.str\n        pos = res.pos\n\n        // [link](  <href>  \"title\"  )\n        //                         ^^ skipping these spaces\n        for (; pos < max; pos++) {\n          code = state.src.charCodeAt(pos)\n          if (!isSpace(code) && code !== 0x0A) { break }\n        }\n      }\n    }\n\n    if (pos >= max || state.src.charCodeAt(pos) !== 0x29/* ) */) {\n      // parsing a valid shortcut link failed, fallback to reference\n      parseReference = true\n    }\n    pos++\n  }\n\n  if (parseReference) {\n    //\n    // Link reference\n    //\n    if (typeof state.env.references === 'undefined') { return false }\n\n    if (pos < max && state.src.charCodeAt(pos) === 0x5B/* [ */) {\n      start = pos + 1\n      pos = state.md.helpers.parseLinkLabel(state, pos)\n      if (pos >= 0) {\n        label = state.src.slice(start, pos++)\n      } else {\n        pos = labelEnd + 1\n      }\n    } else {\n      pos = labelEnd + 1\n    }\n\n    // covers label === '' and label === undefined\n    // (collapsed reference link and shortcut reference link respectively)\n    if (!label) { label = state.src.slice(labelStart, labelEnd) }\n\n    label = normalizeReference(label)\n    ref = state.env.references[label]\n    if (!ref) {\n      state.pos = oldPos\n      return false\n    }\n    href = ref.href\n    title = ref.title\n  }\n\n  //\n  // We found the end of the link, and know for a fact it's a valid link;\n  // so all that's left to do is to call tokenizer.\n  //\n  if (!silent) {\n    state.pos = labelStart\n    state.posMax = labelEnd\n\n    const token_o = state.push('link_open', 'a', 1)\n    const attrs: Array<[string, string]> = [['href', href]]\n    token_o.attrs = attrs\n    if (title) {\n      attrs.push(['title', title])\n    }\n    if (label) {\n      const meta: Record<string, unknown> = Object.create(null)\n      meta.label = label\n      token_o.meta = meta\n    }\n\n    state.linkLevel++\n    state.md.inline.tokenize(state)\n    state.linkLevel--\n\n    state.push('link_close', 'a', -1)\n  }\n\n  state.pos = pos\n  state.posMax = max\n  return true\n}\n","// Process ![image](<src> \"title\")\n\nimport { normalizeReference, isSpace } from '../common/utils.ts'\nimport type Token from '../token.ts'\nimport type StateInline from './state_inline.ts'\n\nexport default function image (state: StateInline, silent: boolean): boolean {\n  let code, content, label, pos, ref, res, title, start\n  let href = ''\n  const oldPos = state.pos\n  const max = state.posMax\n\n  if (state.src.charCodeAt(state.pos) !== 0x21/* ! */) { return false }\n  if (state.src.charCodeAt(state.pos + 1) !== 0x5B/* [ */) { return false }\n\n  const labelStart = state.pos + 2\n  const labelEnd = state.md.helpers.parseLinkLabel(state, state.pos + 1, false)\n\n  // parser failed to find ']', so it's not a valid link\n  if (labelEnd < 0) { return false }\n\n  pos = labelEnd + 1\n  if (pos < max && state.src.charCodeAt(pos) === 0x28/* ( */) {\n    //\n    // Inline link\n    //\n\n    // [link](  <href>  \"title\"  )\n    //        ^^ skipping these spaces\n    pos++\n    for (; pos < max; pos++) {\n      code = state.src.charCodeAt(pos)\n      if (!isSpace(code) && code !== 0x0A) { break }\n    }\n    if (pos >= max) { return false }\n\n    // [link](  <href>  \"title\"  )\n    //          ^^^^^^ parsing link destination\n    start = pos\n    res = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax)\n    if (res.ok) {\n      href = state.md.normalizeLink(res.str)\n      if (state.md.validateLink(href)) {\n        pos = res.pos\n      } else {\n        href = ''\n      }\n    }\n\n    // [link](  <href>  \"title\"  )\n    //                ^^ skipping these spaces\n    start = pos\n    for (; pos < max; pos++) {\n      code = state.src.charCodeAt(pos)\n      if (!isSpace(code) && code !== 0x0A) { break }\n    }\n\n    // [link](  <href>  \"title\"  )\n    //                  ^^^^^^^ parsing link title\n    res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax)\n    if (pos < max && start !== pos && res.ok) {\n      title = res.str\n      pos = res.pos\n\n      // [link](  <href>  \"title\"  )\n      //                         ^^ skipping these spaces\n      for (; pos < max; pos++) {\n        code = state.src.charCodeAt(pos)\n        if (!isSpace(code) && code !== 0x0A) { break }\n      }\n    } else {\n      title = ''\n    }\n\n    if (pos >= max || state.src.charCodeAt(pos) !== 0x29/* ) */) {\n      state.pos = oldPos\n      return false\n    }\n    pos++\n  } else {\n    //\n    // Link reference\n    //\n    if (typeof state.env.references === 'undefined') { return false }\n\n    if (pos < max && state.src.charCodeAt(pos) === 0x5B/* [ */) {\n      start = pos + 1\n      pos = state.md.helpers.parseLinkLabel(state, pos)\n      if (pos >= 0) {\n        label = state.src.slice(start, pos++)\n      } else {\n        pos = labelEnd + 1\n      }\n    } else {\n      pos = labelEnd + 1\n    }\n\n    // covers label === '' and label === undefined\n    // (collapsed reference link and shortcut reference link respectively)\n    if (!label) { label = state.src.slice(labelStart, labelEnd) }\n\n    label = normalizeReference(label)\n    ref = state.env.references[label]\n    if (!ref) {\n      state.pos = oldPos\n      return false\n    }\n    href = ref.href\n    title = ref.title\n  }\n\n  //\n  // We found the end of the link, and know for a fact it's a valid link;\n  // so all that's left to do is to call tokenizer.\n  //\n  if (!silent) {\n    content = state.src.slice(labelStart, labelEnd)\n\n    const tokens: Token[] = []\n    state.md.inline.parse(\n      content,\n      state.md,\n      state.env,\n      tokens\n    )\n\n    const token = state.push('image', 'img', 0)\n    const attrs: Array<[string, string]> = [['src', href], ['alt', '']]\n    token.attrs = attrs\n    token.children = tokens\n    token.content = content\n\n    if (title) {\n      attrs.push(['title', title])\n    }\n    if (label) {\n      const meta: Record<string, unknown> = Object.create(null)\n      meta.label = label\n      token.meta = meta\n    }\n  }\n\n  state.pos = pos\n  state.posMax = max\n  return true\n}\n","// Process autolinks '<protocol:...>'\n\nimport type StateInline from './state_inline.ts'\n\n/* eslint max-len:0 */\nconst EMAIL_RE = /^([a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)$/\n/* eslint-disable-next-line no-control-regex */\nconst AUTOLINK_RE = /^([a-zA-Z][a-zA-Z0-9+.-]{1,31}):([^<>\\x00-\\x20]*)$/\n\nexport default function autolink (state: StateInline, silent: boolean): boolean {\n  let pos = state.pos\n\n  if (state.src.charCodeAt(pos) !== 0x3C/* < */) { return false }\n\n  const start = state.pos\n  const max = state.posMax\n\n  for (;;) {\n    if (++pos >= max) return false\n\n    const ch = state.src.charCodeAt(pos)\n\n    if (ch === 0x3C /* < */) return false\n    if (ch === 0x3E /* > */) break\n  }\n\n  const url = state.src.slice(start + 1, pos)\n\n  if (AUTOLINK_RE.test(url)) {\n    const fullUrl = state.md.normalizeLink(url)\n    if (!state.md.validateLink(fullUrl)) { return false }\n\n    if (!silent) {\n      const token_o = state.push('link_open', 'a', 1)\n      token_o.attrs = [['href', fullUrl]]\n      token_o.markup = 'autolink'\n      token_o.info = 'auto'\n\n      const token_t = state.push('text', '', 0)\n      token_t.content = state.md.normalizeLinkText(url)\n\n      const token_c = state.push('link_close', 'a', -1)\n      token_c.markup = 'autolink'\n      token_c.info = 'auto'\n    }\n\n    state.pos += url.length + 2\n    return true\n  }\n\n  if (EMAIL_RE.test(url)) {\n    const fullUrl = state.md.normalizeLink(`mailto:${url}`)\n    if (!state.md.validateLink(fullUrl)) { return false }\n\n    if (!silent) {\n      const token_o = state.push('link_open', 'a', 1)\n      token_o.attrs = [['href', fullUrl]]\n      token_o.markup = 'autolink'\n      token_o.info = 'auto'\n\n      const token_t = state.push('text', '', 0)\n      token_t.content = state.md.normalizeLinkText(url)\n\n      const token_c = state.push('link_close', 'a', -1)\n      token_c.markup = 'autolink'\n      token_c.info = 'auto'\n    }\n\n    state.pos += url.length + 2\n    return true\n  }\n\n  return false\n}\n","// Process html tags\n\nimport { HTML_OPEN_CLOSE_TAG_RE } from '../common/html_re.ts'\nimport type StateInline from './state_inline.ts'\n\nfunction isLinkOpen (str: string) {\n  return /^<a[>\\s]/i.test(str)\n}\nfunction isLinkClose (str: string) {\n  return /^<\\/a\\s*>/i.test(str)\n}\n\nfunction isLetter (ch: number) {\n  /* eslint no-bitwise:0 */\n  const lc = ch | 0x20 // to lower case\n  return (lc >= 0x61/* a */) && (lc <= 0x7a/* z */)\n}\n\n// Comment, processing instruction, declaration or CDATA: fixed opener,\n// then everything up to the first terminator. Returns end position or -1.\nfunction scanSpecial (state: StateInline, pos: number): number {\n  const src = state.src\n  let start: number\n  let terminator: string\n\n  if (src.startsWith('<!--', pos)) {\n    if (src.startsWith('>', pos + 4)) { return pos + 5 }\n    if (src.startsWith('->', pos + 4)) { return pos + 6 }\n    start = pos + 4\n    terminator = '-->'\n  } else if (src.startsWith('<![CDATA[', pos)) {\n    start = pos + 9\n    terminator = ']]>'\n  } else if (src.charCodeAt(pos + 1) === 0x3F/* ? */) {\n    start = pos + 2\n    terminator = '?>'\n  } else if (isLetter(src.charCodeAt(pos + 2))) {\n    start = pos + 3\n    terminator = '>'\n  } else {\n    return -1\n  }\n\n  if (state.skipHtmlSpecial) { return -1 }\n\n  const end = src.indexOf(terminator, start)\n  if (end < 0) {\n    // One flag for all constructs to keep code simple. Valid constructs after\n    // an unclosed one in the same paragraph become text, that's acceptable.\n    state.skipHtmlSpecial = true\n    return -1\n  }\n  return end + terminator.length\n}\n\nexport default function html_inline (state: StateInline, silent: boolean): boolean {\n  if (!state.md.options.html) { return false }\n\n  // Check start\n  const max = state.posMax\n  const pos = state.pos\n  if (state.src.charCodeAt(pos) !== 0x3C/* < */ ||\n      pos + 2 >= max) {\n    return false\n  }\n\n  let end: number\n  const ch = state.src.charCodeAt(pos + 1)\n\n  if (ch === 0x21/* ! */ || ch === 0x3F/* ? */) {\n    end = scanSpecial(state, pos)\n  } else if (ch === 0x2F/* / */ || isLetter(ch)) {\n    const match = state.src.slice(pos).match(HTML_OPEN_CLOSE_TAG_RE)\n    end = match ? pos + match[0].length : -1\n  } else {\n    return false\n  }\n\n  if (end < 0) { return false }\n\n  if (!silent) {\n    const token = state.push('html_inline', '', 0)\n    token.content = state.src.slice(pos, end)\n\n    if (isLinkOpen(token.content)) state.linkLevel++\n    if (isLinkClose(token.content)) state.linkLevel--\n  }\n  state.pos = end\n  return true\n}\n","// Process html entity - &#123;, &#xAF;, &quot;, ...\n\nimport { decodeHTMLStrict } from 'entities'\nimport { isValidEntityCode, fromCodePoint } from '../common/utils.ts'\nimport type StateInline from './state_inline.ts'\n\nconst DIGITAL_RE = /^&#((?:x[a-f0-9]{1,6}|[0-9]{1,7}));/i\nconst NAMED_RE = /^&([a-z][a-z0-9]{1,31});/i\n\nexport default function entity (state: StateInline, silent: boolean): boolean {\n  const pos = state.pos\n  const max = state.posMax\n\n  if (state.src.charCodeAt(pos) !== 0x26/* & */) return false\n\n  if (pos + 1 >= max) return false\n\n  const ch = state.src.charCodeAt(pos + 1)\n\n  if (ch === 0x23 /* # */) {\n    const match = state.src.slice(pos).match(DIGITAL_RE)\n    if (match) {\n      if (!silent) {\n        const code = match[1][0].toLowerCase() === 'x' ? parseInt(match[1].slice(1), 16) : parseInt(match[1], 10)\n\n        const token = state.push('text_special', '', 0)\n        token.content = isValidEntityCode(code) ? fromCodePoint(code) : fromCodePoint(0xFFFD)\n        token.markup = match[0]\n        token.info = 'entity'\n      }\n      state.pos += match[0].length\n      return true\n    }\n  } else {\n    const match = state.src.slice(pos).match(NAMED_RE)\n    if (match) {\n      const decoded = decodeHTMLStrict(match[0])\n      if (decoded !== match[0]) {\n        if (!silent) {\n          const token = state.push('text_special', '', 0)\n          token.content = decoded\n          token.markup = match[0]\n          token.info = 'entity'\n        }\n        state.pos += match[0].length\n        return true\n      }\n    }\n  }\n\n  return false\n}\n","// For each opening emphasis-like marker find a matching closing one\n//\n\nimport type { Delimiter } from '../types.ts'\nimport type StateInline from './state_inline.ts'\n\nfunction processDelimiters (delimiters: Delimiter[]) {\n  const openersBottom: Record<number, number[]> = {}\n  const max = delimiters.length\n\n  if (!max) return\n\n  // headerIdx is the first delimiter of the current (where closer is) delimiter run\n  let headerIdx = 0\n  let lastTokenIdx = -2 // needs any value lower than -1\n  const jumps: number[] = []\n\n  for (let closerIdx = 0; closerIdx < max; closerIdx++) {\n    const closer = delimiters[closerIdx]\n\n    jumps.push(0)\n\n    // markers belong to same delimiter run if:\n    //  - they have adjacent tokens\n    //  - AND markers are the same\n    //\n    if (delimiters[headerIdx].marker !== closer.marker || lastTokenIdx !== closer.token - 1) {\n      headerIdx = closerIdx\n    }\n\n    lastTokenIdx = closer.token\n\n    // Length is only used for emphasis-specific \"rule of 3\",\n    // if it's not defined (in strikethrough or 3rd party plugins),\n    // we can default it to 0 to disable those checks.\n    //\n    closer.length = closer.length || 0\n\n    if (!closer.close) continue\n\n    // Previously calculated lower bounds (previous fails)\n    // for each marker, each delimiter length modulo 3,\n    // and for whether this closer can be an opener;\n    // https://github.com/commonmark/cmark/commit/34250e12ccebdc6372b8b49c44fab57c72443460\n    /* eslint-disable-next-line no-prototype-builtins */\n    if (!openersBottom.hasOwnProperty(closer.marker)) {\n      openersBottom[closer.marker] = [-1, -1, -1, -1, -1, -1]\n    }\n\n    const minOpenerIdx = openersBottom[closer.marker][(closer.open ? 3 : 0) + (closer.length % 3)]\n\n    let openerIdx = headerIdx - jumps[headerIdx] - 1\n\n    let newMinOpenerIdx = openerIdx\n\n    for (; openerIdx > minOpenerIdx; openerIdx -= jumps[openerIdx] + 1) {\n      const opener = delimiters[openerIdx]\n\n      if (opener.marker !== closer.marker) continue\n\n      if (opener.open && opener.end < 0) {\n        let isOddMatch = false\n\n        // from spec:\n        //\n        // If one of the delimiters can both open and close emphasis, then the\n        // sum of the lengths of the delimiter runs containing the opening and\n        // closing delimiters must not be a multiple of 3 unless both lengths\n        // are multiples of 3.\n        //\n        if (opener.close || closer.open) {\n          if ((opener.length! + closer.length) % 3 === 0) {\n            if (opener.length! % 3 !== 0 || closer.length % 3 !== 0) {\n              isOddMatch = true\n            }\n          }\n        }\n\n        if (!isOddMatch) {\n          // If previous delimiter cannot be an opener, we can safely skip\n          // the entire sequence in future checks. This is required to make\n          // sure algorithm has linear complexity (see *_*_*_*_*_... case).\n          //\n          const lastJump = openerIdx > 0 && !delimiters[openerIdx - 1].open\n            ? jumps[openerIdx - 1] + 1\n            : 0\n\n          jumps[closerIdx] = closerIdx - openerIdx + lastJump\n          jumps[openerIdx] = lastJump\n\n          closer.open = false\n          opener.end = closerIdx\n          opener.close = false\n          newMinOpenerIdx = -1\n          // treat next token as start of run,\n          // it optimizes skips in **<...>**a**<...>** pathological case\n          lastTokenIdx = -2\n          break\n        }\n      }\n    }\n\n    if (newMinOpenerIdx !== -1) {\n      // If match for this delimiter run failed, we want to set lower bound for\n      // future lookups. This is required to make sure algorithm has linear\n      // complexity.\n      //\n      // See details here:\n      // https://github.com/commonmark/cmark/issues/178#issuecomment-270417442\n      //\n      openersBottom[closer.marker][(closer.open ? 3 : 0) + ((closer.length || 0) % 3)] = newMinOpenerIdx\n    }\n  }\n}\n\nexport default function link_pairs (state: StateInline): void {\n  const tokens_meta = state.tokens_meta\n  const max = state.tokens_meta.length\n\n  processDelimiters(state.delimiters)\n\n  for (let curr = 0; curr < max; curr++) {\n    const delimiters = tokens_meta[curr]?.delimiters\n    if (delimiters) {\n      processDelimiters(delimiters)\n    }\n  }\n}\n","// Clean up tokens after emphasis and strikethrough postprocessing:\n// merge adjacent text nodes into one and re-calculate all token levels\n//\n// This is necessary because initially emphasis delimiter markers (*, _, ~)\n// are treated as their own separate text tokens. Then emphasis rule either\n// leaves them as text (needed to merge with adjacent text) or turns them\n// into opening/closing tags (which messes up levels inside).\n//\n\nimport type StateInline from './state_inline.ts'\n\nexport default function fragments_join (state: StateInline): void {\n  let curr, last\n  let level = 0\n  const tokens = state.tokens\n  const max = state.tokens.length\n\n  for (curr = last = 0; curr < max; curr++) {\n    // re-calculate levels after emphasis/strikethrough turns some text nodes\n    // into opening/closing tags\n    if (tokens[curr].nesting < 0) level-- // closing tag\n    tokens[curr].level = level\n    if (tokens[curr].nesting > 0) level++ // opening tag\n\n    if (tokens[curr].type === 'text' &&\n        curr + 1 < max &&\n        tokens[curr + 1].type === 'text') {\n      // collapse two adjacent text nodes\n      tokens[curr + 1].content = tokens[curr].content + tokens[curr + 1].content\n    } else {\n      if (curr !== last) { tokens[last] = tokens[curr] }\n\n      last++\n    }\n  }\n\n  if (curr !== last) {\n    tokens.length = last\n  }\n}\n","import Ruler from './ruler.ts'\nimport StateInline from './rules_inline/state_inline.ts'\nimport type Token from './token.ts'\nimport type MarkdownIt from './markdownit.ts'\nimport type { Env } from './types.ts'\n\nimport r_text from './rules_inline/text.ts'\nimport r_linkify from './rules_inline/linkify.ts'\nimport r_newline from './rules_inline/newline.ts'\nimport r_escape from './rules_inline/escape.ts'\nimport r_backticks from './rules_inline/backticks.ts'\nimport r_strikethrough from './rules_inline/strikethrough.ts'\nimport r_emphasis from './rules_inline/emphasis.ts'\nimport r_link from './rules_inline/link.ts'\nimport r_image from './rules_inline/image.ts'\nimport r_autolink from './rules_inline/autolink.ts'\nimport r_html_inline from './rules_inline/html_inline.ts'\nimport r_entity from './rules_inline/entity.ts'\n\nimport r_balance_pairs from './rules_inline/balance_pairs.ts'\nimport r_fragments_join from './rules_inline/fragments_join.ts'\n\n// Parser rules\n\nconst _rules: Array<[\n  name: string,\n  rule: (state: StateInline, silent: boolean) => boolean\n]> = [\n  ['text', r_text],\n  ['linkify', r_linkify],\n  ['newline', r_newline],\n  ['escape', r_escape],\n  ['backticks', r_backticks],\n  ['strikethrough', r_strikethrough.tokenize],\n  ['emphasis', r_emphasis.tokenize],\n  ['link', r_link],\n  ['image', r_image],\n  ['autolink', r_autolink],\n  ['html_inline', r_html_inline],\n  ['entity', r_entity]\n]\n\n// `rule2` ruleset was created specifically for emphasis/strikethrough\n// post-processing and may be changed in the future.\n//\n// Don't use this for anything except pairs (plugins working with `balance_pairs`).\n//\nconst _rules2: Array<[\n  name: string,\n  rule: (state: StateInline) => void\n]> = [\n  ['balance_pairs', r_balance_pairs],\n  ['strikethrough', r_strikethrough.postProcess],\n  ['emphasis', r_emphasis.postProcess],\n  // rules for pairs separate '**' into its own text tokens, which may be left unused,\n  // rule below merges unused segments back with the rest of the text\n  ['fragments_join', r_fragments_join]\n]\n\n/**\n * Tokenizes paragraph content.\n */\nclass ParserInline {\n  /**\n   * {@link Ruler} instance. Keep configuration of inline rules.\n   */\n  ruler = new Ruler<[StateInline, boolean], boolean>()\n\n  /**\n   * {@link Ruler} instance. Second ruler used for post-processing\n   * (e.g. in emphasis-like rules).\n   */\n  ruler2 = new Ruler<[StateInline], void>()\n\n  State = StateInline\n\n  constructor () {\n    for (let i = 0; i < _rules.length; i++) {\n      this.ruler.push(_rules[i][0], _rules[i][1])\n    }\n\n    for (let i = 0; i < _rules2.length; i++) {\n      this.ruler2.push(_rules2[i][0], _rules2[i][1])\n    }\n  }\n\n  // Skip single token by running all rules in validation mode;\n  // returns `true` if any rule reported success\n  //\n  skipToken (state: StateInline): void {\n    const pos = state.pos\n    const rules = this.ruler.getRules('')\n    const len = rules.length\n    const maxNesting = state.md.options.maxNesting\n    const cache = state.cache\n\n    if (typeof cache[pos] !== 'undefined') {\n      state.pos = cache[pos]\n      return\n    }\n\n    let ok = false\n\n    if (state.level < maxNesting) {\n      for (let i = 0; i < len; i++) {\n        // Increment state.level and decrement it later to limit recursion.\n        // It's harmless to do here, because no tokens are created. But ideally,\n        // we'd need a separate private state variable for this purpose.\n        //\n        state.level++\n        ok = rules[i](state, true)\n        state.level--\n\n        if (ok) {\n          if (pos >= state.pos) { throw new Error(\"inline rule didn't increment state.pos\") }\n          break\n        }\n      }\n    } else {\n      // Too much nesting, just skip until the end of the paragraph.\n      //\n      // NOTE: this will cause links to behave incorrectly in the following case,\n      //       when an amount of `[` is exactly equal to `maxNesting + 1`:\n      //\n      //       [[[[[[[[[[[[[[[[[[[[[foo]()\n      //\n      // TODO: remove this workaround when CM standard will allow nested links\n      //       (we can replace it by preventing links from being parsed in\n      //       validation mode)\n      //\n      state.pos = state.posMax\n    }\n\n    if (!ok) { state.pos++ }\n    cache[pos] = state.pos\n  }\n\n  // Generate tokens for input range\n  //\n  tokenize (state: StateInline): void {\n    const rules = this.ruler.getRules('')\n    const len = rules.length\n    const end = state.posMax\n    const maxNesting = state.md.options.maxNesting\n\n    while (state.pos < end) {\n      // Try all possible rules.\n      // On success, rule should:\n      //\n      // - update `state.pos`\n      // - update `state.tokens`\n      // - return true\n      const prevPos = state.pos\n      let ok = false\n\n      if (state.level < maxNesting) {\n        for (let i = 0; i < len; i++) {\n          ok = rules[i](state, false)\n          if (ok) {\n            if (prevPos >= state.pos) { throw new Error(\"inline rule didn't increment state.pos\") }\n            break\n          }\n        }\n      }\n\n      if (ok) {\n        if (state.pos >= end) { break }\n        continue\n      }\n\n      state.pending += state.src[state.pos++]\n    }\n\n    if (state.pending) {\n      state.pushPending()\n    }\n  }\n\n  /**\n   * Process input string and push inline tokens into `outTokens`\n   */\n  parse (str: string, md: MarkdownIt, env: Env, outTokens: Token[]): void {\n    const state = new this.State(str, md, env, outTokens)\n\n    this.tokenize(state)\n\n    const rules = this.ruler2.getRules('')\n    const len = rules.length\n\n    for (let i = 0; i < len; i++) {\n      rules[i](state)\n    }\n  }\n}\n\nexport default ParserInline\n","import { Any, Cc, P, Z } from \"uc.micro\";\n//#region src/rebuilder.ts\nvar REBuilder = class {\n\tsrc_Any = Any.source;\n\tsrc_Cc = Cc.source;\n\tsrc_Z = Z.source;\n\tsrc_P = P.source;\n\tsrc_ZPCc = [\n\t\tthis.src_Z,\n\t\tthis.src_P,\n\t\tthis.src_Cc\n\t].join(\"|\");\n\tsrc_ZCc = [this.src_Z, this.src_Cc].join(\"|\");\n\tcache = {};\n\topts = {\n\t\tmaxLength: 1e4,\n\t\turlAuth: false,\n\t\tschema_names: []\n\t};\n\tconstructor(opts = {}) {\n\t\tthis.opts = {\n\t\t\t...this.opts,\n\t\t\t...opts\n\t\t};\n\t}\n\tset(opts = {}) {\n\t\tthis.opts = {\n\t\t\t...this.opts,\n\t\t\t...opts\n\t\t};\n\t\tthis.cache = {};\n\t\treturn this;\n\t}\n\tescapeRE(str) {\n\t\treturn str.replace(/[.?*+^$[\\]\\\\(){}|-]/g, \"\\\\$&\");\n\t}\n\tnestedPairRE(open, close, depth = 4) {\n\t\tconst openRE = this.escapeRE(open);\n\t\tconst closeRE = this.escapeRE(close);\n\t\tconst atom = `(?:(?!${this.src_ZCc}|${openRE}|${closeRE}).)`;\n\t\tlet pair = `${openRE}${atom}{0,1000}${closeRE}`;\n\t\tfor (let level = 2; level <= depth; level++) pair = `${openRE}(?:${atom}|${pair}){0,1000}${closeRE}`;\n\t\treturn pair;\n\t}\n\tget_text_separators() {\n\t\treturn this.cache.text_separators ??= /[><\\uff5c]/;\n\t}\n\tget_pseudo_letter() {\n\t\treturn this.cache.src_pseudo_letter ??= new RegExp(`(?:(?!${this.get_text_separators().source}|${this.src_ZPCc})${this.src_Any})`);\n\t}\n\tget_ipv4_addr() {\n\t\treturn this.cache.src_ip4 ??= /* @__PURE__ */ new RegExp(\"(?:(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]|[0-9])[.]){3}(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]|[0-9])\");\n\t}\n\tget_ipv6_addr() {\n\t\tconst h16 = \"[0-9A-Fa-f]{1,4}\";\n\t\tconst ls32 = `(?:(?:${h16}:${h16})|${this.get_ipv4_addr().source})`;\n\t\treturn this.cache.src_ip6_addr ??= new RegExp(`(?:(?:${h16}:){6}${ls32}|::(?:${h16}:){5}${ls32}|(?:${h16})?::(?:${h16}:){4}${ls32}|(?:(?:${h16}:){0,1}${h16})?::(?:${h16}:){3}${ls32}|(?:(?:${h16}:){0,2}${h16})?::(?:${h16}:){2}${ls32}|(?:(?:${h16}:){0,3}${h16})?::${h16}:${ls32}|(?:(?:${h16}:){0,4}${h16})?::${ls32}|(?:(?:${h16}:){0,5}${h16})?::${h16}|(?:(?:${h16}:){0,6}${h16})?::)`);\n\t}\n\tget_ipv6_url_host() {\n\t\treturn this.cache.src_ip6_host ??= new RegExp(`\\\\[${this.get_ipv6_addr().source}\\\\]`);\n\t}\n\tget_ipv6_mail_host() {\n\t\treturn this.cache.src_ipv6_mail_host ??= new RegExp(`\\\\[IPv6:${this.get_ipv6_addr().source}\\\\]`);\n\t}\n\tget_auth() {\n\t\treturn this.cache.src_auth ??= new RegExp(`(?:(?:(?!${this.src_ZCc}|[@/\\\\[\\\\]()]).){1,50}@)?`);\n\t}\n\tget_port() {\n\t\treturn this.cache.src_port ??= /* @__PURE__ */ new RegExp(\"(?::(?:6(?:[0-4]\\\\d{3}|5(?:[0-4]\\\\d{2}|5(?:[0-2]\\\\d|3[0-5])))|[1-5]?\\\\d{1,4}))?\");\n\t}\n\tget_host_terminator() {\n\t\treturn this.cache.src_host_terminator ??= new RegExp(`(?=$|${this.get_text_separators().source}|${this.src_ZPCc})(?!${this.opts[\"---\"] ? \"-(?!--)|\" : \"-|\"}_|:\\\\d|\\\\.-|\\\\.(?!$|${this.src_ZPCc}))`);\n\t}\n\tget_path_terminator() {\n\t\treturn this.cache.src_path_terminator ??= new RegExp(`${this.src_ZPCc}|${this.get_text_separators().source}`);\n\t}\n\tget_path() {\n\t\treturn this.cache.src_path ??= new RegExp(`(?:[/?#](?:${this.nestedPairRE(\"[\", \"]\")}|${this.nestedPairRE(\"(\", \")\")}|${this.nestedPairRE(\"{\", \"}\")}|\\\\\"(?:(?!${this.src_ZCc}|[\"]).){1,100}\\\\\"|\\\\'(?:(?!${this.src_ZCc}|[']).){1,100}\\\\'|\\\\'(?=${this.get_pseudo_letter().source}|[-])|\\\\.{2,20}[:]?[a-zA-Z0-9%/&]|\\\\.(?!${this.src_ZCc}|[.]|$)|` + (this.opts[\"---\"] ? \"\\\\-(?!--(?:[^-]|$))(?:-{0,19})|\" : \"\\\\-{1,20}|\") + `,(?!${this.src_ZCc}|$)|;(?!${this.src_ZCc}|$)|\\\\!{1,20}(?!${this.src_ZCc}|[!]|$)|\\\\?(?!${this.src_ZCc}|[?]|$)|` + this.get_path_extra().source + `[\\\\\\\\/:%@#&=_~*]|(?!${this.get_path_terminator().source}).){1,${this.opts.maxLength}}|\\\\/)?`);\n\t}\n\tget_mail_name() {\n\t\treturn this.cache.src_mail_name ??= /* @__PURE__ */ new RegExp(\"[-!#$%&'*+/=?^_`{|}~a-zA-Z0-9](?:[-!#$%&'*+/=?^_`{|}~a-zA-Z0-9]|[.](?=[-!#$%&'*+/=?^_`{|}~a-zA-Z0-9])){0,63}\");\n\t}\n\tget_xn() {\n\t\treturn this.cache.src_xn ??= /* @__PURE__ */ new RegExp(\"xn--[a-z0-9\\\\-]{1,59}\");\n\t}\n\tget_tld() {\n\t\tif (this.cache.tld) return this.cache.tld;\n\t\tconst tlds_src = [...new Set(this.opts.tlds || [])].sort().reverse().join(\"|\");\n\t\tthis.cache.tld = new RegExp(`${tlds_src || \"$#none#$\"}|${this.get_xn().source}`);\n\t\treturn this.cache.tld;\n\t}\n\tget_domain_root() {\n\t\treturn this.cache.src_domain_root ??= new RegExp(\"(?:\" + this.get_xn().source + `|${this.get_pseudo_letter().source}{1,63})`);\n\t}\n\tget_domain() {\n\t\treturn this.cache.src_domain ??= new RegExp(\"(?:\" + this.get_xn().source + `|(?:${this.get_pseudo_letter().source})|(?:${this.get_pseudo_letter().source}(?:-|${this.get_pseudo_letter().source}){0,61}${this.get_pseudo_letter().source}))`);\n\t}\n\tget_url_host_port() {\n\t\treturn this.cache.url_host_port ??= new RegExp(\"(?:\" + this.get_ipv6_url_host().source + `|(?:(?:(?:${this.get_domain().source})\\\\.){0,10}${this.get_domain().source}))` + this.get_port().source + this.get_host_terminator().source);\n\t}\n\tget_fuzzy_url_host_port() {\n\t\treturn this.cache.fuzzy_url_host_port ??= new RegExp(\"(?:\" + (this.opts.fuzzyIP ? this.get_ipv4_addr().source + \"|\" : \"\") + `(?:(?:(?:${this.get_domain().source})\\\\.){1,10}(?:${this.get_tld().source})))` + this.get_host_terminator().source);\n\t}\n\tget_mail_host() {\n\t\treturn this.cache.src_mail_host ??= new RegExp(\"(?:\" + this.get_ipv6_mail_host().source + `|(?:(?:(?:${this.get_domain().source})\\\\.){0,4}${this.get_domain().source}))` + this.get_host_terminator().source);\n\t}\n\tget_fuzzy_mail_host() {\n\t\treturn this.cache.src_fuzzy_mail_host ??= new RegExp(\"(?:\" + this.get_ipv6_mail_host().source + `|(?:(?:(?:${this.get_domain().source})[.]){1,4}${this.get_domain_root().source}))` + this.get_host_terminator().source);\n\t}\n\tget_path_extra() {\n\t\treturn this.cache.src_path_extra ??= /* @__PURE__ */ new RegExp(\"\");\n\t}\n\tget_fuzzy_mail_host_search() {\n\t\treturn this.cache.mail_fuzzy_host_search ??= new RegExp(`@${this.get_fuzzy_mail_host().source}`, \"ig\");\n\t}\n\tget_fuzzy_link_search() {\n\t\treturn this.cache.link_fuzzy_search ??= new RegExp(`(^|(?![.:/\\\\-_@])(?:[$+<=>^\\`|\\uff5c]|${this.src_ZPCc}))(?:(?![$+<=>^\\`|\\uff5c])${this.get_fuzzy_url_host_port().source}${this.get_path().source})`, \"ig\");\n\t}\n\tget_http_validator() {\n\t\treturn this.cache.http_validator ??= new RegExp(\"\\\\/\\\\/\" + (this.opts.urlAuth ? this.get_auth().source : \"\") + this.get_url_host_port().source + this.get_path().source, \"iy\");\n\t}\n\tget_relative_proto_validator() {\n\t\treturn this.cache.relative_proto_validator ??= new RegExp((this.opts.urlAuth ? this.get_auth().source : \"\") + `(?:localhost|${this.get_ipv6_url_host().source}|(?:(?:${this.get_domain().source})[.]){1,10}${this.get_domain_root().source})` + this.get_port().source + this.get_host_terminator().source + this.get_path().source, \"iy\");\n\t}\n\tget_mail_name_validator() {\n\t\treturn this.cache.mail_name_validator ??= new RegExp(`(?:^|${this.get_text_separators().source}|\"|\\\\(|${this.src_ZCc})(${this.get_mail_name().source})$`);\n\t}\n\tget_mailto_validator() {\n\t\treturn this.cache.mailto_validator ??= new RegExp(`${this.get_mail_name().source}@${this.get_mail_host().source}`, \"iy\");\n\t}\n\tget_schema_names() {\n\t\treturn this.cache.schema_names ??= new RegExp((this.opts.schema_names || []).map((name) => this.escapeRE(name)).join(\"|\"));\n\t}\n\tget_schema_search() {\n\t\treturn this.cache.schema_search ??= new RegExp(`(^|(?!_)(?:[><\\uff5c]|${this.src_ZPCc}))(${this.get_schema_names().source})`, \"ig\");\n\t}\n\tget_schema_at_start() {\n\t\treturn this.cache.schema_at_start ??= new RegExp(`^${this.get_schema_search().source}`, \"i\");\n\t}\n};\n//#endregion\n//#region src/linkifyit.ts\nvar web_schema = {\n\tvalidate: (text, pos, self) => {\n\t\tconst re = self.re.get_http_validator();\n\t\tre.lastIndex = pos;\n\t\tconst m = re.exec(text);\n\t\treturn m ? m[0].length : 0;\n\t},\n\tnormalize: (match, self) => self.normalize(match)\n};\nvar defaultSchemas = {\n\t\"http:\": web_schema,\n\t\"https:\": web_schema,\n\t\"ftp:\": web_schema,\n\t\"//\": {\n\t\tvalidate: function(text, pos, self) {\n\t\t\tconst re = self.re.get_relative_proto_validator();\n\t\t\tre.lastIndex = pos;\n\t\t\tconst m = re.exec(text);\n\t\t\tif (m) {\n\t\t\t\tif (pos >= 3 && text[pos - 3] === \":\") return 0;\n\t\t\t\tif (pos >= 3 && text[pos - 3] === \"/\") return 0;\n\t\t\t\treturn m[0].length;\n\t\t\t}\n\t\t\treturn 0;\n\t\t},\n\t\tnormalize: (match, self) => self.normalize(match)\n\t},\n\t\"mailto:\": {\n\t\tvalidate: function(text, pos, self) {\n\t\t\tconst re = self.re.get_mailto_validator();\n\t\t\tre.lastIndex = pos;\n\t\t\tconst m = re.exec(text);\n\t\t\treturn m ? m[0].length : 0;\n\t\t},\n\t\tnormalize: (match, self) => self.normalize(match)\n\t}\n};\nvar tlds_2ch = \"a:cdefgilmnoqrstuwxz|b:abdefghijmnorstvwyz|c:acdfghiklmnoruvwxyz|d:ejkmoz|e:cegrstu|f:ijkmor|g:abdefghilmnpqrstuwy|h:kmnrtu|i:delmnoqrst|j:emop|k:eghimnprwyz|l:abcikrstuvy|m:acdeghklmnopqrstuvwxyz|n:acefgilopruz|o:m|p:aefghklmnrstwy|q:a|r:eosuw|s:abcdeghijklmnortuvxyz|t:cdfghjklmnortvwz|u:agksyz|v:aceginu|w:fs|y:et|z:amw\";\nvar tlds_default = \"biz|com|edu|gov|net|org|pro|web|xxx|aero|asia|coop|info|museum|name|shop|рф\";\nfunction unpackTlds() {\n\tconst result = tlds_default.split(\"|\");\n\ttlds_2ch.split(\"|\").forEach((item) => {\n\t\tconst sep = item.indexOf(\":\");\n\t\tconst prefix = item.slice(0, sep);\n\t\tfor (const suffix of item.slice(sep + 1)) result.push(prefix + suffix);\n\t});\n\treturn result;\n}\nvar defaultOptions = {\n\tfuzzyLink: false,\n\tfuzzyEmail: true,\n\tfuzzyIP: false,\n\t\"---\": false,\n\ttlds: unpackTlds(),\n\turlAuth: false,\n\tmaxLength: 1e4\n};\n/**\n* Match result returned by {@link LinkifyIt.match} and\n* {@link LinkifyIt.matchAtStart}.\n*\n* @category types\n*/\nvar Match = class {\n\t/** Prefix (protocol) for matched string. Empty for fuzzy links. */\n\tschema;\n\t/** First position of matched string. */\n\tindex;\n\t/** Next position after matched string. */\n\tlastIndex;\n\t/** Matched string. */\n\traw;\n\t/** Normalized text of matched string. */\n\ttext;\n\t/** Normalized URL of matched string. */\n\turl;\n\tconstructor(text, schema, index, lastIndex) {\n\t\tconst raw = text.slice(index, lastIndex);\n\t\tthis.schema = schema.toLowerCase();\n\t\tthis.index = index;\n\t\tthis.lastIndex = lastIndex;\n\t\tthis.raw = raw;\n\t\tthis.text = raw;\n\t\tthis.url = raw;\n\t}\n};\n/** Linkifier instance. */\nvar LinkifyIt = class {\n\t__opts__;\n\t__schemas__;\n\tre;\n\t/**\n\t* Creates new linkifier instance.\n\t*\n\t* By default understands:\n\t*\n\t* - `http(s)://...` , `ftp://...`, `mailto:...` & `//...` links\n\t* - \"fuzzy\" emails (foo@bar.com).\n\t*\n\t* See {@link LinkifyConstructorOptions} for available options.\n\t*\n\t* @param options Recognition options.\n\t*\n\t* @example\n\t* ```javascript\n\t* import { LinkifyIt } from 'linkify-it'\n\t*\n\t* const linkify = new LinkifyIt({ fuzzyLink: true })\n\t*\n\t* linkify\n\t*   .tlds(require('tlds'))       // Reload with full TLD list\n\t*   .tlds('onion', true)         // Add unofficial `.onion` domain\n\t*   .add('ftp:', null)           // Disable `ftp:` protocol\n\t*   .set({ fuzzyIP: true })      // Enable IPs in fuzzy links\n\t*\n\t* console.log(linkify.test('Site github.com!')) // true\n\t* console.log(linkify.match('Site github.com!'))\n\t* ```\n\t*/\n\tconstructor(options = {}) {\n\t\tconst { rebuilder, ...linkifyOptions } = options;\n\t\tthis.__opts__ = {\n\t\t\t...defaultOptions,\n\t\t\t...linkifyOptions\n\t\t};\n\t\tthis.__schemas__ = { ...defaultSchemas };\n\t\tthis.re = rebuilder || new REBuilder();\n\t\tthis.re.set({\n\t\t\t...this.__opts__,\n\t\t\tschema_names: Object.keys(this.__schemas__)\n\t\t});\n\t}\n\t/**\n\t* Add new rule definition.\n\t*\n\t* `schema` is a link prefix (usually, protocol name with `:` at the end,\n\t* `skype:` for example). `linkify-it` makes sure that prefix is not\n\t* preceded with alphanumeric char and symbols. Only whitespaces and\n\t* punctuation allowed.\n\t*\n\t* `definition` is a rule to check tail after link prefix. To disable an\n\t* existing rule, pass `null`.\n\t*\n\t* @param schema Rule name (fixed pattern prefix).\n\t* @param definition Schema definition, or `null` to disable the rule.\n\t*\n\t* See [twitter mentions example](https://github.com/markdown-it/linkify-it/blob/master/examples/twitter.mjs).\n\t*/\n\tadd(schema, definition = null) {\n\t\tif (!definition) delete this.__schemas__[schema];\n\t\telse {\n\t\t\tconst def = {\n\t\t\t\tnormalize: (match, self) => self.normalize(match),\n\t\t\t\t...definition\n\t\t\t};\n\t\t\tthis.__schemas__[schema] = def;\n\t\t}\n\t\tthis.re.set({\n\t\t\t...this.__opts__,\n\t\t\tschema_names: Object.keys(this.__schemas__)\n\t\t});\n\t\treturn this;\n\t}\n\t/**\n\t* Set recognition options for links without schema.\n\t*\n\t* @param options Recognition options.\n\t*/\n\tset(options = {}) {\n\t\tthis.__opts__ = {\n\t\t\t...this.__opts__,\n\t\t\t...options\n\t\t};\n\t\tthis.re.set({\n\t\t\t...this.__opts__,\n\t\t\tschema_names: Object.keys(this.__schemas__)\n\t\t});\n\t\treturn this;\n\t}\n\t/**\n\t* Searches linkifiable pattern and returns `true` on success or `false` on fail.\n\t*\n\t* @param text Text to scan.\n\t*/\n\ttest(text) {\n\t\tif (!text.length) return false;\n\t\tlet m, re;\n\t\tre = this.re.get_schema_search();\n\t\tre.lastIndex = 0;\n\t\twhile ((m = re.exec(text)) !== null) if (this.testSchemaAt(text, m[2], re.lastIndex)) return true;\n\t\tif (this.__opts__.fuzzyLink && this.__schemas__[\"http:\"]) {\n\t\t\tre = this.re.get_fuzzy_link_search();\n\t\t\tre.lastIndex = 0;\n\t\t\tif (re.exec(text) !== null) return true;\n\t\t}\n\t\tif (this.__opts__.fuzzyEmail && this.__schemas__[\"mailto:\"]) {\n\t\t\tif (text.indexOf(\"@\") >= 0) {\n\t\t\t\tconst mailHostRe = this.re.get_fuzzy_mail_host_search();\n\t\t\t\tconst mailNameRe = this.re.get_mail_name_validator();\n\t\t\t\tmailHostRe.lastIndex = 0;\n\t\t\t\twhile ((m = mailHostRe.exec(text)) !== null) {\n\t\t\t\t\tconst name = text.slice(Math.max(0, m.index - 65), m.index);\n\t\t\t\t\tif (mailNameRe.test(name)) return true;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn false;\n\t}\n\t/**\n\t* Similar to {@link LinkifyIt.test} but checks only specific protocol tail exactly\n\t* at given position. Returns length of found pattern (0 on fail).\n\t*\n\t* @param text Text to scan.\n\t* @param schema Rule (schema) name.\n\t* @param pos Text offset to check from.\n\t*/\n\ttestSchemaAt(text, schema, pos) {\n\t\tif (!this.__schemas__[schema.toLowerCase()]) return 0;\n\t\treturn this.__schemas__[schema.toLowerCase()].validate(text.slice(0, pos + this.__opts__.maxLength), pos, this);\n\t}\n\t/**\n\t* Returns array of found link descriptions or `null` on fail. We strongly\n\t* recommend to use {@link LinkifyIt.test} first, for best speed.\n\t*\n\t* @param text Text to scan.\n\t*/\n\tmatch(text) {\n\t\tconst result = [];\n\t\tconst schemaRe = this.re.get_schema_search();\n\t\tlet fuzzyLinkRe;\n\t\tlet mailHostRe;\n\t\tlet mailNameRe;\n\t\tlet fuzzyLinkCandidate;\n\t\tlet fuzzyEmailCandidate;\n\t\tlet schemaPrefix;\n\t\tlet schemaDone = false;\n\t\tlet fuzzyLinkDone = false;\n\t\tlet fuzzyEmailDone = false;\n\t\tlet pos = 0;\n\t\tif (!text.length) return null;\n\t\tschemaRe.lastIndex = 0;\n\t\tif (this.__opts__.fuzzyLink && this.__schemas__[\"http:\"]) {\n\t\t\tfuzzyLinkRe = this.re.get_fuzzy_link_search();\n\t\t\tfuzzyLinkRe.lastIndex = 0;\n\t\t}\n\t\tif (this.__opts__.fuzzyEmail && this.__schemas__[\"mailto:\"]) {\n\t\t\tmailHostRe = this.re.get_fuzzy_mail_host_search();\n\t\t\tmailHostRe.lastIndex = 0;\n\t\t\tmailNameRe = this.re.get_mail_name_validator();\n\t\t}\n\t\tfor (;;) {\n\t\t\tconst scanFrom = Math.max(pos - 1, 0);\n\t\t\tif (mailHostRe && mailNameRe && !fuzzyEmailDone && (!fuzzyEmailCandidate || fuzzyEmailCandidate.index < pos)) {\n\t\t\t\tif (mailHostRe.lastIndex < scanFrom) mailHostRe.lastIndex = scanFrom;\n\t\t\t\tfor (;;) {\n\t\t\t\t\tconst m = mailHostRe.exec(text);\n\t\t\t\t\tif (!m) {\n\t\t\t\t\t\tfuzzyEmailDone = true;\n\t\t\t\t\t\tfuzzyEmailCandidate = void 0;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t\tconst name = mailNameRe.exec(text.slice(Math.max(0, m.index - 65), m.index));\n\t\t\t\t\tif (!name) continue;\n\t\t\t\t\tfuzzyEmailCandidate = {\n\t\t\t\t\t\tschema: \"mailto:\",\n\t\t\t\t\t\tindex: m.index - name[1].length,\n\t\t\t\t\t\tlastIndex: m.index + m[0].length\n\t\t\t\t\t};\n\t\t\t\t\tif (fuzzyEmailCandidate.index >= pos) break;\n\t\t\t\t\tif (mailHostRe.lastIndex < scanFrom) mailHostRe.lastIndex = scanFrom;\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (fuzzyLinkRe && !fuzzyLinkDone && (!fuzzyLinkCandidate || fuzzyLinkCandidate.index < pos)) {\n\t\t\t\tif (fuzzyLinkRe.lastIndex < scanFrom) fuzzyLinkRe.lastIndex = scanFrom;\n\t\t\t\tfor (;;) {\n\t\t\t\t\tconst m = fuzzyLinkRe.exec(text);\n\t\t\t\t\tif (!m) {\n\t\t\t\t\t\tfuzzyLinkDone = true;\n\t\t\t\t\t\tfuzzyLinkCandidate = void 0;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t\tfuzzyLinkCandidate = {\n\t\t\t\t\t\tschema: \"\",\n\t\t\t\t\t\tindex: m.index + m[1].length,\n\t\t\t\t\t\tlastIndex: m.index + m[0].length\n\t\t\t\t\t};\n\t\t\t\t\tif (fuzzyLinkCandidate.index >= pos) break;\n\t\t\t\t\tif (fuzzyLinkRe.lastIndex < scanFrom) fuzzyLinkRe.lastIndex = scanFrom;\n\t\t\t\t}\n\t\t\t}\n\t\t\tlet fuzzyCandidate = fuzzyEmailCandidate;\n\t\t\tif (!fuzzyCandidate || fuzzyLinkCandidate && (fuzzyLinkCandidate.index < fuzzyCandidate.index || fuzzyLinkCandidate.index === fuzzyCandidate.index && fuzzyLinkCandidate.lastIndex > fuzzyCandidate.lastIndex)) fuzzyCandidate = fuzzyLinkCandidate;\n\t\t\tlet schemaCandidate;\n\t\t\tif (!schemaDone) for (;;) {\n\t\t\t\tif (!schemaPrefix) {\n\t\t\t\t\tif (schemaRe.lastIndex < scanFrom) schemaRe.lastIndex = scanFrom;\n\t\t\t\t\tconst m = schemaRe.exec(text);\n\t\t\t\t\tif (!m) {\n\t\t\t\t\t\tschemaDone = true;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t\tschemaPrefix = {\n\t\t\t\t\t\tschema: m[2],\n\t\t\t\t\t\tindex: m.index + m[1].length,\n\t\t\t\t\t\tlastIndex: m.index + m[0].length\n\t\t\t\t\t};\n\t\t\t\t}\n\t\t\t\tif (schemaPrefix.index < pos) {\n\t\t\t\t\tschemaPrefix = void 0;\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tif (fuzzyCandidate && schemaPrefix.index > fuzzyCandidate.index) break;\n\t\t\t\tconst prefix = schemaPrefix;\n\t\t\t\tschemaPrefix = void 0;\n\t\t\t\tconst len = this.testSchemaAt(text, prefix.schema, prefix.lastIndex);\n\t\t\t\tif (len) {\n\t\t\t\t\tschemaCandidate = {\n\t\t\t\t\t\tschema: prefix.schema,\n\t\t\t\t\t\tindex: prefix.index,\n\t\t\t\t\t\tlastIndex: prefix.lastIndex + len\n\t\t\t\t\t};\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\tlet candidate = schemaCandidate;\n\t\t\tif (!candidate || fuzzyEmailCandidate && (fuzzyEmailCandidate.index < candidate.index || fuzzyEmailCandidate.index === candidate.index && fuzzyEmailCandidate.lastIndex > candidate.lastIndex)) candidate = fuzzyEmailCandidate;\n\t\t\tif (!candidate || fuzzyLinkCandidate && (fuzzyLinkCandidate.index < candidate.index || fuzzyLinkCandidate.index === candidate.index && fuzzyLinkCandidate.lastIndex > candidate.lastIndex)) candidate = fuzzyLinkCandidate;\n\t\t\tif (!candidate) break;\n\t\t\tif (candidate === fuzzyEmailCandidate) fuzzyEmailCandidate = void 0;\n\t\t\telse if (candidate === fuzzyLinkCandidate) fuzzyLinkCandidate = void 0;\n\t\t\tconst match = new Match(text, candidate.schema, candidate.index, candidate.lastIndex);\n\t\t\tif (match.schema) this.__schemas__[match.schema].normalize(match, this);\n\t\t\telse this.normalize(match);\n\t\t\tresult.push(match);\n\t\t\tpos = candidate.lastIndex;\n\t\t}\n\t\tif (result.length) return result;\n\t\treturn null;\n\t}\n\t/**\n\t* Returns fully-formed (not fuzzy) link if it starts at the beginning\n\t* of the string, and null otherwise.\n\t*\n\t* @param text Text to scan.\n\t*/\n\tmatchAtStart(text) {\n\t\tif (!text.length) return null;\n\t\tconst m = this.re.get_schema_at_start().exec(text);\n\t\tif (!m) return null;\n\t\tconst len = this.testSchemaAt(text, m[2], m[0].length);\n\t\tif (!len) return null;\n\t\tconst match = new Match(text, m[2], m.index + m[1].length, m.index + m[0].length + len);\n\t\tthis.__schemas__[match.schema].normalize(match, this);\n\t\treturn match;\n\t}\n\t/**\n\t* Load (or merge) new TLDs list. Those are used for fuzzy links (without\n\t* prefix) to avoid false positives. By default this algorithm is used:\n\t*\n\t* - hostname with any 2-letter root zones are ok.\n\t* - biz|com|edu|gov|net|org|pro|web|xxx|aero|asia|coop|info|museum|name|shop|рф\n\t*   are ok.\n\t* - encoded (`xn--...`) root zones are ok.\n\t*\n\t* If list is replaced, then exact match for 2-chars root zones will be checked.\n\t*\n\t* @param list List of TLDs.\n\t* @param keepOld Merge with current list if `true` (`false` by default).\n\t*/\n\ttlds(list, keepOld = false) {\n\t\tlist = Array.isArray(list) ? list : [list];\n\t\tif (!keepOld) this.__opts__.tlds = list;\n\t\telse this.__opts__.tlds = this.__opts__.tlds.concat(list);\n\t\tthis.re.set({\n\t\t\t...this.__opts__,\n\t\t\tschema_names: Object.keys(this.__schemas__)\n\t\t});\n\t\treturn this;\n\t}\n\t/**\n\t* Default normalizer (if schema does not define its own).\n\t*\n\t* @param match Match to normalize.\n\t*/\n\tnormalize(match) {\n\t\tif (!match.schema) match.url = `http://${match.url}`;\n\t\tif (match.schema === \"mailto:\" && !/^mailto:/i.test(match.url)) match.url = `mailto:${match.url}`;\n\t}\n};\nfunction linkifyit(options = {}) {\n\treturn new LinkifyIt(options);\n}\n//#endregion\nexport { LinkifyIt, REBuilder, linkifyit };\n\n//# sourceMappingURL=index.mjs.map","'use strict';\n\n/** Highest positive signed 32-bit float value */\nconst maxInt = 2147483647; // aka. 0x7FFFFFFF or 2^31-1\n\n/** Bootstring parameters */\nconst base = 36;\nconst tMin = 1;\nconst tMax = 26;\nconst skew = 38;\nconst damp = 700;\nconst initialBias = 72;\nconst initialN = 128; // 0x80\nconst delimiter = '-'; // '\\x2D'\n\n/** Regular expressions */\nconst regexPunycode = /^xn--/;\nconst regexNonASCII = /[^\\0-\\x7F]/; // Note: U+007F DEL is excluded too.\nconst regexSeparators = /[\\x2E\\u3002\\uFF0E\\uFF61]/g; // RFC 3490 separators\n\n/** Error messages */\nconst errors = {\n\t'overflow': 'Overflow: input needs wider integers to process',\n\t'not-basic': 'Illegal input >= 0x80 (not a basic code point)',\n\t'invalid-input': 'Invalid input'\n};\n\n/** Convenience shortcuts */\nconst baseMinusTMin = base - tMin;\nconst floor = Math.floor;\nconst stringFromCharCode = String.fromCharCode;\n\n/*--------------------------------------------------------------------------*/\n\n/**\n * A generic error utility function.\n * @private\n * @param {String} type The error type.\n * @returns {Error} Throws a `RangeError` with the applicable error message.\n */\nfunction error(type) {\n\tthrow new RangeError(errors[type]);\n}\n\n/**\n * A generic `Array#map` utility function.\n * @private\n * @param {Array} array The array to iterate over.\n * @param {Function} callback The function that gets called for every array\n * item.\n * @returns {Array} A new array of values returned by the callback function.\n */\nfunction map(array, callback) {\n\tconst result = [];\n\tlet length = array.length;\n\twhile (length--) {\n\t\tresult[length] = callback(array[length]);\n\t}\n\treturn result;\n}\n\n/**\n * A simple `Array#map`-like wrapper to work with domain name strings or email\n * addresses.\n * @private\n * @param {String} domain The domain name or email address.\n * @param {Function} callback The function that gets called for every\n * character.\n * @returns {String} A new string of characters returned by the callback\n * function.\n */\nfunction mapDomain(domain, callback) {\n\tconst parts = domain.split('@');\n\tlet result = '';\n\tif (parts.length > 1) {\n\t\t// In email addresses, only the domain name should be punycoded. Leave\n\t\t// the local part (i.e. everything up to `@`) intact.\n\t\tresult = parts[0] + '@';\n\t\tdomain = parts[1];\n\t}\n\t// Avoid `split(regex)` for IE8 compatibility. See #17.\n\tdomain = domain.replace(regexSeparators, '\\x2E');\n\tconst labels = domain.split('.');\n\tconst encoded = map(labels, callback).join('.');\n\treturn result + encoded;\n}\n\n/**\n * Creates an array containing the numeric code points of each Unicode\n * character in the string. While JavaScript uses UCS-2 internally,\n * this function will convert a pair of surrogate halves (each of which\n * UCS-2 exposes as separate characters) into a single code point,\n * matching UTF-16.\n * @see `punycode.ucs2.encode`\n * @see <https://mathiasbynens.be/notes/javascript-encoding>\n * @memberOf punycode.ucs2\n * @name decode\n * @param {String} string The Unicode input string (UCS-2).\n * @returns {Array} The new array of code points.\n */\nfunction ucs2decode(string) {\n\tconst output = [];\n\tlet counter = 0;\n\tconst length = string.length;\n\twhile (counter < length) {\n\t\tconst value = string.charCodeAt(counter++);\n\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t// It's a high surrogate, and there is a next character.\n\t\t\tconst extra = string.charCodeAt(counter++);\n\t\t\tif ((extra & 0xFC00) == 0xDC00) { // Low surrogate.\n\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t} else {\n\t\t\t\t// It's an unmatched surrogate; only append this code unit, in case the\n\t\t\t\t// next code unit is the high surrogate of a surrogate pair.\n\t\t\t\toutput.push(value);\n\t\t\t\tcounter--;\n\t\t\t}\n\t\t} else {\n\t\t\toutput.push(value);\n\t\t}\n\t}\n\treturn output;\n}\n\n/**\n * Creates a string based on an array of numeric code points.\n * @see `punycode.ucs2.decode`\n * @memberOf punycode.ucs2\n * @name encode\n * @param {Array} codePoints The array of numeric code points.\n * @returns {String} The new Unicode string (UCS-2).\n */\nconst ucs2encode = codePoints => String.fromCodePoint(...codePoints);\n\n/**\n * Converts a basic code point into a digit/integer.\n * @see `digitToBasic()`\n * @private\n * @param {Number} codePoint The basic numeric code point value.\n * @returns {Number} The numeric value of a basic code point (for use in\n * representing integers) in the range `0` to `base - 1`, or `base` if\n * the code point does not represent a value.\n */\nconst basicToDigit = function(codePoint) {\n\tif (codePoint >= 0x30 && codePoint < 0x3A) {\n\t\treturn 26 + (codePoint - 0x30);\n\t}\n\tif (codePoint >= 0x41 && codePoint < 0x5B) {\n\t\treturn codePoint - 0x41;\n\t}\n\tif (codePoint >= 0x61 && codePoint < 0x7B) {\n\t\treturn codePoint - 0x61;\n\t}\n\treturn base;\n};\n\n/**\n * Converts a digit/integer into a basic code point.\n * @see `basicToDigit()`\n * @private\n * @param {Number} digit The numeric value of a basic code point.\n * @returns {Number} The basic code point whose value (when used for\n * representing integers) is `digit`, which needs to be in the range\n * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is\n * used; else, the lowercase form is used. The behavior is undefined\n * if `flag` is non-zero and `digit` has no uppercase form.\n */\nconst digitToBasic = function(digit, flag) {\n\t//  0..25 map to ASCII a..z or A..Z\n\t// 26..35 map to ASCII 0..9\n\treturn digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);\n};\n\n/**\n * Bias adaptation function as per section 3.4 of RFC 3492.\n * https://tools.ietf.org/html/rfc3492#section-3.4\n * @private\n */\nconst adapt = function(delta, numPoints, firstTime) {\n\tlet k = 0;\n\tdelta = firstTime ? floor(delta / damp) : delta >> 1;\n\tdelta += floor(delta / numPoints);\n\tfor (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {\n\t\tdelta = floor(delta / baseMinusTMin);\n\t}\n\treturn floor(k + (baseMinusTMin + 1) * delta / (delta + skew));\n};\n\n/**\n * Converts a Punycode string of ASCII-only symbols to a string of Unicode\n * symbols.\n * @memberOf punycode\n * @param {String} input The Punycode string of ASCII-only symbols.\n * @returns {String} The resulting string of Unicode symbols.\n */\nconst decode = function(input) {\n\t// Don't use UCS-2.\n\tconst output = [];\n\tconst inputLength = input.length;\n\tlet i = 0;\n\tlet n = initialN;\n\tlet bias = initialBias;\n\n\t// Handle the basic code points: let `basic` be the number of input code\n\t// points before the last delimiter, or `0` if there is none, then copy\n\t// the first basic code points to the output.\n\n\tlet basic = input.lastIndexOf(delimiter);\n\tif (basic < 0) {\n\t\tbasic = 0;\n\t}\n\n\tfor (let j = 0; j < basic; ++j) {\n\t\t// if it's not a basic code point\n\t\tif (input.charCodeAt(j) >= 0x80) {\n\t\t\terror('not-basic');\n\t\t}\n\t\toutput.push(input.charCodeAt(j));\n\t}\n\n\t// Main decoding loop: start just after the last delimiter if any basic code\n\t// points were copied; start at the beginning otherwise.\n\n\tfor (let index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {\n\n\t\t// `index` is the index of the next character to be consumed.\n\t\t// Decode a generalized variable-length integer into `delta`,\n\t\t// which gets added to `i`. The overflow checking is easier\n\t\t// if we increase `i` as we go, then subtract off its starting\n\t\t// value at the end to obtain `delta`.\n\t\tconst oldi = i;\n\t\tfor (let w = 1, k = base; /* no condition */; k += base) {\n\n\t\t\tif (index >= inputLength) {\n\t\t\t\terror('invalid-input');\n\t\t\t}\n\n\t\t\tconst digit = basicToDigit(input.charCodeAt(index++));\n\n\t\t\tif (digit >= base) {\n\t\t\t\terror('invalid-input');\n\t\t\t}\n\t\t\tif (digit > floor((maxInt - i) / w)) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\ti += digit * w;\n\t\t\tconst t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\n\t\t\tif (digit < t) {\n\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\tconst baseMinusT = base - t;\n\t\t\tif (w > floor(maxInt / baseMinusT)) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\tw *= baseMinusT;\n\n\t\t}\n\n\t\tconst out = output.length + 1;\n\t\tbias = adapt(i - oldi, out, oldi == 0);\n\n\t\t// `i` was supposed to wrap around from `out` to `0`,\n\t\t// incrementing `n` each time, so we'll fix that now:\n\t\tif (floor(i / out) > maxInt - n) {\n\t\t\terror('overflow');\n\t\t}\n\n\t\tn += floor(i / out);\n\t\ti %= out;\n\n\t\t// Insert `n` at position `i` of the output.\n\t\toutput.splice(i++, 0, n);\n\n\t}\n\n\treturn String.fromCodePoint(...output);\n};\n\n/**\n * Converts a string of Unicode symbols (e.g. a domain name label) to a\n * Punycode string of ASCII-only symbols.\n * @memberOf punycode\n * @param {String} input The string of Unicode symbols.\n * @returns {String} The resulting Punycode string of ASCII-only symbols.\n */\nconst encode = function(input) {\n\tconst output = [];\n\n\t// Convert the input in UCS-2 to an array of Unicode code points.\n\tinput = ucs2decode(input);\n\n\t// Cache the length.\n\tconst inputLength = input.length;\n\n\t// Initialize the state.\n\tlet n = initialN;\n\tlet delta = 0;\n\tlet bias = initialBias;\n\n\t// Handle the basic code points.\n\tfor (const currentValue of input) {\n\t\tif (currentValue < 0x80) {\n\t\t\toutput.push(stringFromCharCode(currentValue));\n\t\t}\n\t}\n\n\tconst basicLength = output.length;\n\tlet handledCPCount = basicLength;\n\n\t// `handledCPCount` is the number of code points that have been handled;\n\t// `basicLength` is the number of basic code points.\n\n\t// Finish the basic string with a delimiter unless it's empty.\n\tif (basicLength) {\n\t\toutput.push(delimiter);\n\t}\n\n\t// Main encoding loop:\n\twhile (handledCPCount < inputLength) {\n\n\t\t// All non-basic code points < n have been handled already. Find the next\n\t\t// larger one:\n\t\tlet m = maxInt;\n\t\tfor (const currentValue of input) {\n\t\t\tif (currentValue >= n && currentValue < m) {\n\t\t\t\tm = currentValue;\n\t\t\t}\n\t\t}\n\n\t\t// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,\n\t\t// but guard against overflow.\n\t\tconst handledCPCountPlusOne = handledCPCount + 1;\n\t\tif (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {\n\t\t\terror('overflow');\n\t\t}\n\n\t\tdelta += (m - n) * handledCPCountPlusOne;\n\t\tn = m;\n\n\t\tfor (const currentValue of input) {\n\t\t\tif (currentValue < n && ++delta > maxInt) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\t\t\tif (currentValue === n) {\n\t\t\t\t// Represent delta as a generalized variable-length integer.\n\t\t\t\tlet q = delta;\n\t\t\t\tfor (let k = base; /* no condition */; k += base) {\n\t\t\t\t\tconst t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\t\t\t\t\tif (q < t) {\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t\tconst qMinusT = q - t;\n\t\t\t\t\tconst baseMinusT = base - t;\n\t\t\t\t\toutput.push(\n\t\t\t\t\t\tstringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))\n\t\t\t\t\t);\n\t\t\t\t\tq = floor(qMinusT / baseMinusT);\n\t\t\t\t}\n\n\t\t\t\toutput.push(stringFromCharCode(digitToBasic(q, 0)));\n\t\t\t\tbias = adapt(delta, handledCPCountPlusOne, handledCPCount === basicLength);\n\t\t\t\tdelta = 0;\n\t\t\t\t++handledCPCount;\n\t\t\t}\n\t\t}\n\n\t\t++delta;\n\t\t++n;\n\n\t}\n\treturn output.join('');\n};\n\n/**\n * Converts a Punycode string representing a domain name or an email address\n * to Unicode. Only the Punycoded parts of the input will be converted, i.e.\n * it doesn't matter if you call it on a string that has already been\n * converted to Unicode.\n * @memberOf punycode\n * @param {String} input The Punycoded domain name or email address to\n * convert to Unicode.\n * @returns {String} The Unicode representation of the given Punycode\n * string.\n */\nconst toUnicode = function(input) {\n\treturn mapDomain(input, function(string) {\n\t\treturn regexPunycode.test(string)\n\t\t\t? decode(string.slice(4).toLowerCase())\n\t\t\t: string;\n\t});\n};\n\n/**\n * Converts a Unicode string representing a domain name or an email address to\n * Punycode. Only the non-ASCII parts of the domain name will be converted,\n * i.e. it doesn't matter if you call it with a domain that's already in\n * ASCII.\n * @memberOf punycode\n * @param {String} input The domain name or email address to convert, as a\n * Unicode string.\n * @returns {String} The Punycode representation of the given domain name or\n * email address.\n */\nconst toASCII = function(input) {\n\treturn mapDomain(input, function(string) {\n\t\treturn regexNonASCII.test(string)\n\t\t\t? 'xn--' + encode(string)\n\t\t\t: string;\n\t});\n};\n\n/*--------------------------------------------------------------------------*/\n\n/** Define the public API */\nconst punycode = {\n\t/**\n\t * A string representing the current Punycode.js version number.\n\t * @memberOf punycode\n\t * @type String\n\t */\n\t'version': '2.3.1',\n\t/**\n\t * An object of methods to convert from JavaScript's internal character\n\t * representation (UCS-2) to Unicode code points, and back.\n\t * @see <https://mathiasbynens.be/notes/javascript-encoding>\n\t * @memberOf punycode\n\t * @type Object\n\t */\n\t'ucs2': {\n\t\t'decode': ucs2decode,\n\t\t'encode': ucs2encode\n\t},\n\t'decode': decode,\n\t'encode': encode,\n\t'toASCII': toASCII,\n\t'toUnicode': toUnicode\n};\n\nexport { ucs2decode, ucs2encode, decode, encode, toASCII, toUnicode };\nexport default punycode;\n","// markdown-it default options\n\nimport type { MarkdownItOptions } from '../types.ts'\n\nconst options: Required<MarkdownItOptions> = {\n  // Enable HTML tags in source\n  html: false,\n\n  // Use '/' to close single tags (<br />)\n  xhtmlOut: false,\n\n  // Convert '\\n' in paragraphs into <br>\n  breaks: false,\n\n  // CSS language prefix for fenced blocks\n  langPrefix: 'language-',\n\n  // autoconvert URL-like texts to links\n  linkify: false,\n\n  // Enable some language-neutral replacements + quotes beautification\n  typographer: false,\n\n  // Double + single quotes replacement pairs, when typographer enabled,\n  // and smartquotes on. Could be either a String or an Array.\n  //\n  // For example, you can use '«»„“' for Russian, '„“‚‘' for German,\n  // and ['«\\xA0', '\\xA0»', '‹\\xA0', '\\xA0›'] for French (including nbsp).\n  quotes: '\\u201c\\u201d\\u2018\\u2019', /* “”‘’ */\n\n  // Highlighter function. Should return escaped HTML,\n  // or '' if the source string is not changed and should be escaped externaly.\n  // If result starts with <pre... internal wrapper is skipped.\n  //\n  // function (/*str, lang*/) { return ''; }\n  //\n  highlight: null,\n\n  // Internal protection, recursion limit\n  maxNesting: 100\n}\n\nexport default {\n  options,\n\n  components: {\n    core: {},\n    block: {},\n    inline: {}\n  }\n}\n","// \"Zero\" preset, with nothing enabled. Useful for manual configuring of simple\n// modes. For example, to parse bold/italic only.\n\nimport type { MarkdownItOptions } from '../types.ts'\n\nconst options: Required<MarkdownItOptions> = {\n  // Enable HTML tags in source\n  html: false,\n\n  // Use '/' to close single tags (<br />)\n  xhtmlOut: false,\n\n  // Convert '\\n' in paragraphs into <br>\n  breaks: false,\n\n  // CSS language prefix for fenced blocks\n  langPrefix: 'language-',\n\n  // autoconvert URL-like texts to links\n  linkify: false,\n\n  // Enable some language-neutral replacements + quotes beautification\n  typographer: false,\n\n  // Double + single quotes replacement pairs, when typographer enabled,\n  // and smartquotes on. Could be either a String or an Array.\n  //\n  // For example, you can use '«»„“' for Russian, '„“‚‘' for German,\n  // and ['«\\xA0', '\\xA0»', '‹\\xA0', '\\xA0›'] for French (including nbsp).\n  quotes: '\\u201c\\u201d\\u2018\\u2019', /* “”‘’ */\n\n  // Highlighter function. Should return escaped HTML,\n  // or '' if the source string is not changed and should be escaped externaly.\n  // If result starts with <pre... internal wrapper is skipped.\n  //\n  // function (/*str, lang*/) { return ''; }\n  //\n  highlight: null,\n\n  // Internal protection, recursion limit\n  maxNesting: 20\n}\n\nexport default {\n  options,\n\n  components: {\n\n    core: {\n      rules: [\n        'normalize',\n        'block',\n        'strip_references',\n        'inline',\n        'text_join'\n      ]\n    },\n\n    block: {\n      rules: [\n        'paragraph'\n      ]\n    },\n\n    inline: {\n      rules: [\n        'text'\n      ],\n      rules2: [\n        'balance_pairs',\n        'fragments_join'\n      ]\n    }\n  }\n}\n","// Commonmark default options\n\nimport type { MarkdownItOptions } from '../types.ts'\n\nconst options: Required<MarkdownItOptions> = {\n  // Enable HTML tags in source\n  html: true,\n\n  // Use '/' to close single tags (<br />)\n  xhtmlOut: true,\n\n  // Convert '\\n' in paragraphs into <br>\n  breaks: false,\n\n  // CSS language prefix for fenced blocks\n  langPrefix: 'language-',\n\n  // autoconvert URL-like texts to links\n  linkify: false,\n\n  // Enable some language-neutral replacements + quotes beautification\n  typographer: false,\n\n  // Double + single quotes replacement pairs, when typographer enabled,\n  // and smartquotes on. Could be either a String or an Array.\n  //\n  // For example, you can use '«»„“' for Russian, '„“‚‘' for German,\n  // and ['«\\xA0', '\\xA0»', '‹\\xA0', '\\xA0›'] for French (including nbsp).\n  quotes: '\\u201c\\u201d\\u2018\\u2019', /* “”‘’ */\n\n  // Highlighter function. Should return escaped HTML,\n  // or '' if the source string is not changed and should be escaped externaly.\n  // If result starts with <pre... internal wrapper is skipped.\n  //\n  // function (/*str, lang*/) { return ''; }\n  //\n  highlight: null,\n\n  // Internal protection, recursion limit\n  maxNesting: 20\n}\n\nexport default {\n  options,\n\n  components: {\n\n    core: {\n      rules: [\n        'normalize',\n        'block',\n        'strip_references',\n        'inline',\n        'text_join'\n      ]\n    },\n\n    block: {\n      rules: [\n        'blockquote',\n        'code',\n        'fence',\n        'heading',\n        'hr',\n        'html_block',\n        'lheading',\n        'list',\n        'reference',\n        'paragraph'\n      ]\n    },\n\n    inline: {\n      rules: [\n        'autolink',\n        'backticks',\n        'emphasis',\n        'entity',\n        'escape',\n        'html_inline',\n        'image',\n        'link',\n        'newline',\n        'text'\n      ],\n      rules2: [\n        'balance_pairs',\n        'emphasis',\n        'fragments_join'\n      ]\n    }\n  }\n}\n","// Main parser class\n\nimport * as utils from './common/utils.ts'\nimport * as helpers from './helpers/index.ts'\nimport Token from './token.ts'\nimport Ruler from './ruler.ts'\nimport Renderer from './renderer.ts'\nimport ParserCore from './parser_core.ts'\nimport StateCore from './rules_core/state_core.ts'\nimport ParserBlock from './parser_block.ts'\nimport StateBlock from './rules_block/state_block.ts'\nimport ParserInline from './parser_inline.ts'\nimport StateInline from './rules_inline/state_inline.ts'\nimport { LinkifyIt } from 'linkify-it'\nimport * as mdurl from 'mdurl'\nimport punycode from 'punycode.js'\n\nimport cfg_default from './presets/default.ts'\nimport cfg_zero from './presets/zero.ts'\nimport cfg_commonmark from './presets/commonmark.ts'\nimport type { Env, MarkdownItOptions } from './types.ts'\n\nconst config = {\n  default: cfg_default,\n  zero: cfg_zero,\n  commonmark: cfg_commonmark\n}\n\ntype MarkdownItPresetName = keyof typeof config\n\n/**\n * Parser preset containing options and enabled rules for each parser component.\n */\nexport interface MarkdownItPreset {\n  options?: Required<MarkdownItOptions>\n  components?: {\n    core?: {\n      rules?: string[]\n    }\n    block?: {\n      rules?: string[]\n    }\n    inline?: {\n      rules?: string[]\n      rules2?: string[]\n    }\n  }\n}\n\ntype MarkdownItComponentName = keyof NonNullable<MarkdownItPreset['components']>\n\n//\n// This validator can prohibit more than really needed to prevent XSS. It's a\n// tradeoff to keep code simple and to be secure by default.\n//\n// If you need different setup - override validator method as you wish. Or\n// replace it with dummy function and use external sanitizer.\n//\n\nconst BAD_PROTO_RE = /^(vbscript|javascript|file|data):/\nconst GOOD_DATA_RE = /^data:image\\/(gif|png|jpeg|webp);/\n\nconst RECODE_HOSTNAME_FOR = ['http:', 'https:', 'mailto:']\n\n/**\n * Parses Markdown into tokens and renders them to HTML.\n *\n * @category Main\n */\nclass MarkdownIt {\n  /**\n   * Instance of {@link ParserInline}. You may need it to add new rules when\n   * writing plugins. For simple rules control use {@link MarkdownIt.disable}\n   * and {@link MarkdownIt.enable}.\n   */\n  inline = new ParserInline()\n\n  /**\n   * Instance of {@link ParserBlock}. You may need it to add new rules when\n   * writing plugins. For simple rules control use {@link MarkdownIt.disable}\n   * and {@link MarkdownIt.enable}.\n   */\n  block = new ParserBlock()\n\n  /**\n   * Instance of {@link ParserCore} chain executor. You may need it to add new\n   * rules when writing plugins. For simple rules control use\n   * {@link MarkdownIt.disable} and {@link MarkdownIt.enable}.\n   */\n  core = new ParserCore()\n\n  /**\n   * Instance of {@link Renderer}. Use it to modify output look. Or to add rendering\n   * rules for new token types, generated by plugins.\n   *\n   * See {@link Renderer} docs and\n   * [source code](https://github.com/markdown-it/markdown-it/blob/master/src/renderer.ts).\n   *\n   * @example\n   * ```javascript\n   * import MarkdownIt from 'markdown-it'\n   * const md = new MarkdownIt()\n   *\n   * function myToken(tokens, idx, options, env, self) {\n   *   //...\n   *   return result;\n   * };\n   *\n   * md.renderer.rules['my_token'] = myToken\n   * ```\n   */\n  renderer = new Renderer()\n\n  /**\n   * [linkify-it](https://github.com/markdown-it/linkify-it) instance.\n   * Used by [linkify](https://github.com/markdown-it/markdown-it/blob/master/src/rules_core/linkify.ts)\n   * rule.\n   */\n  linkify = new LinkifyIt()\n\n  /**\n   * Link validation function. CommonMark allows too much in links. By default\n   * we disable `javascript:`, `vbscript:`, `file:` schemas, and almost all `data:...` schemas\n   * except some embedded image types.\n   *\n   * You can change this behaviour:\n   *\n   * @example\n   * ```javascript\n   * import MarkdownIt from 'markdown-it'\n   * const md = new MarkdownIt()\n   *\n   * // enable everything\n   * md.validateLink = function () { return true; }\n   * ```\n   */\n  validateLink (url: string): boolean {\n    // url should be normalized at this point, and existing entities are decoded\n    const str = url.trim().toLowerCase()\n\n    return BAD_PROTO_RE.test(str) ? GOOD_DATA_RE.test(str) : true\n  }\n\n  /**\n   * Function used to encode link url to a machine-readable format,\n   * which includes url-encoding, punycode, etc.\n   */\n  normalizeLink (url: string): string {\n    // Each url part should be encoded separately, with proper encoder\n    const parsed = mdurl.parse(url, true)\n\n    if (parsed.hostname) {\n      // Encode hostnames in urls like:\n      // `http://host/`, `https://host/`, `mailto:user@host`, `//host/`\n      //\n      // We don't encode unknown schemas, because it's likely that we encode\n      // something we shouldn't (e.g. `skype:name` treated as `skype:host`)\n      //\n      if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) {\n        try {\n          parsed.hostname = punycode.toASCII(parsed.hostname)\n        } catch (er) { /**/ }\n      }\n    }\n\n    if (parsed.auth) parsed.auth = mdurl.encode(parsed.auth)\n    if (parsed.hostname) parsed.hostname = mdurl.encode(parsed.hostname)\n    if (parsed.pathname) parsed.pathname = mdurl.encode(parsed.pathname)\n    if (parsed.search) parsed.search = mdurl.encode(parsed.search)\n    if (parsed.hash) parsed.hash = mdurl.encode(parsed.hash)\n\n    return mdurl.format(parsed)\n  }\n\n  /**\n   * Function used to decode link url to a human-readable format`\n   */\n  normalizeLinkText (url: string): string {\n    const parsed = mdurl.parse(url, true)\n\n    if (parsed.hostname) {\n      // Encode hostnames in urls like:\n      // `http://host/`, `https://host/`, `mailto:user@host`, `//host/`\n      //\n      // We don't encode unknown schemas, because it's likely that we encode\n      // something we shouldn't (e.g. `skype:name` treated as `skype:host`)\n      //\n      if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) {\n        try {\n          parsed.hostname = punycode.toUnicode(parsed.hostname)\n        } catch (er) { /**/ }\n      }\n    }\n\n    // add '%' to exclude list because of https://github.com/markdown-it/markdown-it/issues/720\n    return mdurl.decode(mdurl.format(parsed), mdurl.decode.defaultChars + '%')\n  }\n\n  // Expose utils & helpers for easy acces from plugins\n\n  /**\n   * Assorted utility functions, useful to write plugins. See details\n   * [here](https://github.com/markdown-it/markdown-it/blob/master/src/common/utils.ts).\n   */\n  utils = utils\n\n  /**\n   * Link components parser functions, useful to write plugins. See details\n   * [here](https://github.com/markdown-it/markdown-it/blob/master/src/helpers).\n   */\n  helpers = Object.assign({}, helpers)\n\n  declare options: Required<MarkdownItOptions>\n\n  constructor (\n    ...args:\n      | []\n      | [options: MarkdownItOptions]\n      | [presetName: MarkdownItPresetName, options?: MarkdownItOptions]\n  ) {\n    const [presetNameOrOptions, options] = args\n\n    if (typeof presetNameOrOptions === 'string') {\n      this.configure(presetNameOrOptions)\n      if (options) { this.set(options) }\n    } else {\n      this.configure('default')\n      this.set(presetNameOrOptions || {})\n    }\n  }\n\n  /**\n   * Set parser options (in the same format as in constructor). Probably, you\n   * will never need it, but you can change options after constructor call.\n   *\n   * __Note:__ To achieve the best possible performance, don't modify a\n   * `markdown-it` instance options on the fly. If you need multiple configurations\n   * it's best to create multiple instances and initialize each with separate\n   * config.\n   *\n   * @example\n   * ```javascript\n   * import MarkdownIt from 'markdown-it'\n   *\n   * const md = new MarkdownIt()\n   *   .set({ html: true, breaks: true })\n   *   .set({ typographer: true })\n   * ```\n   */\n  set (options: MarkdownItOptions): this {\n    Object.assign(this.options, options)\n    return this\n  }\n\n  /**\n   * Batch load of all options and compenent settings. This is internal method,\n   * and you probably will not need it. But if you will - see available presets\n   * and data structure [here](https://github.com/markdown-it/markdown-it/tree/master/src/presets)\n   *\n   * We strongly recommend to use presets instead of direct config loads. That\n   * will give better compatibility with next versions.\n   */\n  configure (presets: MarkdownItPresetName | MarkdownItPreset): this {\n    let p: MarkdownItPreset\n\n    if (typeof presets === 'string') {\n      const presetName = presets\n      p = config[presetName]\n      if (!p) { throw new Error(`Wrong 'markdown-it' preset \"${presetName}\", check name`) }\n    } else {\n      p = presets\n    }\n\n    if (!p) { throw new Error('Wrong `markdown-it` preset, can\\'t be empty') }\n\n    if (p.options) { this.options = { ...p.options } }\n\n    const components = p.components\n    if (components) {\n      const componentNames: MarkdownItComponentName[] = ['core', 'block', 'inline']\n      componentNames.forEach((name) => {\n        const rules = components[name]?.rules\n        if (rules) {\n          this[name].ruler.enableOnly(rules)\n        }\n      })\n\n      const rules2 = components.inline?.rules2\n      if (rules2) {\n        this.inline.ruler2.enableOnly(rules2)\n      }\n    }\n    return this\n  }\n\n  /**\n   * Enable list or rules. It will automatically find appropriate components,\n   * containing rules with given names. If rule not found, and `ignoreInvalid`\n   * not set - throws exception.\n   *\n   * @example\n   * ```javascript\n   * import MarkdownIt from 'markdown-it'\n   *\n   * const md = new MarkdownIt()\n   *   .enable(['sub', 'sup'])\n   *   .disable('smartquotes')\n   * ```\n   */\n  enable (list: string | string[], ignoreInvalid = false): this {\n    let result: string[] = []\n\n    if (!Array.isArray(list)) { list = [list] }\n\n    const chains: MarkdownItComponentName[] = ['core', 'block', 'inline']\n    chains.forEach((chain) => {\n      result = result.concat(this[chain].ruler.enable(list, true))\n    })\n\n    result = result.concat(this.inline.ruler2.enable(list, true))\n\n    const missed = list.filter((name) => result.indexOf(name) < 0)\n\n    if (missed.length && !ignoreInvalid) {\n      throw new Error(`MarkdownIt. Failed to enable unknown rule(s): ${missed}`)\n    }\n\n    return this\n  }\n\n  /**\n   * The same as {@link MarkdownIt.enable}, but turn specified rules off.\n   */\n  disable (list: string | string[], ignoreInvalid = false): this {\n    let result: string[] = []\n\n    if (!Array.isArray(list)) { list = [list] }\n\n    const chains: MarkdownItComponentName[] = ['core', 'block', 'inline']\n    chains.forEach((chain) => {\n      result = result.concat(this[chain].ruler.disable(list, true))\n    })\n\n    result = result.concat(this.inline.ruler2.disable(list, true))\n\n    const missed = list.filter((name) => result.indexOf(name) < 0)\n\n    if (missed.length && !ignoreInvalid) {\n      throw new Error(`MarkdownIt. Failed to disable unknown rule(s): ${missed}`)\n    }\n    return this\n  }\n\n  /**\n   * Load specified plugin with given params into current parser instance.\n   * It's just a sugar to call `plugin(md, params)` with curring.\n   *\n   * @example\n   * ```javascript\n   * import MarkdownIt from 'markdown-it'\n   * import iterator from 'markdown-it-for-inline'\n   *\n   * const md = new MarkdownIt()\n   *   .use(iterator, 'foo_replace', 'text', function (tokens, idx) {\n   *     tokens[idx].content = tokens[idx].content.replace(/foo/g, 'bar')\n   *   })\n   * ```\n   */\n  use<Params extends unknown[]> (\n    plugin: (md: this, ...params: Params) => void,\n    ...params: Params\n  ): this {\n    plugin.apply(plugin, [this, ...params])\n    return this\n  }\n\n  /**\n   * Parse input string and return list of block tokens (special token type\n   * \"inline\" will contain list of inline tokens). You should not call this\n   * method directly, until you write custom renderer (for example, to produce\n   * AST).\n   *\n   * `env` is used to pass data between \"distributed\" rules and return additional\n   * metadata like reference info, needed for the renderer. It also can be used to\n   * inject data in specific cases. Usually, you will be ok to pass `{}`,\n   * and then pass updated object to renderer.\n   */\n  parse (src: string, env: Env): Token[] {\n    if (typeof src !== 'string') {\n      throw new Error('Input data should be a String')\n    }\n\n    const state = new this.core.State(src, this, env)\n\n    this.core.process(state)\n\n    return state.tokens\n  }\n\n  /**\n   * Render markdown string into html. It does all magic for you :).\n   *\n   * `env` can be used to inject additional metadata (`{}` by default).\n   * But you will not need it with high probability. See also comment\n   * in {@link MarkdownIt.parse}.\n   */\n  render (src: string, env: Env = {}): string {\n    return this.renderer.render(this.parse(src, env), this.options, env)\n  }\n\n  /**\n   * The same as {@link MarkdownIt.parse} but skip all block rules. It returns\n   * the block tokens list with the single `inline` element, containing parsed\n   * inline tokens in `children` property. Also updates `env` object.\n   */\n  parseInline (src: string, env: Env): Token[] {\n    const state = new this.core.State(src, this, env)\n\n    state.inlineMode = true\n    this.core.process(state)\n\n    return state.tokens\n  }\n\n  /**\n   * Similar to {@link MarkdownIt.render} but for single paragraph content.\n   * Result will NOT be wrapped into `<p>` tags.\n   */\n  renderInline (src: string, env: Env = {}): string {\n    return this.renderer.render(this.parseInline(src, env), this.options, env)\n  }\n\n  static Token = Token\n  static Ruler = Ruler\n  static Renderer = Renderer\n  static ParserCore = ParserCore\n  static StateCore = StateCore\n  static ParserBlock = ParserBlock\n  static StateBlock = StateBlock\n  static ParserInline = ParserInline\n  static StateInline = StateInline\n}\n\nexport default MarkdownIt\n","import { callable } from './common/utils.ts'\nimport MarkdownIt from './markdownit.ts'\n\n/**\n * Default package export.\n *\n * For backward compatibility, the {@link MarkdownIt} class is wrapped so\n * legacy code can call it without `new`. New code should instantiate it as a\n * regular class with `new`. The compatibility wrapper may be removed in a\n * future release.\n *\n * @category Main\n */\nconst MarkdownItCallable = callable(MarkdownIt)\n\nexport default MarkdownItCallable\n\nexport type { default as MarkdownIt, MarkdownItPreset } from './markdownit.ts'\nexport type { Delimiter, Env, MarkdownItOptions } from './types.ts'\nexport type { default as Token } from './token.ts'\nexport type { default as Ruler } from './ruler.ts'\nexport type { default as Renderer, RendererRule } from './renderer.ts'\nexport type { default as ParserCore } from './parser_core.ts'\nexport type { default as StateCore } from './rules_core/state_core.ts'\nexport type { default as ParserBlock } from './parser_block.ts'\nexport type { default as StateBlock } from './rules_block/state_block.ts'\nexport type { default as ParserInline } from './parser_inline.ts'\nexport type { default as StateInline } from './rules_inline/state_inline.ts'\n"],"ignoreList":[0,1,2,3,4,5,6,7,8,9,10,60,61],"mappings":"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"}