@coderminer/vue-markdown 1.0.0 → 1.0.1

package/dist/math/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":["emptyOptions","_objectSpread2","visitParents","SKIP","markdownLineEnding","convert","visit","factorySpace","longestStreak","fromHtml","htmlToMarkdownNodes","katex","mathFromMarkdown","enterMathFlow","enterMathFlowMeta","enterMathText","exitMathFlow","exitMathFlowFence","exitMathFlowMeta","exitMathData","exitMathText","token","data","node","code","mathToMarkdown","single","options","inlineMathPeek","math","raw","tracker","state","info","sequence","exit","value","subexit","inlineMath","size","index","pattern","expression","match","position","mathFlow","tokenizeMathFenced","nonLazyContinuation","tokenizeNonLazyContinuation","self","tail","initialSize","sizeOpen","start","effects","sequenceOpen","nok","metaBefore","metaAfter","meta","ok","beforeNonLazyContinuation","after","tokenizeClosingFence","contentStart","beforeContentChunk","contentChunk","beforeSequenceClose","sequenceClose","afterSequenceClose","lineStart","mathText","tokenizeMathText","resolveMathText","between","tailExitIndex","events","headEnterIndex","enter","previous","emptyOptions$1","remarkMath","settings","micromarkExtensions","fromMarkdownExtensions","toMarkdownExtensions","removePosition","force","tree","remove","fromHtmlIsomorphic","findAfter","is","test","parent","convertElement","element","tagNameFactory","anyFactory","castFactory","checks","tests","any","parameters","tagName","check","looksLikeAnElement","testFunction","searchLineFeeds","searchTabOrSpaces","br","cell","isCell","p","row","notRendered","hidden","closedDialog","blockOrCaption","toText","options_","children","block","whitespace","inferWhitespace","results","collectText","renderedTextCollection","result","count","collectElement","collectPreText","items","prefix","suffix","lines","end","trimAndCollapseSpacesAndTabs","join","breakBefore","breakAfter","properties","emptyOptions","emptyClasses","rehypeKatex","classes","languageMath","mathDisplay","mathInline","displayMode","parents","scope","error","cause","ruleId","_unused","_node$properties","textContent","isMathCode","names","name","annotation","tex","display","annotate","nodes","child","rehypeMathAnnotation","escapeRegExp","replaceDelimiters","inline","source","part","body","mathPlugin","_options$singleDollar","_options$katex","cache","MAX_CACHE","renderOptions","katexEngine","key","cached","katexOptions","html","oldest"],"sources":["../../node_modules/mdast-util-math/lib/index.js","../../node_modules/micromark-extension-math/lib/math-flow.js","../../node_modules/micromark-extension-math/lib/math-text.js","../../node_modules/micromark-extension-math/lib/syntax.js","../../node_modules/remark-math/lib/index.js","../../node_modules/unist-util-remove-position/lib/index.js","../../node_modules/hast-util-from-html-isomorphic/lib/index.js","../../node_modules/unist-util-find-after/lib/index.js","../../node_modules/hast-util-is-element/lib/index.js","../../node_modules/hast-util-to-text/lib/index.js","../../node_modules/rehype-katex/lib/index.js","../../src/math/plugin.ts","../../src/math/katex.ts"],"sourcesContent":["/**\n * @typedef {import('hast').Element} HastElement\n * @typedef {import('hast').ElementContent} HastElementContent\n * @typedef {import('mdast-util-from-markdown').CompileContext} CompileContext\n * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension\n * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle\n * @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle\n * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension\n * @typedef {import('../index.js').InlineMath} InlineMath\n * @typedef {import('../index.js').Math} Math\n *\n * @typedef ToOptions\n *   Configuration.\n * @property {boolean | null | undefined} [singleDollarTextMath=true]\n *   Whether to support math (text) with a single dollar (default: `true`).\n *\n *   Single dollars work in Pandoc and many other places, but often interfere\n *   with “normal” dollars in text.\n *   If you turn this off, you can still use two or more dollars for text math.\n */\n\nimport {ok as assert} from 'devlop'\nimport {longestStreak} from 'longest-streak'\n\n/**\n * Create an extension for `mdast-util-from-markdown`.\n *\n * @returns {FromMarkdownExtension}\n *   Extension for `mdast-util-from-markdown`.\n */\nexport function mathFromMarkdown() {\n  return {\n    enter: {\n      mathFlow: enterMathFlow,\n      mathFlowFenceMeta: enterMathFlowMeta,\n      mathText: enterMathText\n    },\n    exit: {\n      mathFlow: exitMathFlow,\n      mathFlowFence: exitMathFlowFence,\n      mathFlowFenceMeta: exitMathFlowMeta,\n      mathFlowValue: exitMathData,\n      mathText: exitMathText,\n      mathTextData: exitMathData\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {FromMarkdownHandle}\n   */\n  function enterMathFlow(token) {\n    /** @type {HastElement} */\n    const code = {\n      type: 'element',\n      tagName: 'code',\n      properties: {className: ['language-math', 'math-display']},\n      children: []\n    }\n    this.enter(\n      {\n        type: 'math',\n        meta: null,\n        value: '',\n        data: {hName: 'pre', hChildren: [code]}\n      },\n      token\n    )\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {FromMarkdownHandle}\n   */\n  function enterMathFlowMeta() {\n    this.buffer()\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {FromMarkdownHandle}\n   */\n  function exitMathFlowMeta() {\n    const data = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    assert(node.type === 'math')\n    node.meta = data\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {FromMarkdownHandle}\n   */\n  function exitMathFlowFence() {\n    // Exit if this is the closing fence.\n    if (this.data.mathFlowInside) return\n    this.buffer()\n    this.data.mathFlowInside = true\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {FromMarkdownHandle}\n   */\n  function exitMathFlow(token) {\n    const data = this.resume().replace(/^(\\r?\\n|\\r)|(\\r?\\n|\\r)$/g, '')\n    const node = this.stack[this.stack.length - 1]\n    assert(node.type === 'math')\n    this.exit(token)\n    node.value = data\n    // @ts-expect-error: we defined it in `enterMathFlow`.\n    const code = /** @type {HastElement} */ (node.data.hChildren[0])\n    assert(code.type === 'element')\n    assert(code.tagName === 'code')\n    code.children.push({type: 'text', value: data})\n    this.data.mathFlowInside = undefined\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {FromMarkdownHandle}\n   */\n  function enterMathText(token) {\n    this.enter(\n      {\n        type: 'inlineMath',\n        value: '',\n        data: {\n          hName: 'code',\n          hProperties: {className: ['language-math', 'math-inline']},\n          hChildren: []\n        }\n      },\n      token\n    )\n    this.buffer()\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {FromMarkdownHandle}\n   */\n  function exitMathText(token) {\n    const data = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    assert(node.type === 'inlineMath')\n    this.exit(token)\n    node.value = data\n    const children = /** @type {Array<HastElementContent>} */ (\n      // @ts-expect-error: we defined it in `enterMathFlow`.\n      node.data.hChildren\n    )\n    children.push({type: 'text', value: data})\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {FromMarkdownHandle}\n   */\n  function exitMathData(token) {\n    this.config.enter.data.call(this, token)\n    this.config.exit.data.call(this, token)\n  }\n}\n\n/**\n * Create an extension for `mdast-util-to-markdown`.\n *\n * @param {ToOptions | null | undefined} [options]\n *   Configuration (optional).\n * @returns {ToMarkdownExtension}\n *   Extension for `mdast-util-to-markdown`.\n */\nexport function mathToMarkdown(options) {\n  let single = (options || {}).singleDollarTextMath\n\n  if (single === null || single === undefined) {\n    single = true\n  }\n\n  inlineMath.peek = inlineMathPeek\n\n  return {\n    unsafe: [\n      {character: '\\r', inConstruct: 'mathFlowMeta'},\n      {character: '\\n', inConstruct: 'mathFlowMeta'},\n      {\n        character: '$',\n        after: single ? undefined : '\\\\$',\n        inConstruct: 'phrasing'\n      },\n      {character: '$', inConstruct: 'mathFlowMeta'},\n      {atBreak: true, character: '$', after: '\\\\$'}\n    ],\n    handlers: {math, inlineMath}\n  }\n\n  /**\n   * @type {ToMarkdownHandle}\n   * @param {Math} node\n   */\n  // Note: fixing this code? Please also fix the similar code for code:\n  // <https://github.com/syntax-tree/mdast-util-to-markdown/blob/main/lib/handle/code.js>\n  function math(node, _, state, info) {\n    const raw = node.value || ''\n    const tracker = state.createTracker(info)\n    const sequence = '$'.repeat(Math.max(longestStreak(raw, '$') + 1, 2))\n    const exit = state.enter('mathFlow')\n    let value = tracker.move(sequence)\n\n    if (node.meta) {\n      const subexit = state.enter('mathFlowMeta')\n      value += tracker.move(\n        state.safe(node.meta, {\n          after: '\\n',\n          before: value,\n          encode: ['$'],\n          ...tracker.current()\n        })\n      )\n      subexit()\n    }\n\n    value += tracker.move('\\n')\n\n    if (raw) {\n      value += tracker.move(raw + '\\n')\n    }\n\n    value += tracker.move(sequence)\n    exit()\n    return value\n  }\n\n  /**\n   * @type {ToMarkdownHandle}\n   * @param {InlineMath} node\n   */\n  // Note: fixing this code? Please also fix the similar code for inline code:\n  // <https://github.com/syntax-tree/mdast-util-to-markdown/blob/main/lib/handle/inline-code.js>\n  function inlineMath(node, _, state) {\n    let value = node.value || ''\n    let size = 1\n\n    if (!single) size++\n\n    // If there is a single dollar sign on its own in the math, use a fence of\n    // two.\n    // If there are two in a row, use one.\n    while (\n      new RegExp('(^|[^$])' + '\\\\$'.repeat(size) + '([^$]|$)').test(value)\n    ) {\n      size++\n    }\n\n    const sequence = '$'.repeat(size)\n\n    // If this is not just spaces or eols (tabs don’t count), and either the\n    // first and last character are a space or eol, or the first or last\n    // character are dollar signs, then pad with spaces.\n    if (\n      // Contains non-space.\n      /[^ \\r\\n]/.test(value) &&\n      // Starts with space and ends with space.\n      ((/^[ \\r\\n]/.test(value) && /[ \\r\\n]$/.test(value)) ||\n        // Starts or ends with dollar.\n        /^\\$|\\$$/.test(value))\n    ) {\n      value = ' ' + value + ' '\n    }\n\n    let index = -1\n\n    // We have a potential problem: certain characters after eols could result in\n    // blocks being seen.\n    // For example, if someone injected the string `'\\n# b'`, then that would\n    // result in an ATX heading.\n    // We can’t escape characters in `inlineMath`, but because eols are\n    // transformed to spaces when going from markdown to HTML anyway, we can swap\n    // them out.\n    while (++index < state.unsafe.length) {\n      const pattern = state.unsafe[index]\n\n      // Only look for `atBreak`s.\n      // Btw: note that `atBreak` patterns will always start the regex at LF or\n      // CR.\n      if (!pattern.atBreak) continue\n\n      const expression = state.compilePattern(pattern)\n      /** @type {RegExpExecArray | null} */\n      let match\n\n      while ((match = expression.exec(value))) {\n        let position = match.index\n\n        // Support CRLF (patterns only look for one of the characters).\n        if (\n          value.codePointAt(position) === 10 /* `\\n` */ &&\n          value.codePointAt(position - 1) === 13 /* `\\r` */\n        ) {\n          position--\n        }\n\n        value = value.slice(0, position) + ' ' + value.slice(match.index + 1)\n      }\n    }\n\n    return sequence + value + sequence\n  }\n\n  /**\n   * @returns {string}\n   */\n  function inlineMathPeek() {\n    return '$'\n  }\n}\n","/**\n * @import {Construct, State, TokenizeContext, Tokenizer} from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {Construct} */\nexport const mathFlow = {\n  tokenize: tokenizeMathFenced,\n  concrete: true,\n  name: 'mathFlow'\n};\n\n/** @type {Construct} */\nconst nonLazyContinuation = {\n  tokenize: tokenizeNonLazyContinuation,\n  partial: true\n};\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeMathFenced(effects, ok, nok) {\n  const self = this;\n  const tail = self.events[self.events.length - 1];\n  const initialSize = tail && tail[1].type === \"linePrefix\" ? tail[2].sliceSerialize(tail[1], true).length : 0;\n  let sizeOpen = 0;\n  return start;\n\n  /**\n   * Start of math.\n   *\n   * ```markdown\n   * > | $$\n   *     ^\n   *   | \\frac{1}{2}\n   *   | $$\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('mathFlow');\n    effects.enter('mathFlowFence');\n    effects.enter('mathFlowFenceSequence');\n    return sequenceOpen(code);\n  }\n\n  /**\n   * In opening fence sequence.\n   *\n   * ```markdown\n   * > | $$\n   *      ^\n   *   | \\frac{1}{2}\n   *   | $$\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceOpen(code) {\n    if (code === 36) {\n      effects.consume(code);\n      sizeOpen++;\n      return sequenceOpen;\n    }\n    if (sizeOpen < 2) {\n      return nok(code);\n    }\n    effects.exit('mathFlowFenceSequence');\n    return factorySpace(effects, metaBefore, \"whitespace\")(code);\n  }\n\n  /**\n   * In opening fence, before meta.\n   *\n   * ```markdown\n   * > | $$asciimath\n   *       ^\n   *   | x < y\n   *   | $$\n   * ```\n   *\n   * @type {State}\n   */\n\n  function metaBefore(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return metaAfter(code);\n    }\n    effects.enter('mathFlowFenceMeta');\n    effects.enter(\"chunkString\", {\n      contentType: \"string\"\n    });\n    return meta(code);\n  }\n\n  /**\n   * In meta.\n   *\n   * ```markdown\n   * > | $$asciimath\n   *        ^\n   *   | x < y\n   *   | $$\n   * ```\n   *\n   * @type {State}\n   */\n  function meta(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"chunkString\");\n      effects.exit('mathFlowFenceMeta');\n      return metaAfter(code);\n    }\n    if (code === 36) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return meta;\n  }\n\n  /**\n   * After meta.\n   *\n   * ```markdown\n   * > | $$\n   *       ^\n   *   | \\frac{1}{2}\n   *   | $$\n   * ```\n   *\n   * @type {State}\n   */\n  function metaAfter(code) {\n    // Guaranteed to be eol/eof.\n    effects.exit('mathFlowFence');\n    if (self.interrupt) {\n      return ok(code);\n    }\n    return effects.attempt(nonLazyContinuation, beforeNonLazyContinuation, after)(code);\n  }\n\n  /**\n   * After eol/eof in math, at a non-lazy closing fence or content.\n   *\n   * ```markdown\n   *   | $$\n   * > | \\frac{1}{2}\n   *     ^\n   * > | $$\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function beforeNonLazyContinuation(code) {\n    return effects.attempt({\n      tokenize: tokenizeClosingFence,\n      partial: true\n    }, after, contentStart)(code);\n  }\n\n  /**\n   * Before math content, definitely not before a closing fence.\n   *\n   * ```markdown\n   *   | $$\n   * > | \\frac{1}{2}\n   *     ^\n   *   | $$\n   * ```\n   *\n   * @type {State}\n   */\n  function contentStart(code) {\n    return (initialSize ? factorySpace(effects, beforeContentChunk, \"linePrefix\", initialSize + 1) : beforeContentChunk)(code);\n  }\n\n  /**\n   * Before math content, after optional prefix.\n   *\n   * ```markdown\n   *   | $$\n   * > | \\frac{1}{2}\n   *     ^\n   *   | $$\n   * ```\n   *\n   * @type {State}\n   */\n  function beforeContentChunk(code) {\n    if (code === null) {\n      return after(code);\n    }\n    if (markdownLineEnding(code)) {\n      return effects.attempt(nonLazyContinuation, beforeNonLazyContinuation, after)(code);\n    }\n    effects.enter('mathFlowValue');\n    return contentChunk(code);\n  }\n\n  /**\n   * In math content.\n   *\n   * ```markdown\n   *   | $$\n   * > | \\frac{1}{2}\n   *      ^\n   *   | $$\n   * ```\n   *\n   * @type {State}\n   */\n  function contentChunk(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('mathFlowValue');\n      return beforeContentChunk(code);\n    }\n    effects.consume(code);\n    return contentChunk;\n  }\n\n  /**\n   * After math (ha!).\n   *\n   * ```markdown\n   *   | $$\n   *   | \\frac{1}{2}\n   * > | $$\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    effects.exit('mathFlow');\n    return ok(code);\n  }\n\n  /** @type {Tokenizer} */\n  function tokenizeClosingFence(effects, ok, nok) {\n    let size = 0;\n    /**\n     * Before closing fence, at optional whitespace.\n     *\n     * ```markdown\n     *   | $$\n     *   | \\frac{1}{2}\n     * > | $$\n     *     ^\n     * ```\n     */\n    return factorySpace(effects, beforeSequenceClose, \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4);\n\n    /**\n     * In closing fence, after optional whitespace, at sequence.\n     *\n     * ```markdown\n     *   | $$\n     *   | \\frac{1}{2}\n     * > | $$\n     *     ^\n     * ```\n     *\n     * @type {State}\n     */\n    function beforeSequenceClose(code) {\n      effects.enter('mathFlowFence');\n      effects.enter('mathFlowFenceSequence');\n      return sequenceClose(code);\n    }\n\n    /**\n     * In closing fence sequence.\n     *\n     * ```markdown\n     *   | $$\n     *   | \\frac{1}{2}\n     * > | $$\n     *      ^\n     * ```\n     *\n     * @type {State}\n     */\n    function sequenceClose(code) {\n      if (code === 36) {\n        size++;\n        effects.consume(code);\n        return sequenceClose;\n      }\n      if (size < sizeOpen) {\n        return nok(code);\n      }\n      effects.exit('mathFlowFenceSequence');\n      return factorySpace(effects, afterSequenceClose, \"whitespace\")(code);\n    }\n\n    /**\n     * After closing fence sequence, after optional whitespace.\n     *\n     * ```markdown\n     *   | $$\n     *   | \\frac{1}{2}\n     * > | $$\n     *       ^\n     * ```\n     *\n     * @type {State}\n     */\n    function afterSequenceClose(code) {\n      if (code === null || markdownLineEnding(code)) {\n        effects.exit('mathFlowFence');\n        return ok(code);\n      }\n      return nok(code);\n    }\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeNonLazyContinuation(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /** @type {State} */\n  function start(code) {\n    if (code === null) {\n      return ok(code);\n    }\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return lineStart;\n  }\n\n  /** @type {State} */\n  function lineStart(code) {\n    return self.parser.lazy[self.now().line] ? nok(code) : ok(code);\n  }\n}","/**\n * @import {Options} from 'micromark-extension-math'\n * @import {Construct, Previous, Resolver, State, Token, TokenizeContext, Tokenizer} from 'micromark-util-types'\n */\n\n// To do: next major: clean spaces in HTML compiler.\n// This has to be coordinated together with `mdast-util-math`.\n\nimport { markdownLineEnding } from 'micromark-util-character';\n/**\n * @param {Options | null | undefined} [options={}]\n *   Configuration (default: `{}`).\n * @returns {Construct}\n *   Construct.\n */\nexport function mathText(options) {\n  const options_ = options || {};\n  let single = options_.singleDollarTextMath;\n  if (single === null || single === undefined) {\n    single = true;\n  }\n  return {\n    tokenize: tokenizeMathText,\n    resolve: resolveMathText,\n    previous,\n    name: 'mathText'\n  };\n\n  /**\n   * @this {TokenizeContext}\n   * @type {Tokenizer}\n   */\n  function tokenizeMathText(effects, ok, nok) {\n    const self = this;\n    let sizeOpen = 0;\n    /** @type {number} */\n    let size;\n    /** @type {Token} */\n    let token;\n    return start;\n\n    /**\n     * Start of math (text).\n     *\n     * ```markdown\n     * > | $a$\n     *     ^\n     * > | \\$a$\n     *      ^\n     * ```\n     *\n     * @type {State}\n     */\n    function start(code) {\n      effects.enter('mathText');\n      effects.enter('mathTextSequence');\n      return sequenceOpen(code);\n    }\n\n    /**\n     * In opening sequence.\n     *\n     * ```markdown\n     * > | $a$\n     *     ^\n     * ```\n     *\n     * @type {State}\n     */\n\n    function sequenceOpen(code) {\n      if (code === 36) {\n        effects.consume(code);\n        sizeOpen++;\n        return sequenceOpen;\n      }\n\n      // Not enough markers in the sequence.\n      if (sizeOpen < 2 && !single) {\n        return nok(code);\n      }\n      effects.exit('mathTextSequence');\n      return between(code);\n    }\n\n    /**\n     * Between something and something else.\n     *\n     * ```markdown\n     * > | $a$\n     *      ^^\n     * ```\n     *\n     * @type {State}\n     */\n    function between(code) {\n      if (code === null) {\n        return nok(code);\n      }\n      if (code === 36) {\n        token = effects.enter('mathTextSequence');\n        size = 0;\n        return sequenceClose(code);\n      }\n\n      // Tabs don’t work, and virtual spaces don’t make sense.\n      if (code === 32) {\n        effects.enter('space');\n        effects.consume(code);\n        effects.exit('space');\n        return between;\n      }\n      if (markdownLineEnding(code)) {\n        effects.enter(\"lineEnding\");\n        effects.consume(code);\n        effects.exit(\"lineEnding\");\n        return between;\n      }\n\n      // Data.\n      effects.enter('mathTextData');\n      return data(code);\n    }\n\n    /**\n     * In data.\n     *\n     * ```markdown\n     * > | $a$\n     *      ^\n     * ```\n     *\n     * @type {State}\n     */\n    function data(code) {\n      if (code === null || code === 32 || code === 36 || markdownLineEnding(code)) {\n        effects.exit('mathTextData');\n        return between(code);\n      }\n      effects.consume(code);\n      return data;\n    }\n\n    /**\n     * In closing sequence.\n     *\n     * ```markdown\n     * > | `a`\n     *       ^\n     * ```\n     *\n     * @type {State}\n     */\n\n    function sequenceClose(code) {\n      // More.\n      if (code === 36) {\n        effects.consume(code);\n        size++;\n        return sequenceClose;\n      }\n\n      // Done!\n      if (size === sizeOpen) {\n        effects.exit('mathTextSequence');\n        effects.exit('mathText');\n        return ok(code);\n      }\n\n      // More or less accents: mark as data.\n      token.type = 'mathTextData';\n      return data(code);\n    }\n  }\n}\n\n/** @type {Resolver} */\nfunction resolveMathText(events) {\n  let tailExitIndex = events.length - 4;\n  let headEnterIndex = 3;\n  /** @type {number} */\n  let index;\n  /** @type {number | undefined} */\n  let enter;\n\n  // If we start and end with an EOL or a space.\n  if ((events[headEnterIndex][1].type === \"lineEnding\" || events[headEnterIndex][1].type === 'space') && (events[tailExitIndex][1].type === \"lineEnding\" || events[tailExitIndex][1].type === 'space')) {\n    index = headEnterIndex;\n\n    // And we have data.\n    while (++index < tailExitIndex) {\n      if (events[index][1].type === 'mathTextData') {\n        // Then we have padding.\n        events[tailExitIndex][1].type = 'mathTextPadding';\n        events[headEnterIndex][1].type = 'mathTextPadding';\n        headEnterIndex += 2;\n        tailExitIndex -= 2;\n        break;\n      }\n    }\n  }\n\n  // Merge adjacent spaces and data.\n  index = headEnterIndex - 1;\n  tailExitIndex++;\n  while (++index <= tailExitIndex) {\n    if (enter === undefined) {\n      if (index !== tailExitIndex && events[index][1].type !== \"lineEnding\") {\n        enter = index;\n      }\n    } else if (index === tailExitIndex || events[index][1].type === \"lineEnding\") {\n      events[enter][1].type = 'mathTextData';\n      if (index !== enter + 2) {\n        events[enter][1].end = events[index - 1][1].end;\n        events.splice(enter + 2, index - enter - 2);\n        tailExitIndex -= index - enter - 2;\n        index = enter + 2;\n      }\n      enter = undefined;\n    }\n  }\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Previous}\n */\nfunction previous(code) {\n  // If there is a previous code, there will always be a tail.\n  return code !== 36 || this.events[this.events.length - 1][1].type === \"characterEscape\";\n}","/**\n * @import {Options} from 'micromark-extension-math'\n * @import {Extension} from 'micromark-util-types'\n */\n\nimport { mathFlow } from './math-flow.js';\nimport { mathText } from './math-text.js';\n\n/**\n * Create an extension for `micromark` to enable math syntax.\n *\n * @param {Options | null | undefined} [options={}]\n *   Configuration (default: `{}`).\n * @returns {Extension}\n *   Extension for `micromark` that can be passed in `extensions`, to\n *   enable math syntax.\n */\nexport function math(options) {\n  return {\n    flow: {\n      [36]: mathFlow\n    },\n    text: {\n      [36]: mathText(options)\n    }\n  };\n}","/// <reference types=\"mdast-util-math\" />\n/// <reference types=\"remark-parse\" />\n/// <reference types=\"remark-stringify\" />\n\n/**\n * @typedef {import('mdast').Root} Root\n * @typedef {import('mdast-util-math').ToOptions} Options\n * @typedef {import('unified').Processor<Root>} Processor\n */\n\nimport {mathFromMarkdown, mathToMarkdown} from 'mdast-util-math'\nimport {math} from 'micromark-extension-math'\n\n/** @type {Readonly<Options>} */\nconst emptyOptions = {}\n\n/**\n * Add support for math.\n *\n * @param {Readonly<Options> | null | undefined} [options]\n *   Configuration (optional).\n * @returns {undefined}\n *   Nothing.\n */\nexport default function remarkMath(options) {\n  // @ts-expect-error: TS is wrong about `this`.\n  // eslint-disable-next-line unicorn/no-this-assignment\n  const self = /** @type {Processor} */ (this)\n  const settings = options || emptyOptions\n  const data = self.data()\n\n  const micromarkExtensions =\n    data.micromarkExtensions || (data.micromarkExtensions = [])\n  const fromMarkdownExtensions =\n    data.fromMarkdownExtensions || (data.fromMarkdownExtensions = [])\n  const toMarkdownExtensions =\n    data.toMarkdownExtensions || (data.toMarkdownExtensions = [])\n\n  micromarkExtensions.push(math(settings))\n  fromMarkdownExtensions.push(mathFromMarkdown())\n  toMarkdownExtensions.push(mathToMarkdown(settings))\n}\n","/**\n * @typedef {import('unist').Node} Node\n */\n\n/**\n * @typedef Options\n *   Configuration.\n * @property {boolean | null | undefined} [force=false]\n *   Whether to use `delete` to remove `position` fields.\n *\n *   The default is to set them to `undefined`.\n */\n\nimport {visit} from 'unist-util-visit'\n\n/**\n * Remove the `position` field from a tree.\n *\n * @param {Node} tree\n *   Tree to clean.\n * @param {Options | null | undefined} [options={force: false}]\n *   Configuration (default: `{force: false}`).\n * @returns {undefined}\n *   Nothing.\n */\nexport function removePosition(tree, options) {\n  const config = options || {}\n  const force = config.force || false\n\n  visit(tree, remove)\n\n  /**\n   * @param {Node} node\n   */\n  function remove(node) {\n    if (force) {\n      delete node.position\n    } else {\n      node.position = undefined\n    }\n  }\n}\n","/**\n * @typedef {import('hast').Root} Root\n *\n * @typedef {Pick<import('hast-util-from-html').Options, 'fragment'>} Options\n */\n\nimport {fromHtml} from 'hast-util-from-html'\nimport {removePosition} from 'unist-util-remove-position'\n\n/**\n * Turn HTML into a syntax tree, using browser APIs when available, so it has\n * a smaller bundle size there.\n *\n * @param {string} value\n *   Serialized HTML to parse.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {Root}\n *   Tree.\n */\nexport function fromHtmlIsomorphic(value, options) {\n  const tree = fromHtml(value, options)\n  removePosition(tree, {force: true})\n  delete tree.data\n  return tree\n}\n","/**\n * @typedef {import('unist').Node} UnistNode\n * @typedef {import('unist').Parent} UnistParent\n */\n\n/**\n * @typedef {Exclude<import('unist-util-is').Test, undefined> | undefined} Test\n *   Test from `unist-util-is`.\n *\n *   Note: we have remove and add `undefined`, because otherwise when generating\n *   automatic `.d.ts` files, TS tries to flatten paths from a local perspective,\n *   which doesn’t work when publishing on npm.\n */\n\n/**\n * @typedef {(\n *   Fn extends (value: any) => value is infer Thing\n *   ? Thing\n *   : Fallback\n * )} Predicate\n *   Get the value of a type guard `Fn`.\n * @template Fn\n *   Value; typically function that is a type guard (such as `(x): x is Y`).\n * @template Fallback\n *   Value to yield if `Fn` is not a type guard.\n */\n\n/**\n * @typedef {(\n *   Check extends null | undefined // No test.\n *   ? Value\n *   : Value extends {type: Check} // String (type) test.\n *   ? Value\n *   : Value extends Check // Partial test.\n *   ? Value\n *   : Check extends Function // Function test.\n *   ? Predicate<Check, Value> extends Value\n *     ? Predicate<Check, Value>\n *     : never\n *   : never // Some other test?\n * )} MatchesOne\n *   Check whether a node matches a primitive check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test, but not arrays.\n */\n\n/**\n * @typedef {(\n *   Check extends Array<any>\n *   ? MatchesOne<Value, Check[keyof Check]>\n *   : MatchesOne<Value, Check>\n * )} Matches\n *   Check whether a node matches a check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test.\n */\n\n/**\n * @typedef {(\n *   Kind extends {children: Array<infer Child>}\n *   ? Child\n *   : never\n * )} Child\n *   Collect nodes that can be parents of `Child`.\n * @template {UnistNode} Kind\n *   All node types.\n */\n\nimport {convert} from 'unist-util-is'\n\n/**\n * Find the first node in `parent` after another `node` or after an index,\n * that passes `test`.\n *\n * @param parent\n *   Parent node.\n * @param index\n *   Child node or index.\n * @param [test=undefined]\n *   Test for child to look for (optional).\n * @returns\n *   A child (matching `test`, if given) or `undefined`.\n */\nexport const findAfter =\n  // Note: overloads like this are needed to support optional generics.\n  /**\n   * @type {(\n   *   (<Kind extends UnistParent, Check extends Test>(parent: Kind, index: Child<Kind> | number, test: Check) => Matches<Child<Kind>, Check> | undefined) &\n   *   (<Kind extends UnistParent>(parent: Kind, index: Child<Kind> | number, test?: null | undefined) => Child<Kind> | undefined)\n   * )}\n   */\n  (\n    /**\n     * @param {UnistParent} parent\n     * @param {UnistNode | number} index\n     * @param {Test} [test]\n     * @returns {UnistNode | undefined}\n     */\n    function (parent, index, test) {\n      const is = convert(test)\n\n      if (!parent || !parent.type || !parent.children) {\n        throw new Error('Expected parent node')\n      }\n\n      if (typeof index === 'number') {\n        if (index < 0 || index === Number.POSITIVE_INFINITY) {\n          throw new Error('Expected positive finite number as index')\n        }\n      } else {\n        index = parent.children.indexOf(index)\n\n        if (index < 0) {\n          throw new Error('Expected child node or index')\n        }\n      }\n\n      while (++index < parent.children.length) {\n        if (is(parent.children[index], index, parent)) {\n          return parent.children[index]\n        }\n      }\n\n      return undefined\n    }\n  )\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Parents} Parents\n */\n\n/**\n * @template Fn\n * @template Fallback\n * @typedef {Fn extends (value: any) => value is infer Thing ? Thing : Fallback} Predicate\n */\n\n/**\n * @callback Check\n *   Check that an arbitrary value is an element.\n * @param {unknown} this\n *   Context object (`this`) to call `test` with\n * @param {unknown} [element]\n *   Anything (typically a node).\n * @param {number | null | undefined} [index]\n *   Position of `element` in its parent.\n * @param {Parents | null | undefined} [parent]\n *   Parent of `element`.\n * @returns {boolean}\n *   Whether this is an element and passes a test.\n *\n * @typedef {Array<TestFunction | string> | TestFunction | string | null | undefined} Test\n *   Check for an arbitrary element.\n *\n *   * when `string`, checks that the element has that tag name\n *   * when `function`, see `TestFunction`\n *   * when `Array`, checks if one of the subtests pass\n *\n * @callback TestFunction\n *   Check if an element passes a test.\n * @param {unknown} this\n *   The given context.\n * @param {Element} element\n *   An element.\n * @param {number | undefined} [index]\n *   Position of `element` in its parent.\n * @param {Parents | undefined} [parent]\n *   Parent of `element`.\n * @returns {boolean | undefined | void}\n *   Whether this element passes the test.\n *\n *   Note: `void` is included until TS sees no return as `undefined`.\n */\n\n/**\n * Check if `element` is an `Element` and whether it passes the given test.\n *\n * @param element\n *   Thing to check, typically `element`.\n * @param test\n *   Check for a specific element.\n * @param index\n *   Position of `element` in its parent.\n * @param parent\n *   Parent of `element`.\n * @param context\n *   Context object (`this`) to call `test` with.\n * @returns\n *   Whether `element` is an `Element` and passes a test.\n * @throws\n *   When an incorrect `test`, `index`, or `parent` is given; there is no error\n *   thrown when `element` is not a node or not an element.\n */\nexport const isElement =\n  // Note: overloads in JSDoc can’t yet use different `@template`s.\n  /**\n   * @type {(\n   *   (<Condition extends TestFunction>(element: unknown, test: Condition, index?: number | null | undefined, parent?: Parents | null | undefined, context?: unknown) => element is Element & Predicate<Condition, Element>) &\n   *   (<Condition extends string>(element: unknown, test: Condition, index?: number | null | undefined, parent?: Parents | null | undefined, context?: unknown) => element is Element & {tagName: Condition}) &\n   *   ((element?: null | undefined) => false) &\n   *   ((element: unknown, test?: null | undefined, index?: number | null | undefined, parent?: Parents | null | undefined, context?: unknown) => element is Element) &\n   *   ((element: unknown, test?: Test, index?: number | null | undefined, parent?: Parents | null | undefined, context?: unknown) => boolean)\n   * )}\n   */\n  (\n    /**\n     * @param {unknown} [element]\n     * @param {Test | undefined} [test]\n     * @param {number | null | undefined} [index]\n     * @param {Parents | null | undefined} [parent]\n     * @param {unknown} [context]\n     * @returns {boolean}\n     */\n    // eslint-disable-next-line max-params\n    function (element, test, index, parent, context) {\n      const check = convertElement(test)\n\n      if (\n        index !== null &&\n        index !== undefined &&\n        (typeof index !== 'number' ||\n          index < 0 ||\n          index === Number.POSITIVE_INFINITY)\n      ) {\n        throw new Error('Expected positive finite `index`')\n      }\n\n      if (\n        parent !== null &&\n        parent !== undefined &&\n        (!parent.type || !parent.children)\n      ) {\n        throw new Error('Expected valid `parent`')\n      }\n\n      if (\n        (index === null || index === undefined) !==\n        (parent === null || parent === undefined)\n      ) {\n        throw new Error('Expected both `index` and `parent`')\n      }\n\n      return looksLikeAnElement(element)\n        ? check.call(context, element, index, parent)\n        : false\n    }\n  )\n\n/**\n * Generate a check from a test.\n *\n * Useful if you’re going to test many nodes, for example when creating a\n * utility where something else passes a compatible test.\n *\n * The created function is a bit faster because it expects valid input only:\n * an `element`, `index`, and `parent`.\n *\n * @param test\n *   A test for a specific element.\n * @returns\n *   A check.\n */\nexport const convertElement =\n  // Note: overloads in JSDoc can’t yet use different `@template`s.\n  /**\n   * @type {(\n   *   (<Condition extends TestFunction>(test: Condition) => (element: unknown, index?: number | null | undefined, parent?: Parents | null | undefined, context?: unknown) => element is Element & Predicate<Condition, Element>) &\n   *   (<Condition extends string>(test: Condition) => (element: unknown, index?: number | null | undefined, parent?: Parents | null | undefined, context?: unknown) => element is Element & {tagName: Condition}) &\n   *   ((test?: null | undefined) => (element?: unknown, index?: number | null | undefined, parent?: Parents | null | undefined, context?: unknown) => element is Element) &\n   *   ((test?: Test) => Check)\n   * )}\n   */\n  (\n    /**\n     * @param {Test | null | undefined} [test]\n     * @returns {Check}\n     */\n    function (test) {\n      if (test === null || test === undefined) {\n        return element\n      }\n\n      if (typeof test === 'string') {\n        return tagNameFactory(test)\n      }\n\n      // Assume array.\n      if (typeof test === 'object') {\n        return anyFactory(test)\n      }\n\n      if (typeof test === 'function') {\n        return castFactory(test)\n      }\n\n      throw new Error('Expected function, string, or array as `test`')\n    }\n  )\n\n/**\n * Handle multiple tests.\n *\n * @param {Array<TestFunction | string>} tests\n * @returns {Check}\n */\nfunction anyFactory(tests) {\n  /** @type {Array<Check>} */\n  const checks = []\n  let index = -1\n\n  while (++index < tests.length) {\n    checks[index] = convertElement(tests[index])\n  }\n\n  return castFactory(any)\n\n  /**\n   * @this {unknown}\n   * @type {TestFunction}\n   */\n  function any(...parameters) {\n    let index = -1\n\n    while (++index < checks.length) {\n      if (checks[index].apply(this, parameters)) return true\n    }\n\n    return false\n  }\n}\n\n/**\n * Turn a string into a test for an element with a certain type.\n *\n * @param {string} check\n * @returns {Check}\n */\nfunction tagNameFactory(check) {\n  return castFactory(tagName)\n\n  /**\n   * @param {Element} element\n   * @returns {boolean}\n   */\n  function tagName(element) {\n    return element.tagName === check\n  }\n}\n\n/**\n * Turn a custom test into a test for an element that passes that test.\n *\n * @param {TestFunction} testFunction\n * @returns {Check}\n */\nfunction castFactory(testFunction) {\n  return check\n\n  /**\n   * @this {unknown}\n   * @type {Check}\n   */\n  function check(value, index, parent) {\n    return Boolean(\n      looksLikeAnElement(value) &&\n        testFunction.call(\n          this,\n          value,\n          typeof index === 'number' ? index : undefined,\n          parent || undefined\n        )\n    )\n  }\n}\n\n/**\n * Make sure something is an element.\n *\n * @param {unknown} element\n * @returns {element is Element}\n */\nfunction element(element) {\n  return Boolean(\n    element &&\n      typeof element === 'object' &&\n      'type' in element &&\n      element.type === 'element' &&\n      'tagName' in element &&\n      typeof element.tagName === 'string'\n  )\n}\n\n/**\n * @param {unknown} value\n * @returns {value is Element}\n */\nfunction looksLikeAnElement(value) {\n  return (\n    value !== null &&\n    typeof value === 'object' &&\n    'type' in value &&\n    'tagName' in value\n  )\n}\n","/**\n * @typedef {import('hast').Comment} Comment\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Nodes} Nodes\n * @typedef {import('hast').Parents} Parents\n * @typedef {import('hast').Text} Text\n * @typedef {import('hast-util-is-element').TestFunction} TestFunction\n */\n\n/**\n * @typedef {'normal' | 'nowrap' | 'pre' | 'pre-wrap'} Whitespace\n *   Valid and useful whitespace values (from CSS).\n *\n * @typedef {0 | 1 | 2} BreakNumber\n *   Specific break:\n *\n *   *   `0` — space\n *   *   `1` — line ending\n *   *   `2` — blank line\n *\n * @typedef {'\\n'} BreakForce\n *   Forced break.\n *\n * @typedef {boolean} BreakValue\n *   Whether there was a break.\n *\n * @typedef {BreakNumber | BreakValue | undefined} BreakBefore\n *   Any value for a break before.\n *\n * @typedef {BreakForce | BreakNumber | BreakValue | undefined} BreakAfter\n *   Any value for a break after.\n *\n * @typedef CollectionInfo\n *   Info on current collection.\n * @property {BreakAfter} breakAfter\n *   Whether there was a break after.\n * @property {BreakBefore} breakBefore\n *   Whether there was a break before.\n * @property {Whitespace} whitespace\n *   Current whitespace setting.\n *\n * @typedef Options\n *   Configuration.\n * @property {Whitespace | null | undefined} [whitespace='normal']\n *   Initial CSS whitespace setting to use (default: `'normal'`).\n */\n\nimport {findAfter} from 'unist-util-find-after'\nimport {convertElement} from 'hast-util-is-element'\n\nconst searchLineFeeds = /\\n/g\nconst searchTabOrSpaces = /[\\t ]+/g\n\nconst br = convertElement('br')\nconst cell = convertElement(isCell)\nconst p = convertElement('p')\nconst row = convertElement('tr')\n\n// Note that we don’t need to include void elements here as they don’t have text.\n// See: <https://github.com/wooorm/html-void-elements>\nconst notRendered = convertElement([\n  // List from: <https://html.spec.whatwg.org/multipage/rendering.html#hidden-elements>\n  'datalist',\n  'head',\n  'noembed',\n  'noframes',\n  'noscript', // Act as if we support scripting.\n  'rp',\n  'script',\n  'style',\n  'template',\n  'title',\n  // Hidden attribute.\n  hidden,\n  // From: <https://html.spec.whatwg.org/multipage/rendering.html#flow-content-3>\n  closedDialog\n])\n\n// See: <https://html.spec.whatwg.org/multipage/rendering.html#the-css-user-agent-style-sheet-and-presentational-hints>\nconst blockOrCaption = convertElement([\n  'address', // Flow content\n  'article', // Sections and headings\n  'aside', // Sections and headings\n  'blockquote', // Flow content\n  'body', // Page\n  'caption', // `table-caption`\n  'center', // Flow content (legacy)\n  'dd', // Lists\n  'dialog', // Flow content\n  'dir', // Lists (legacy)\n  'dl', // Lists\n  'dt', // Lists\n  'div', // Flow content\n  'figure', // Flow content\n  'figcaption', // Flow content\n  'footer', // Flow content\n  'form,', // Flow content\n  'h1', // Sections and headings\n  'h2', // Sections and headings\n  'h3', // Sections and headings\n  'h4', // Sections and headings\n  'h5', // Sections and headings\n  'h6', // Sections and headings\n  'header', // Flow content\n  'hgroup', // Sections and headings\n  'hr', // Flow content\n  'html', // Page\n  'legend', // Flow content\n  'li', // Lists (as `display: list-item`)\n  'listing', // Flow content (legacy)\n  'main', // Flow content\n  'menu', // Lists\n  'nav', // Sections and headings\n  'ol', // Lists\n  'p', // Flow content\n  'plaintext', // Flow content (legacy)\n  'pre', // Flow content\n  'section', // Sections and headings\n  'ul', // Lists\n  'xmp' // Flow content (legacy)\n])\n\n/**\n * Get the plain-text value of a node.\n *\n * ###### Algorithm\n *\n * *   if `tree` is a comment, returns its `value`\n * *   if `tree` is a text, applies normal whitespace collapsing to its\n *     `value`, as defined by the CSS Text spec\n * *   if `tree` is a root or element, applies an algorithm similar to the\n *     `innerText` getter as defined by HTML\n *\n * ###### Notes\n *\n * > 👉 **Note**: the algorithm acts as if `tree` is being rendered, and as if\n * > we’re a CSS-supporting user agent, with scripting enabled.\n *\n * *   if `tree` is an element that is not displayed (such as a `head`), we’ll\n *     still use the `innerText` algorithm instead of switching to `textContent`\n * *   if descendants of `tree` are elements that are not displayed, they are\n *     ignored\n * *   CSS is not considered, except for the default user agent style sheet\n * *   a line feed is collapsed instead of ignored in cases where Fullwidth, Wide,\n *     or Halfwidth East Asian Width characters are used, the same goes for a case\n *     with Chinese, Japanese, or Yi writing systems\n * *   replaced elements (such as `audio`) are treated like non-replaced elements\n *\n * @param {Nodes} tree\n *   Tree to turn into text.\n * @param {Readonly<Options> | null | undefined} [options]\n *   Configuration (optional).\n * @returns {string}\n *   Serialized `tree`.\n */\nexport function toText(tree, options) {\n  const options_ = options || {}\n  const children = 'children' in tree ? tree.children : []\n  const block = blockOrCaption(tree)\n  const whitespace = inferWhitespace(tree, {\n    whitespace: options_.whitespace || 'normal',\n    breakBefore: false,\n    breakAfter: false\n  })\n\n  /** @type {Array<BreakNumber | string>} */\n  const results = []\n\n  // Treat `text` and `comment` as having normal white-space.\n  // This deviates from the spec as in the DOM the node’s `.data` has to be\n  // returned.\n  // If you want that behavior use `hast-util-to-string`.\n  // All other nodes are later handled as if they are `element`s (so the\n  // algorithm also works on a `root`).\n  // Nodes without children are treated as a void element, so `doctype` is thus\n  // ignored.\n  if (tree.type === 'text' || tree.type === 'comment') {\n    results.push(\n      ...collectText(tree, {\n        whitespace,\n        breakBefore: true,\n        breakAfter: true\n      })\n    )\n  }\n\n  // 1.  If this element is not being rendered, or if the user agent is a\n  //     non-CSS user agent, then return the same value as the textContent IDL\n  //     attribute on this element.\n  //\n  //     Note: we’re not supporting stylesheets so we’re acting as if the node\n  //     is rendered.\n  //\n  //     If you want that behavior use `hast-util-to-string`.\n  //     Important: we’ll have to account for this later though.\n\n  // 2.  Let results be a new empty list.\n  let index = -1\n\n  // 3.  For each child node node of this element:\n  while (++index < children.length) {\n    // 3.1. Let current be the list resulting in running the inner text\n    //      collection steps with node.\n    //      Each item in results will either be a JavaScript string or a\n    //      positive integer (a required line break count).\n    // 3.2. For each item item in current, append item to results.\n    results.push(\n      ...renderedTextCollection(\n        children[index],\n        // @ts-expect-error: `tree` is a parent if we’re here.\n        tree,\n        {\n          whitespace,\n          breakBefore: index ? undefined : block,\n          breakAfter:\n            index < children.length - 1 ? br(children[index + 1]) : block\n        }\n      )\n    )\n  }\n\n  // 4.  Remove any items from results that are the empty string.\n  // 5.  Remove any runs of consecutive required line break count items at the\n  //     start or end of results.\n  // 6.  Replace each remaining run of consecutive required line break count\n  //     items with a string consisting of as many U+000A LINE FEED (LF)\n  //     characters as the maximum of the values in the required line break\n  //     count items.\n  /** @type {Array<string>} */\n  const result = []\n  /** @type {number | undefined} */\n  let count\n\n  index = -1\n\n  while (++index < results.length) {\n    const value = results[index]\n\n    if (typeof value === 'number') {\n      if (count !== undefined && value > count) count = value\n    } else if (value) {\n      if (count !== undefined && count > -1) {\n        result.push('\\n'.repeat(count) || ' ')\n      }\n\n      count = -1\n      result.push(value)\n    }\n  }\n\n  // 7.  Return the concatenation of the string items in results.\n  return result.join('')\n}\n\n/**\n * <https://html.spec.whatwg.org/multipage/dom.html#rendered-text-collection-steps>\n *\n * @param {Nodes} node\n * @param {Parents} parent\n * @param {CollectionInfo} info\n * @returns {Array<BreakNumber | string>}\n */\nfunction renderedTextCollection(node, parent, info) {\n  if (node.type === 'element') {\n    return collectElement(node, parent, info)\n  }\n\n  if (node.type === 'text') {\n    return info.whitespace === 'normal'\n      ? collectText(node, info)\n      : collectPreText(node)\n  }\n\n  return []\n}\n\n/**\n * Collect an element.\n *\n * @param {Element} node\n *   Element node.\n * @param {Parents} parent\n * @param {CollectionInfo} info\n *   Info on current collection.\n * @returns {Array<BreakNumber | string>}\n */\nfunction collectElement(node, parent, info) {\n  // First we infer the `white-space` property.\n  const whitespace = inferWhitespace(node, info)\n  const children = node.children || []\n  let index = -1\n  /** @type {Array<BreakNumber | string>} */\n  let items = []\n\n  // We’re ignoring point 3, and exiting without any content here, because we\n  // deviated from the spec in `toText` at step 3.\n  if (notRendered(node)) {\n    return items\n  }\n\n  /** @type {BreakNumber | undefined} */\n  let prefix\n  /** @type {BreakForce | BreakNumber | undefined} */\n  let suffix\n  // Note: we first detect if there is going to be a break before or after the\n  // contents, as that changes the white-space handling.\n\n  // 2.  If node’s computed value of `visibility` is not `visible`, then return\n  //     items.\n  //\n  //     Note: Ignored, as everything is visible by default user agent styles.\n\n  // 3.  If node is not being rendered, then return items. [...]\n  //\n  //     Note: We already did this above.\n\n  // See `collectText` for step 4.\n\n  // 5.  If node is a `<br>` element, then append a string containing a single\n  //     U+000A LINE FEED (LF) character to items.\n  if (br(node)) {\n    suffix = '\\n'\n  }\n\n  // 7.  If node’s computed value of `display` is `table-row`, and node’s CSS\n  //     box is not the last `table-row` box of the nearest ancestor `table`\n  //     box, then append a string containing a single U+000A LINE FEED (LF)\n  //     character to items.\n  //\n  //     See: <https://html.spec.whatwg.org/multipage/rendering.html#tables-2>\n  //     Note: needs further investigation as this does not account for implicit\n  //     rows.\n  else if (\n    row(node) &&\n    // @ts-expect-error: something up with types of parents.\n    findAfter(parent, node, row)\n  ) {\n    suffix = '\\n'\n  }\n\n  // 8.  If node is a `<p>` element, then append 2 (a required line break count)\n  //     at the beginning and end of items.\n  else if (p(node)) {\n    prefix = 2\n    suffix = 2\n  }\n\n  // 9.  If node’s used value of `display` is block-level or `table-caption`,\n  //     then append 1 (a required line break count) at the beginning and end of\n  //     items.\n  else if (blockOrCaption(node)) {\n    prefix = 1\n    suffix = 1\n  }\n\n  // 1.  Let items be the result of running the inner text collection steps with\n  //     each child node of node in tree order, and then concatenating the\n  //     results to a single list.\n  while (++index < children.length) {\n    items = items.concat(\n      renderedTextCollection(children[index], node, {\n        whitespace,\n        breakBefore: index ? undefined : prefix,\n        breakAfter:\n          index < children.length - 1 ? br(children[index + 1]) : suffix\n      })\n    )\n  }\n\n  // 6.  If node’s computed value of `display` is `table-cell`, and node’s CSS\n  //     box is not the last `table-cell` box of its enclosing `table-row` box,\n  //     then append a string containing a single U+0009 CHARACTER TABULATION\n  //     (tab) character to items.\n  //\n  //     See: <https://html.spec.whatwg.org/multipage/rendering.html#tables-2>\n  if (\n    cell(node) &&\n    // @ts-expect-error: something up with types of parents.\n    findAfter(parent, node, cell)\n  ) {\n    items.push('\\t')\n  }\n\n  // Add the pre- and suffix.\n  if (prefix) items.unshift(prefix)\n  if (suffix) items.push(suffix)\n\n  return items\n}\n\n/**\n * 4.  If node is a Text node, then for each CSS text box produced by node,\n *     in content order, compute the text of the box after application of the\n *     CSS `white-space` processing rules and `text-transform` rules, set\n *     items to the list of the resulting strings, and return items.\n *     The CSS `white-space` processing rules are slightly modified:\n *     collapsible spaces at the end of lines are always collapsed, but they\n *     are only removed if the line is the last line of the block, or it ends\n *     with a br element.\n *     Soft hyphens should be preserved.\n *\n *     Note: See `collectText` and `collectPreText`.\n *     Note: we don’t deal with `text-transform`, no element has that by\n *     default.\n *\n * See: <https://drafts.csswg.org/css-text/#white-space-phase-1>\n *\n * @param {Comment | Text} node\n *   Text node.\n * @param {CollectionInfo} info\n *   Info on current collection.\n * @returns {Array<BreakNumber | string>}\n *   Result.\n */\nfunction collectText(node, info) {\n  const value = String(node.value)\n  /** @type {Array<string>} */\n  const lines = []\n  /** @type {Array<BreakNumber | string>} */\n  const result = []\n  let start = 0\n\n  while (start <= value.length) {\n    searchLineFeeds.lastIndex = start\n\n    const match = searchLineFeeds.exec(value)\n    const end = match && 'index' in match ? match.index : value.length\n\n    lines.push(\n      // Any sequence of collapsible spaces and tabs immediately preceding or\n      // following a segment break is removed.\n      trimAndCollapseSpacesAndTabs(\n        // […] ignoring bidi formatting characters (characters with the\n        // Bidi_Control property [UAX9]: ALM, LTR, RTL, LRE-RLO, LRI-PDI) as if\n        // they were not there.\n        value\n          .slice(start, end)\n          .replace(/[\\u061C\\u200E\\u200F\\u202A-\\u202E\\u2066-\\u2069]/g, ''),\n        start === 0 ? info.breakBefore : true,\n        end === value.length ? info.breakAfter : true\n      )\n    )\n\n    start = end + 1\n  }\n\n  // Collapsible segment breaks are transformed for rendering according to the\n  // segment break transformation rules.\n  // So here we jump to 4.1.2 of [CSSTEXT]:\n  // Any collapsible segment break immediately following another collapsible\n  // segment break is removed\n  let index = -1\n  /** @type {BreakNumber | undefined} */\n  let join\n\n  while (++index < lines.length) {\n    // *   If the character immediately before or immediately after the segment\n    //     break is the zero-width space character (U+200B), then the break is\n    //     removed, leaving behind the zero-width space.\n    if (\n      lines[index].charCodeAt(lines[index].length - 1) === 0x20_0b /* ZWSP */ ||\n      (index < lines.length - 1 &&\n        lines[index + 1].charCodeAt(0) === 0x20_0b) /* ZWSP */\n    ) {\n      result.push(lines[index])\n      join = undefined\n    }\n\n    // *   Otherwise, if the East Asian Width property [UAX11] of both the\n    //     character before and after the segment break is Fullwidth, Wide, or\n    //     Halfwidth (not Ambiguous), and neither side is Hangul, then the\n    //     segment break is removed.\n    //\n    //     Note: ignored.\n    // *   Otherwise, if the writing system of the segment break is Chinese,\n    //     Japanese, or Yi, and the character before or after the segment break\n    //     is punctuation or a symbol (Unicode general category P* or S*) and\n    //     has an East Asian Width property of Ambiguous, and the character on\n    //     the other side of the segment break is Fullwidth, Wide, or Halfwidth,\n    //     and not Hangul, then the segment break is removed.\n    //\n    //     Note: ignored.\n\n    // *   Otherwise, the segment break is converted to a space (U+0020).\n    else if (lines[index]) {\n      if (typeof join === 'number') result.push(join)\n      result.push(lines[index])\n      join = 0\n    } else if (index === 0 || index === lines.length - 1) {\n      // If this line is empty, and it’s the first or last, add a space.\n      // Note that this function is only called in normal whitespace, so we\n      // don’t worry about `pre`.\n      result.push(0)\n    }\n  }\n\n  return result\n}\n\n/**\n * Collect a text node as “pre” whitespace.\n *\n * @param {Text} node\n *   Text node.\n * @returns {Array<BreakNumber | string>}\n *   Result.\n */\nfunction collectPreText(node) {\n  return [String(node.value)]\n}\n\n/**\n * 3.  Every collapsible tab is converted to a collapsible space (U+0020).\n * 4.  Any collapsible space immediately following another collapsible\n *     space—even one outside the boundary of the inline containing that\n *     space, provided both spaces are within the same inline formatting\n *     context—is collapsed to have zero advance width. (It is invisible,\n *     but retains its soft wrap opportunity, if any.)\n *\n * @param {string} value\n *   Value to collapse.\n * @param {BreakBefore} breakBefore\n *   Whether there was a break before.\n * @param {BreakAfter} breakAfter\n *   Whether there was a break after.\n * @returns {string}\n *   Result.\n */\nfunction trimAndCollapseSpacesAndTabs(value, breakBefore, breakAfter) {\n  /** @type {Array<string>} */\n  const result = []\n  let start = 0\n  /** @type {number | undefined} */\n  let end\n\n  while (start < value.length) {\n    searchTabOrSpaces.lastIndex = start\n    const match = searchTabOrSpaces.exec(value)\n    end = match ? match.index : value.length\n\n    // If we’re not directly after a segment break, but there was white space,\n    // add an empty value that will be turned into a space.\n    if (!start && !end && match && !breakBefore) {\n      result.push('')\n    }\n\n    if (start !== end) {\n      result.push(value.slice(start, end))\n    }\n\n    start = match ? end + match[0].length : end\n  }\n\n  // If we reached the end, there was trailing white space, and there’s no\n  // segment break after this node, add an empty value that will be turned\n  // into a space.\n  if (start !== end && !breakAfter) {\n    result.push('')\n  }\n\n  return result.join(' ')\n}\n\n/**\n * Figure out the whitespace of a node.\n *\n * We don’t support void elements here (so `nobr wbr` -> `normal` is ignored).\n *\n * @param {Nodes} node\n *   Node (typically `Element`).\n * @param {CollectionInfo} info\n *   Info on current collection.\n * @returns {Whitespace}\n *   Applied whitespace.\n */\nfunction inferWhitespace(node, info) {\n  if (node.type === 'element') {\n    const properties = node.properties || {}\n    switch (node.tagName) {\n      case 'listing':\n      case 'plaintext':\n      case 'xmp': {\n        return 'pre'\n      }\n\n      case 'nobr': {\n        return 'nowrap'\n      }\n\n      case 'pre': {\n        return properties.wrap ? 'pre-wrap' : 'pre'\n      }\n\n      case 'td':\n      case 'th': {\n        return properties.noWrap ? 'nowrap' : info.whitespace\n      }\n\n      case 'textarea': {\n        return 'pre-wrap'\n      }\n\n      default:\n    }\n  }\n\n  return info.whitespace\n}\n\n/**\n * @type {TestFunction}\n * @param {Element} node\n * @returns {node is {properties: {hidden: true}}}\n */\nfunction hidden(node) {\n  return Boolean((node.properties || {}).hidden)\n}\n\n/**\n * @type {TestFunction}\n * @param {Element} node\n * @returns {node is {tagName: 'td' | 'th'}}\n */\nfunction isCell(node) {\n  return node.tagName === 'td' || node.tagName === 'th'\n}\n\n/**\n * @type {TestFunction}\n */\nfunction closedDialog(node) {\n  return node.tagName === 'dialog' && !(node.properties || {}).open\n}\n","/**\n * @import {ElementContent, Root} from 'hast'\n * @import {KatexOptions} from 'katex'\n * @import {VFile} from 'vfile'\n */\n\n/**\n * @typedef {Omit<KatexOptions, 'displayMode' | 'throwOnError'>} Options\n */\n\nimport {fromHtmlIsomorphic} from 'hast-util-from-html-isomorphic'\nimport {toText} from 'hast-util-to-text'\nimport katex from 'katex'\nimport {SKIP, visitParents} from 'unist-util-visit-parents'\n\n/** @type {Readonly<Options>} */\nconst emptyOptions = {}\n/** @type {ReadonlyArray<unknown>} */\nconst emptyClasses = []\n\n/**\n * Render elements with a `language-math` (or `math-display`, `math-inline`)\n * class with KaTeX.\n *\n * @param {Readonly<Options> | null | undefined} [options]\n *   Configuration (optional).\n * @returns\n *   Transform.\n */\nexport default function rehypeKatex(options) {\n  const settings = options || emptyOptions\n\n  /**\n   * Transform.\n   *\n   * @param {Root} tree\n   *   Tree.\n   * @param {VFile} file\n   *   File.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  return function (tree, file) {\n    visitParents(tree, 'element', function (element, parents) {\n      const classes = Array.isArray(element.properties.className)\n        ? element.properties.className\n        : emptyClasses\n      // This class can be generated from markdown with ` ```math `.\n      const languageMath = classes.includes('language-math')\n      // This class is used by `remark-math` for flow math (block, `$$\\nmath\\n$$`).\n      const mathDisplay = classes.includes('math-display')\n      // This class is used by `remark-math` for text math (inline, `$math$`).\n      const mathInline = classes.includes('math-inline')\n      let displayMode = mathDisplay\n\n      // Any class is fine.\n      if (!languageMath && !mathDisplay && !mathInline) {\n        return\n      }\n\n      let parent = parents[parents.length - 1]\n      let scope = element\n\n      // If this was generated with ` ```math `, replace the `<pre>` and use\n      // display.\n      if (\n        element.tagName === 'code' &&\n        languageMath &&\n        parent &&\n        parent.type === 'element' &&\n        parent.tagName === 'pre'\n      ) {\n        scope = parent\n        parent = parents[parents.length - 2]\n        displayMode = true\n      }\n\n      /* c8 ignore next -- verbose to test. */\n      if (!parent) return\n\n      const value = toText(scope, {whitespace: 'pre'})\n\n      /** @type {Array<ElementContent> | string | undefined} */\n      let result\n\n      try {\n        result = katex.renderToString(value, {\n          ...settings,\n          displayMode,\n          throwOnError: true\n        })\n      } catch (error) {\n        const cause = /** @type {Error} */ (error)\n        const ruleId = cause.name.toLowerCase()\n\n        file.message('Could not render math with KaTeX', {\n          ancestors: [...parents, element],\n          cause,\n          place: element.position,\n          ruleId,\n          source: 'rehype-katex'\n        })\n\n        // KaTeX *should* handle `ParseError` itself, but not others.\n        // it doesn’t always:\n        // <https://github.com/remarkjs/react-markdown/issues/853>\n        try {\n          result = katex.renderToString(value, {\n            ...settings,\n            displayMode,\n            strict: 'ignore',\n            throwOnError: false\n          })\n        } catch {\n          // Generate similar markup if this is an other error.\n          // See: <https://github.com/KaTeX/KaTeX/blob/5dc7af0/docs/error.md>.\n          result = [\n            {\n              type: 'element',\n              tagName: 'span',\n              properties: {\n                className: ['katex-error'],\n                style: 'color:' + (settings.errorColor || '#cc0000'),\n                title: String(error)\n              },\n              children: [{type: 'text', value}]\n            }\n          ]\n        }\n      }\n\n      if (typeof result === 'string') {\n        const root = fromHtmlIsomorphic(result, {fragment: true})\n        // Cast as we don’t expect `doctypes` in KaTeX result.\n        result = /** @type {Array<ElementContent>} */ (root.children)\n      }\n\n      const index = parent.children.indexOf(scope)\n      parent.children.splice(index, 1, ...result)\n      return SKIP\n    })\n  }\n}\n","import remarkMath from 'remark-math'\r\nimport rehypeKatex from 'rehype-katex'\r\nimport type { Element, ElementContent, Root, RootContent } from 'hast'\r\nimport type { MarkdownPlugin } from '../core/types'\r\n\r\nexport interface MathPluginOptions {\r\n  /** Enable `$...$` inline math (remark-math option). */\r\n  singleDollarTextMath?: boolean\r\n  /** Optional custom inline delimiters, e.g. `['\\\\(', '\\\\)']`. */\r\n  inlineDelimiters?: [string, string]\r\n  /** Optional custom display delimiters, e.g. `['\\\\[', '\\\\]']`. */\r\n  displayDelimiters?: [string, string]\r\n  /** Options passed to rehype-katex. */\r\n  katex?: Record<string, unknown>\r\n}\r\n\r\nfunction classes(node: Element): string[] {\r\n  const value: unknown = node.properties?.className\r\n  if (Array.isArray(value)) return value.map(String)\r\n  return typeof value === 'string' ? value.split(/\\s+/) : []\r\n}\r\n\r\nfunction textContent(node: RootContent): string {\r\n  if (node.type === 'text') return node.value\r\n  if (node.type !== 'element') return ''\r\n  return node.children.map(textContent).join('')\r\n}\r\n\r\nfunction isMathCode(node: Element): boolean {\r\n  const names = classes(node)\r\n  return names.includes('language-math') && names.some((name) => name.startsWith('math-'))\r\n}\r\n\r\nfunction annotation(\r\n  display: boolean,\r\n  tex: string,\r\n  children: ElementContent[],\r\n): Element {\r\n  return {\r\n    type: 'element',\r\n    tagName: 'vmd-math',\r\n    properties: {\r\n      'data-vmd-math': '',\r\n      'data-tex': tex,\r\n      'data-display': display ? 'true' : 'false',\r\n    },\r\n    children,\r\n  }\r\n}\r\n\r\nfunction annotate(nodes: ElementContent[]): ElementContent[] {\r\n  return nodes.map((node) => {\r\n    if (node.type !== 'element') return node\r\n\r\n    if (node.tagName === 'code' && isMathCode(node)) {\r\n      const display = classes(node).includes('math-display')\r\n      const tex = textContent(node)\r\n      return annotation(display, tex, [node])\r\n    }\r\n\r\n    if (node.tagName === 'pre') {\r\n      const code = node.children.find(\r\n        (child): child is Element =>\r\n          child.type === 'element' && child.tagName === 'code' && isMathCode(child),\r\n      )\r\n      if (code) {\r\n        return annotation(\r\n          classes(code).includes('math-display'),\r\n          textContent(code),\r\n          [node],\r\n        )\r\n      }\r\n    }\r\n\r\n    if (node.children.length > 0) {\r\n      return { ...node, children: annotate(node.children) }\r\n    }\r\n    return node\r\n  })\r\n}\r\n\r\nfunction rehypeMathAnnotation() {\r\n  return (tree: Root) => {\r\n    tree.children = annotate(tree.children as ElementContent[])\r\n  }\r\n}\r\n\r\nfunction escapeRegExp(value: string): string {\r\n  return value.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\r\n}\r\n\r\nfunction replaceDelimiters(\r\n  source: string,\r\n  options: MathPluginOptions,\r\n): string {\r\n  const inline = options.inlineDelimiters\r\n  const display = options.displayDelimiters\r\n  if (!inline && !display) return source\r\n\r\n  return source\r\n    .split(/(```[\\s\\S]*?```|`[^`]*`)/g)\r\n    .map((part, index) => {\r\n      if (index % 2 === 1) return part\r\n      let value = part\r\n      if (display) {\r\n        value = value.replace(\r\n          new RegExp(\r\n            `${escapeRegExp(display[0])}([\\\\s\\\\S]*?)${escapeRegExp(display[1])}`,\r\n            'g',\r\n          ),\r\n          (_match, body: string) => `\\n$$\\n${body}\\n$$\\n`,\r\n        )\r\n      }\r\n      if (inline) {\r\n        value = value.replace(\r\n          new RegExp(\r\n            `${escapeRegExp(inline[0])}([\\\\s\\\\S]*?)${escapeRegExp(inline[1])}`,\r\n            'g',\r\n          ),\r\n          (_match, body: string) => `$${body}$`,\r\n        )\r\n      }\r\n      return value\r\n    })\r\n    .join('')\r\n}\r\n\r\n/**\r\n * Official math plugin. Math is parsed with remark-math, annotated with its\r\n * TeX source, then rendered by rehype-katex. The annotation survives so custom\r\n * engines can re-render from the source.\r\n */\r\nexport function mathPlugin(options: MathPluginOptions = {}): MarkdownPlugin {\r\n  return {\r\n    name: 'math',\r\n    remarkPlugins: [\r\n      [\r\n        remarkMath,\r\n        { singleDollarTextMath: options.singleDollarTextMath ?? true },\r\n      ],\r\n    ],\r\n    rehypePlugins: [rehypeMathAnnotation, [rehypeKatex, options.katex ?? {}]],\r\n    transformSource: (source) => replaceDelimiters(source, options),\r\n  }\r\n}\r\n\r\nexport { rehypeMathAnnotation }\r\n","import katex from 'katex'\r\nimport { htmlToMarkdownNodes } from '../core/hast-nodes'\r\nimport type { MathEngine, MathRenderOptions, MathRenderResult } from '../core/types'\r\n\r\nconst cache = new Map<string, MathRenderResult>()\r\nconst MAX_CACHE = 256\r\n\r\nfunction renderOptions(options: MathRenderOptions): Record<string, unknown> {\r\n  return {\r\n    displayMode: Boolean(options.displayMode),\r\n    throwOnError: false,\r\n    trust: false,\r\n    strict: 'warn',\r\n    output: 'htmlAndMathml',\r\n    ...options,\r\n  }\r\n}\r\n\r\n/** Default KaTeX engine. Invalid TeX becomes readable error markup. */\r\nexport const katexEngine: MathEngine = {\r\n  id: 'katex',\r\n  render(tex, options) {\r\n    const key = `${tex}\\u001e${JSON.stringify(options)}`\r\n    const cached = cache.get(key)\r\n    if (cached) return cached\r\n\r\n    const katexOptions = renderOptions(options)\r\n    try {\r\n      const html = katex.renderToString(tex, katexOptions)\r\n      const result: MathRenderResult = {\r\n        nodes: htmlToMarkdownNodes(html),\r\n      }\r\n      if (html.includes('katex-error')) {\r\n        result.error = 'Invalid TeX expression.'\r\n      }\r\n      cache.set(key, result)\r\n      if (cache.size > MAX_CACHE) {\r\n        const oldest = cache.keys().next().value\r\n        if (oldest !== undefined) cache.delete(oldest)\r\n      }\r\n      return result\r\n    } catch (error) {\r\n      const result: MathRenderResult = {\r\n        nodes: [{ kind: 'text', key: 'math-error', value: tex }],\r\n        error: error instanceof Error ? error.message : String(error),\r\n      }\r\n      cache.set(key, result)\r\n      return result\r\n    }\r\n  },\r\n}\r\n\r\nexport default katexEngine\r\n"],"ignoreList":[0,1,2,3,4,5,6,7,8,9,10],"mappings":"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"}