{"version":3,"file":"markdown-it.mjs","names":[],"sources":["../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","../src/presets/default.ts","../src/presets/zero.ts","../src/presets/commonmark.ts","../src/markdownit.ts","../src/index.ts"],"sourcesContent":["/**\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  // List of added rules. Each element is:\n  //\n  // {\n  //   name: XXX,\n  //   enabled: Boolean,\n  //   fn: Function(),\n  //   alt: [ name2, name3 ]\n  // }\n  //\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  __cache__: Record<string, Array<(...args: Args) => Result>> | null = null\n\n  // Helper methods, should not be used directly\n\n  // Find rule index by name\n  //\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  // Build rules lookup cache\n  //\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   * @param name Rule name to replace.\n   * @param fn New rule function.\n   * @param options Rule options. `alt` is an array with names of \"alternate\"\n   * chains.\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   * @param beforeName New rule will be added before this one.\n   * @param ruleName Name of added rule.\n   * @param fn Rule function.\n   * @param options Rule options. `alt` is an array with names of \"alternate\"\n   * chains.\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   * @param afterName New rule will be added after this one.\n   * @param ruleName Name of added rule.\n   * @param fn Rule function.\n   * @param options Rule options. `alt` is an array with names of \"alternate\"\n   * chains.\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   * @param ruleName Name of added rule.\n   * @param fn Rule function.\n   * @param options Rule options. `alt` is an array with names of \"alternate\"\n   * chains.\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   * @param list List of rule names to enable.\n   * @param ignoreInvalid Set `true` to ignore errors when rule not found.\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   * @param list List of rule names to enable (whitelist).\n   * @param ignoreInvalid Set `true` to ignore errors when rule not found.\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   * @param list List of rule names to disable.\n   * @param ignoreInvalid Set `true` to ignore errors when rule not found.\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   * @param tokens List of tokens.\n   * @param idx Token index to render.\n   * @param options Params of parser instance.\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   * @param tokens List on block tokens to render.\n   * @param options Params of parser instance.\n   * @param env Additional data from parsed input (references, for example).\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   * @param tokens List on block tokens to render.\n   * @param options Params of parser instance.\n   * @param env Additional data from parsed input (references, for example).\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   * @param tokens List on block tokens to render.\n   * @param options Params of parser instance.\n   * @param env Additional data from parsed input (references, for example).\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 NEWLINES_RE = /\\r\\n?|\\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(NEWLINES_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 { arrayReplaceAt } from '../common/utils.ts'\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    let tokens = blockTokens[j].children!\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        // replace current node\n        blockTokens[j].children = tokens = arrayReplaceAt(tokens, i, nodes)\n      }\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\ninterface Replacement {\n  pos: number\n  ch: string\n}\n\ntype ReplacementMap = Record<string, Replacement[]>\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 = []\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    stack.length = 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        // this could be a closing quote, rewind the stack to get a match\n        for (j = stack.length - 1; j >= 0; j--) {\n          let item = stack[j]\n          if (stack[j].level < thisLevel) { break }\n          if (item.single === isSingle && stack[j].level === thisLevel) {\n            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.token, item.pos, openQuote)\n\n            stack.length = j\n            continue OUTER\n          }\n        }\n      }\n\n      if (canOpen) {\n        stack.push({\n          token: i,\n          pos: t.index,\n          single: isSingle,\n          level: thisLevel\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\nexport default function reference (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  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 (state.src.charCodeAt(pos) !== 0x5B/* [ */) { return false }\n\n  function getNextLine (nextLine: number) {\n    const endLine = state.lineMax\n\n    if (nextLine >= endLine || state.isEmpty(nextLine)) {\n      // empty line or end of input\n      return null\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 null\n      }\n    }\n\n    const pos = state.bMarks[nextLine] + state.tShift[nextLine]\n    const max = state.eMarks[nextLine]\n\n    // max + 1 explicitly includes the newline\n    return state.src.slice(pos, max + 1)\n  }\n\n  let str = state.src.slice(pos, max + 1)\n\n  max = str.length\n  let labelEnd = -1\n\n  for (pos = 1; pos < max; pos++) {\n    const ch = str.charCodeAt(pos)\n    if (ch === 0x5B /* [ */) {\n      return false\n    } else if (ch === 0x5D /* ] */) {\n      labelEnd = pos\n      break\n    } else if (ch === 0x0A /* \\n */) {\n      const lineContent = getNextLine(nextLine)\n      if (lineContent !== null) {\n        str += lineContent\n        max = str.length\n        nextLine++\n      }\n    } else if (ch === 0x5C /* \\ */) {\n      pos++\n      if (pos < max && str.charCodeAt(pos) === 0x0A) {\n        const lineContent = getNextLine(nextLine)\n        if (lineContent !== null) {\n          str += lineContent\n          max = str.length\n          nextLine++\n        }\n      }\n    }\n  }\n\n  if (labelEnd < 0 || str.charCodeAt(labelEnd + 1) !== 0x3A/* : */) { return false }\n\n  // [label]:   destination   'title'\n  //         ^^^ skip optional whitespace here\n  for (pos = labelEnd + 2; pos < max; pos++) {\n    const ch = str.charCodeAt(pos)\n    if (ch === 0x0A) {\n      const lineContent = getNextLine(nextLine)\n      if (lineContent !== null) {\n        str += lineContent\n        max = str.length\n        nextLine++\n      }\n    } else if (isSpace(ch)) {\n      /* eslint no-empty:0 */\n    } else {\n      break\n    }\n  }\n\n  // [label]:   destination   'title'\n  //            ^^^^^^^^^^^ parse this\n  const destRes = state.md.helpers.parseLinkDestination(str, 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 destEndLineNo = nextLine\n\n  // [label]:   destination   'title'\n  //                       ^^^ skipping those spaces\n  const start = pos\n  for (; pos < max; pos++) {\n    const ch = str.charCodeAt(pos)\n    if (ch === 0x0A) {\n      const lineContent = getNextLine(nextLine)\n      if (lineContent !== null) {\n        str += lineContent\n        max = str.length\n        nextLine++\n      }\n    } else if (isSpace(ch)) {\n      /* Nothing */\n    } else {\n      break\n    }\n  }\n\n  // [label]:   destination   'title'\n  //                          ^^^^^^^ parse this\n  let titleRes = state.md.helpers.parseLinkTitle(str, pos, max)\n  while (titleRes.can_continue) {\n    const lineContent = getNextLine(nextLine)\n    if (lineContent === null) break\n    str += lineContent\n    pos = max\n    max = str.length\n    nextLine++\n    titleRes = state.md.helpers.parseLinkTitle(str, pos, max, titleRes)\n  }\n  let title\n\n  if (pos < max && start !== pos && titleRes.ok) {\n    title = titleRes.str\n    pos = titleRes.pos\n  } else {\n    title = ''\n    pos = destEndPos\n    nextLine = destEndLineNo\n  }\n\n  // skip trailing spaces until the rest of the line\n  while (pos < max) {\n    const ch = str.charCodeAt(pos)\n    if (!isSpace(ch)) { break }\n    pos++\n  }\n\n  if (pos < max && str.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      nextLine = destEndLineNo\n      while (pos < max) {\n        const ch = str.charCodeAt(pos)\n        if (!isSpace(ch)) { break }\n        pos++\n      }\n    }\n  }\n\n  if (pos < max && str.charCodeAt(pos) !== 0x0A) {\n    // garbage at the end of the line\n    return false\n  }\n\n  const label = normalizeReference(str.slice(1, labelEnd))\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\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 length => last seen position\n  backticks: Record<number, number> = {}\n  backticksScanned = 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","// Process links like https://example.org/\n\nimport type StateInline from './state_inline.ts'\n\n// RFC3986: scheme = ALPHA *( ALPHA / DIGIT / \"+\" / \"-\" / \".\" )\nconst SCHEME_RE = /(?:^|[^a-z0-9.+-])([a-z][a-z0-9.+-]*)$/i\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  const match = state.pending.match(SCHEME_RE)\n  if (!match) return false\n\n  const proto = match[1]\n\n  const link = state.md.linkify.matchAtStart(state.src.slice(pos - proto.length))\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 <= proto.length) 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, -proto.length)\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 - proto.length\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\nexport default function backtick (state: StateInline, silent: boolean): boolean {\n  let pos = state.pos\n  const ch = state.src.charCodeAt(pos)\n\n  if (ch !== 0x60/* ` */) { return false }\n\n  const start = pos\n  pos++\n  const max = state.posMax\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 && (state.backticks[openerLength] || 0) <= start) {\n    if (!silent) state.pending += marker\n    state.pos += openerLength\n    return true\n  }\n\n  let matchEnd = pos\n  let matchStart\n\n  // Nothing found in the cache, scan until the end of the line (or until marker is found)\n  while ((matchStart = state.src.indexOf('`', matchEnd)) !== -1) {\n    matchEnd = matchStart + 1\n\n    // scan marker length\n    while (matchEnd < max && state.src.charCodeAt(matchEnd) === 0x60/* ` */) { matchEnd++ }\n\n    const closerLength = matchEnd - matchStart\n\n    if (closerLength === openerLength) {\n      // Found matching closer length.\n      if (!silent) {\n        const token = state.push('code_inline', 'code', 0)\n        token.markup = marker\n        token.content = state.src.slice(pos, matchStart)\n          .replace(/\\n/g, ' ')\n          .replace(/^ (.+) $/, '$1')\n      }\n      state.pos = matchEnd\n      return true\n    }\n\n    // Some different length found, put it in cache as upper limit of where closer can be found\n    state.backticks[closerLength] = matchStart\n  }\n\n  // Scanned through the end, didn't find anything\n  state.backticksScanned = true\n\n  if (!silent) state.pending += marker\n  state.pos += openerLength\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_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\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  // Quick fail on second char\n  const ch = state.src.charCodeAt(pos + 1)\n  if (ch !== 0x21/* ! */ &&\n      ch !== 0x3F/* ? */ &&\n      ch !== 0x2F/* / */ &&\n      !isLetter(ch)) {\n    return false\n  }\n\n  const match = state.src.slice(pos).match(HTML_TAG_RE)\n  if (!match) { return false }\n\n  if (!silent) {\n    const token = state.push('html_inline', '', 0)\n    token.content = match[0]\n\n    if (isLinkOpen(token.content)) state.linkLevel++\n    if (isLinkClose(token.content)) state.linkLevel--\n  }\n  state.pos += match[0].length\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","// 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    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    return mdurl.encode(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   * @param list Rule name or list of rule names to enable.\n   * @param ignoreInvalid Set `true` to ignore errors when rule not found.\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   * @param list Rule name or list of rule names to disable.\n   * @param ignoreInvalid Set `true` to ignore errors when rule not found.\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   * @param src Source string.\n   * @param env Environment sandbox.\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   * @param src Source string.\n   * @param env Environment sandbox.\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   * @param src Source string.\n   * @param env Environment sandbox.\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   * @param src Source string.\n   * @param env Environment sandbox.\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"],"mappings":"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"}