{"version":3,"file":"externals/marked/16.2.1/index.min.js","mappings":"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","sources":["webpack:///@babel/runtime/7.25.7/helpers/classCallCheck.js","webpack:///@babel/runtime/7.25.7/helpers/createClass.js","webpack:///@babel/runtime/7.25.7/helpers/defineProperty.js","webpack:///@babel/runtime/7.25.7/helpers/extends.js","webpack:///@babel/runtime/7.25.7/helpers/toPrimitive.js","webpack:///@babel/runtime/7.25.7/helpers/toPropertyKey.js","webpack:///@babel/runtime/7.25.7/helpers/typeof.js","webpack:///webpack/bootstrap","webpack:///webpack/runtime/define property getters","webpack:///webpack/runtime/hasOwnProperty shorthand","webpack:///@servicenow/sn-ai-engagement-experience/target/src/defaults.ts","webpack:///@servicenow/sn-ai-engagement-experience/target/src/rules.ts","webpack:///@servicenow/sn-ai-engagement-experience/target/src/helpers.ts","webpack:///@servicenow/sn-ai-engagement-experience/target/src/Tokenizer.ts","webpack:///@servicenow/sn-ai-engagement-experience/target/src/Lexer.ts","webpack:///@servicenow/sn-ai-engagement-experience/target/src/Renderer.ts","webpack:///@servicenow/sn-ai-engagement-experience/target/src/TextRenderer.ts","webpack:///@servicenow/sn-ai-engagement-experience/target/src/Parser.ts","webpack:///@servicenow/sn-ai-engagement-experience/target/src/Hooks.ts","webpack:///@servicenow/sn-ai-engagement-experience/target/src/Instance.ts","webpack:///@servicenow/sn-ai-engagement-experience/target/src/marked.ts"],"sourcesContent":["function _classCallCheck(a, n) {\n  if (!(a instanceof n)) throw new TypeError(\"Cannot call a class as a function\");\n}\nmodule.exports = _classCallCheck, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var toPropertyKey = require(\"./toPropertyKey.js\");\nfunction _defineProperties(e, r) {\n  for (var t = 0; t < r.length; t++) {\n    var o = r[t];\n    o.enumerable = o.enumerable || !1, o.configurable = !0, \"value\" in o && (o.writable = !0), Object.defineProperty(e, toPropertyKey(o.key), o);\n  }\n}\nfunction _createClass(e, r, t) {\n  return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, \"prototype\", {\n    writable: !1\n  }), e;\n}\nmodule.exports = _createClass, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var toPropertyKey = require(\"./toPropertyKey.js\");\nfunction _defineProperty(e, r, t) {\n  return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {\n    value: t,\n    enumerable: !0,\n    configurable: !0,\n    writable: !0\n  }) : e[r] = t, e;\n}\nmodule.exports = _defineProperty, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _extends() {\n  return module.exports = _extends = Object.assign ? Object.assign.bind() : function (n) {\n    for (var e = 1; e < arguments.length; e++) {\n      var t = arguments[e];\n      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);\n    }\n    return n;\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports, _extends.apply(null, arguments);\n}\nmodule.exports = _extends, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var _typeof = require(\"./typeof.js\")[\"default\"];\nfunction toPrimitive(t, r) {\n  if (\"object\" != _typeof(t) || !t) return t;\n  var e = t[Symbol.toPrimitive];\n  if (void 0 !== e) {\n    var i = e.call(t, r || \"default\");\n    if (\"object\" != _typeof(i)) return i;\n    throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n  }\n  return (\"string\" === r ? String : Number)(t);\n}\nmodule.exports = toPrimitive, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var _typeof = require(\"./typeof.js\")[\"default\"];\nvar toPrimitive = require(\"./toPrimitive.js\");\nfunction toPropertyKey(t) {\n  var i = toPrimitive(t, \"string\");\n  return \"symbol\" == _typeof(i) ? i : i + \"\";\n}\nmodule.exports = toPropertyKey, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _typeof(o) {\n  \"@babel/helpers - typeof\";\n\n  return module.exports = _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) {\n    return typeof o;\n  } : function (o) {\n    return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o;\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports, _typeof(o);\n}\nmodule.exports = _typeof, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","import type { MarkedOptions } from './MarkedOptions.ts';\n\n/**\n * Gets the original marked default options.\n */\nexport function _getDefaults<ParserOutput = string, RendererOutput = string>(): MarkedOptions<ParserOutput, RendererOutput> {\n  return {\n    async: false,\n    breaks: false,\n    extensions: null,\n    gfm: true,\n    hooks: null,\n    pedantic: false,\n    renderer: null,\n    silent: false,\n    tokenizer: null,\n    walkTokens: null,\n  };\n}\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport let _defaults: MarkedOptions<any, any> = _getDefaults();\n\nexport function changeDefaults<ParserOutput = string, RendererOutput = string>(newDefaults: MarkedOptions<ParserOutput, RendererOutput>) {\n  _defaults = newDefaults;\n}\n","const noopTest = { exec: () => null } as unknown as RegExp;\n\nfunction edit(regex: string | RegExp, opt = '') {\n  let source = typeof regex === 'string' ? regex : regex.source;\n  const obj = {\n    replace: (name: string | RegExp, val: string | RegExp) => {\n      let valSource = typeof val === 'string' ? val : val.source;\n      valSource = valSource.replace(other.caret, '$1');\n      source = source.replace(name, valSource);\n      return obj;\n    },\n    getRegex: () => {\n      return new RegExp(source, opt);\n    },\n  };\n  return obj;\n}\n\nexport const other = {\n  codeRemoveIndent: /^(?: {1,4}| {0,3}\\t)/gm,\n  outputLinkReplace: /\\\\([\\[\\]])/g,\n  indentCodeCompensation: /^(\\s+)(?:```)/,\n  beginningSpace: /^\\s+/,\n  endingHash: /#$/,\n  startingSpaceChar: /^ /,\n  endingSpaceChar: / $/,\n  nonSpaceChar: /[^ ]/,\n  newLineCharGlobal: /\\n/g,\n  tabCharGlobal: /\\t/g,\n  multipleSpaceGlobal: /\\s+/g,\n  blankLine: /^[ \\t]*$/,\n  doubleBlankLine: /\\n[ \\t]*\\n[ \\t]*$/,\n  blockquoteStart: /^ {0,3}>/,\n  blockquoteSetextReplace: /\\n {0,3}((?:=+|-+) *)(?=\\n|$)/g,\n  blockquoteSetextReplace2: /^ {0,3}>[ \\t]?/gm,\n  listReplaceTabs: /^\\t+/,\n  listReplaceNesting: /^ {1,4}(?=( {4})*[^ ])/g,\n  listIsTask: /^\\[[ xX]\\] /,\n  listReplaceTask: /^\\[[ xX]\\] +/,\n  anyLine: /\\n.*\\n/,\n  hrefBrackets: /^<(.*)>$/,\n  tableDelimiter: /[:|]/,\n  tableAlignChars: /^\\||\\| *$/g,\n  tableRowBlankLine: /\\n[ \\t]*$/,\n  tableAlignRight: /^ *-+: *$/,\n  tableAlignCenter: /^ *:-+: *$/,\n  tableAlignLeft: /^ *:-+ *$/,\n  startATag: /^<a /i,\n  endATag: /^<\\/a>/i,\n  startPreScriptTag: /^<(pre|code|kbd|script)(\\s|>)/i,\n  endPreScriptTag: /^<\\/(pre|code|kbd|script)(\\s|>)/i,\n  startAngleBracket: /^</,\n  endAngleBracket: />$/,\n  pedanticHrefTitle: /^([^'\"]*[^\\s])\\s+(['\"])(.*)\\2/,\n  unicodeAlphaNumeric: /[\\p{L}\\p{N}]/u,\n  escapeTest: /[&<>\"']/,\n  escapeReplace: /[&<>\"']/g,\n  escapeTestNoEncode: /[<>\"']|&(?!(#\\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\\w+);)/,\n  escapeReplaceNoEncode: /[<>\"']|&(?!(#\\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\\w+);)/g,\n  unescapeTest: /&(#(?:\\d+)|(?:#x[0-9A-Fa-f]+)|(?:\\w+));?/ig,\n  caret: /(^|[^\\[])\\^/g,\n  percentDecode: /%25/g,\n  findPipe: /\\|/g,\n  splitPipe: / \\|/,\n  slashPipe: /\\\\\\|/g,\n  carriageReturn: /\\r\\n|\\r/g,\n  spaceLine: /^ +$/gm,\n  notSpaceStart: /^\\S*/,\n  endingNewline: /\\n$/,\n  listItemRegex: (bull: string) => new RegExp(`^( {0,3}${bull})((?:[\\t ][^\\\\n]*)?(?:\\\\n|$))`),\n  nextBulletRegex: (indent: number) => new RegExp(`^ {0,${Math.min(3, indent - 1)}}(?:[*+-]|\\\\d{1,9}[.)])((?:[ \\t][^\\\\n]*)?(?:\\\\n|$))`),\n  hrRegex: (indent: number) => new RegExp(`^ {0,${Math.min(3, indent - 1)}}((?:- *){3,}|(?:_ *){3,}|(?:\\\\* *){3,})(?:\\\\n+|$)`),\n  fencesBeginRegex: (indent: number) => new RegExp(`^ {0,${Math.min(3, indent - 1)}}(?:\\`\\`\\`|~~~)`),\n  headingBeginRegex: (indent: number) => new RegExp(`^ {0,${Math.min(3, indent - 1)}}#`),\n  htmlBeginRegex: (indent: number) => new RegExp(`^ {0,${Math.min(3, indent - 1)}}<(?:[a-z].*>|!--)`, 'i'),\n};\n\n/**\n * Block-Level Grammar\n */\n\nconst newline = /^(?:[ \\t]*(?:\\n|$))+/;\nconst blockCode = /^((?: {4}| {0,3}\\t)[^\\n]+(?:\\n(?:[ \\t]*(?:\\n|$))*)?)+/;\nconst fences = /^ {0,3}(`{3,}(?=[^`\\n]*(?:\\n|$))|~{3,})([^\\n]*)(?:\\n|$)(?:|([\\s\\S]*?)(?:\\n|$))(?: {0,3}\\1[~`]* *(?=\\n|$)|$)/;\nconst hr = /^ {0,3}((?:-[\\t ]*){3,}|(?:_[ \\t]*){3,}|(?:\\*[ \\t]*){3,})(?:\\n+|$)/;\nconst heading = /^ {0,3}(#{1,6})(?=\\s|$)(.*)(?:\\n+|$)/;\nconst bullet = /(?:[*+-]|\\d{1,9}[.)])/;\nconst lheadingCore = /^(?!bull |blockCode|fences|blockquote|heading|html|table)((?:.|\\n(?!\\s*?\\n|bull |blockCode|fences|blockquote|heading|html|table))+?)\\n {0,3}(=+|-+) *(?:\\n+|$)/;\nconst lheading = edit(lheadingCore)\n  .replace(/bull/g, bullet) // lists can interrupt\n  .replace(/blockCode/g, /(?: {4}| {0,3}\\t)/) // indented code blocks can interrupt\n  .replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/) // fenced code blocks can interrupt\n  .replace(/blockquote/g, / {0,3}>/) // blockquote can interrupt\n  .replace(/heading/g, / {0,3}#{1,6}/) // ATX heading can interrupt\n  .replace(/html/g, / {0,3}<[^\\n>]+>\\n/) // block html can interrupt\n  .replace(/\\|table/g, '') // table not in commonmark\n  .getRegex();\nconst lheadingGfm = edit(lheadingCore)\n  .replace(/bull/g, bullet) // lists can interrupt\n  .replace(/blockCode/g, /(?: {4}| {0,3}\\t)/) // indented code blocks can interrupt\n  .replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/) // fenced code blocks can interrupt\n  .replace(/blockquote/g, / {0,3}>/) // blockquote can interrupt\n  .replace(/heading/g, / {0,3}#{1,6}/) // ATX heading can interrupt\n  .replace(/html/g, / {0,3}<[^\\n>]+>\\n/) // block html can interrupt\n  .replace(/table/g, / {0,3}\\|?(?:[:\\- ]*\\|)+[\\:\\- ]*\\n/) // table can interrupt\n  .getRegex();\nconst _paragraph = /^([^\\n]+(?:\\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\\n)[^\\n]+)*)/;\nconst blockText = /^[^\\n]+/;\nconst _blockLabel = /(?!\\s*\\])(?:\\\\[\\s\\S]|[^\\[\\]\\\\])+/;\nconst def = edit(/^ {0,3}\\[(label)\\]: *(?:\\n[ \\t]*)?([^<\\s][^\\s]*|<.*?>)(?:(?: +(?:\\n[ \\t]*)?| *\\n[ \\t]*)(title))? *(?:\\n+|$)/)\n  .replace('label', _blockLabel)\n  .replace('title', /(?:\"(?:\\\\\"?|[^\"\\\\])*\"|'[^'\\n]*(?:\\n[^'\\n]+)*\\n?'|\\([^()]*\\))/)\n  .getRegex();\n\nconst list = edit(/^( {0,3}bull)([ \\t][^\\n]+?)?(?:\\n|$)/)\n  .replace(/bull/g, bullet)\n  .getRegex();\n\nconst _tag = 'address|article|aside|base|basefont|blockquote|body|caption'\n  + '|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption'\n  + '|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe'\n  + '|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option'\n  + '|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|title'\n  + '|tr|track|ul';\nconst _comment = /<!--(?:-?>|[\\s\\S]*?(?:-->|$))/;\nconst html = edit(\n  '^ {0,3}(?:' // optional indentation\n+ '<(script|pre|style|textarea)[\\\\s>][\\\\s\\\\S]*?(?:</\\\\1>[^\\\\n]*\\\\n+|$)' // (1)\n+ '|comment[^\\\\n]*(\\\\n+|$)' // (2)\n+ '|<\\\\?[\\\\s\\\\S]*?(?:\\\\?>\\\\n*|$)' // (3)\n+ '|<![A-Z][\\\\s\\\\S]*?(?:>\\\\n*|$)' // (4)\n+ '|<!\\\\[CDATA\\\\[[\\\\s\\\\S]*?(?:\\\\]\\\\]>\\\\n*|$)' // (5)\n+ '|</?(tag)(?: +|\\\\n|/?>)[\\\\s\\\\S]*?(?:(?:\\\\n[ \\t]*)+\\\\n|$)' // (6)\n+ '|<(?!script|pre|style|textarea)([a-z][\\\\w-]*)(?:attribute)*? */?>(?=[ \\\\t]*(?:\\\\n|$))[\\\\s\\\\S]*?(?:(?:\\\\n[ \\t]*)+\\\\n|$)' // (7) open tag\n+ '|</(?!script|pre|style|textarea)[a-z][\\\\w-]*\\\\s*>(?=[ \\\\t]*(?:\\\\n|$))[\\\\s\\\\S]*?(?:(?:\\\\n[ \\t]*)+\\\\n|$)' // (7) closing tag\n+ ')', 'i')\n  .replace('comment', _comment)\n  .replace('tag', _tag)\n  .replace('attribute', / +[a-zA-Z:_][\\w.:-]*(?: *= *\"[^\"\\n]*\"| *= *'[^'\\n]*'| *= *[^\\s\"'=<>`]+)?/)\n  .getRegex();\n\nconst paragraph = edit(_paragraph)\n  .replace('hr', hr)\n  .replace('heading', ' {0,3}#{1,6}(?:\\\\s|$)')\n  .replace('|lheading', '') // setext headings don't interrupt commonmark paragraphs\n  .replace('|table', '')\n  .replace('blockquote', ' {0,3}>')\n  .replace('fences', ' {0,3}(?:`{3,}(?=[^`\\\\n]*\\\\n)|~{3,})[^\\\\n]*\\\\n')\n  .replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt\n  .replace('html', '</?(?:tag)(?: +|\\\\n|/?>)|<(?:script|pre|style|textarea|!--)')\n  .replace('tag', _tag) // pars can be interrupted by type (6) html blocks\n  .getRegex();\n\nconst blockquote = edit(/^( {0,3}> ?(paragraph|[^\\n]*)(?:\\n|$))+/)\n  .replace('paragraph', paragraph)\n  .getRegex();\n\n/**\n * Normal Block Grammar\n */\n\nconst blockNormal = {\n  blockquote,\n  code: blockCode,\n  def,\n  fences,\n  heading,\n  hr,\n  html,\n  lheading,\n  list,\n  newline,\n  paragraph,\n  table: noopTest,\n  text: blockText,\n};\n\ntype BlockKeys = keyof typeof blockNormal;\n\n/**\n * GFM Block Grammar\n */\n\nconst gfmTable = edit(\n  '^ *([^\\\\n ].*)\\\\n' // Header\n+ ' {0,3}((?:\\\\| *)?:?-+:? *(?:\\\\| *:?-+:? *)*(?:\\\\| *)?)' // Align\n+ '(?:\\\\n((?:(?! *\\\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\\\n|$))*)\\\\n*|$)') // Cells\n  .replace('hr', hr)\n  .replace('heading', ' {0,3}#{1,6}(?:\\\\s|$)')\n  .replace('blockquote', ' {0,3}>')\n  .replace('code', '(?: {4}| {0,3}\\t)[^\\\\n]')\n  .replace('fences', ' {0,3}(?:`{3,}(?=[^`\\\\n]*\\\\n)|~{3,})[^\\\\n]*\\\\n')\n  .replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt\n  .replace('html', '</?(?:tag)(?: +|\\\\n|/?>)|<(?:script|pre|style|textarea|!--)')\n  .replace('tag', _tag) // tables can be interrupted by type (6) html blocks\n  .getRegex();\n\nconst blockGfm: Record<BlockKeys, RegExp> = {\n  ...blockNormal,\n  lheading: lheadingGfm,\n  table: gfmTable,\n  paragraph: edit(_paragraph)\n    .replace('hr', hr)\n    .replace('heading', ' {0,3}#{1,6}(?:\\\\s|$)')\n    .replace('|lheading', '') // setext headings don't interrupt commonmark paragraphs\n    .replace('table', gfmTable) // interrupt paragraphs with table\n    .replace('blockquote', ' {0,3}>')\n    .replace('fences', ' {0,3}(?:`{3,}(?=[^`\\\\n]*\\\\n)|~{3,})[^\\\\n]*\\\\n')\n    .replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt\n    .replace('html', '</?(?:tag)(?: +|\\\\n|/?>)|<(?:script|pre|style|textarea|!--)')\n    .replace('tag', _tag) // pars can be interrupted by type (6) html blocks\n    .getRegex(),\n};\n\n/**\n * Pedantic grammar (original John Gruber's loose markdown specification)\n */\n\nconst blockPedantic: Record<BlockKeys, RegExp> = {\n  ...blockNormal,\n  html: edit(\n    '^ *(?:comment *(?:\\\\n|\\\\s*$)'\n    + '|<(tag)[\\\\s\\\\S]+?</\\\\1> *(?:\\\\n{2,}|\\\\s*$)' // closed tag\n    + '|<tag(?:\"[^\"]*\"|\\'[^\\']*\\'|\\\\s[^\\'\"/>\\\\s]*)*?/?> *(?:\\\\n{2,}|\\\\s*$))')\n    .replace('comment', _comment)\n    .replace(/tag/g, '(?!(?:'\n      + 'a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub'\n      + '|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)'\n      + '\\\\b)\\\\w+(?!:|[^\\\\w\\\\s@]*@)\\\\b')\n    .getRegex(),\n  def: /^ *\\[([^\\]]+)\\]: *<?([^\\s>]+)>?(?: +([\"(][^\\n]+[\")]))? *(?:\\n+|$)/,\n  heading: /^(#{1,6})(.*)(?:\\n+|$)/,\n  fences: noopTest, // fences not supported\n  lheading: /^(.+?)\\n {0,3}(=+|-+) *(?:\\n+|$)/,\n  paragraph: edit(_paragraph)\n    .replace('hr', hr)\n    .replace('heading', ' *#{1,6} *[^\\n]')\n    .replace('lheading', lheading)\n    .replace('|table', '')\n    .replace('blockquote', ' {0,3}>')\n    .replace('|fences', '')\n    .replace('|list', '')\n    .replace('|html', '')\n    .replace('|tag', '')\n    .getRegex(),\n};\n\n/**\n * Inline-Level Grammar\n */\n\nconst escape = /^\\\\([!\"#$%&'()*+,\\-./:;<=>?@\\[\\]\\\\^_`{|}~])/;\nconst inlineCode = /^(`+)([^`]|[^`][\\s\\S]*?[^`])\\1(?!`)/;\nconst br = /^( {2,}|\\\\)\\n(?!\\s*$)/;\nconst inlineText = /^(`+|[^`])(?:(?= {2,}\\n)|[\\s\\S]*?(?:(?=[\\\\<!\\[`*_]|\\b_|$)|[^ ](?= {2,}\\n)))/;\n\n// list of unicode punctuation marks, plus any missing characters from CommonMark spec\nconst _punctuation = /[\\p{P}\\p{S}]/u;\nconst _punctuationOrSpace = /[\\s\\p{P}\\p{S}]/u;\nconst _notPunctuationOrSpace = /[^\\s\\p{P}\\p{S}]/u;\nconst punctuation = edit(/^((?![*_])punctSpace)/, 'u')\n  .replace(/punctSpace/g, _punctuationOrSpace).getRegex();\n\n// GFM allows ~ inside strong and em for strikethrough\nconst _punctuationGfmStrongEm = /(?!~)[\\p{P}\\p{S}]/u;\nconst _punctuationOrSpaceGfmStrongEm = /(?!~)[\\s\\p{P}\\p{S}]/u;\nconst _notPunctuationOrSpaceGfmStrongEm = /(?:[^\\s\\p{P}\\p{S}]|~)/u;\n\n// sequences em should skip over [title](link), `code`, <html>\nconst blockSkip = /\\[[^\\[\\]]*?\\]\\((?:\\\\[\\s\\S]|[^\\\\\\(\\)]|\\((?:\\\\[\\s\\S]|[^\\\\\\(\\)])*\\))*\\)|`[^`]*?`|<(?! )[^<>]*?>/g;\n\nconst emStrongLDelimCore = /^(?:\\*+(?:((?!\\*)punct)|[^\\s*]))|^_+(?:((?!_)punct)|([^\\s_]))/;\n\nconst emStrongLDelim = edit(emStrongLDelimCore, 'u')\n  .replace(/punct/g, _punctuation)\n  .getRegex();\n\nconst emStrongLDelimGfm = edit(emStrongLDelimCore, 'u')\n  .replace(/punct/g, _punctuationGfmStrongEm)\n  .getRegex();\n\nconst emStrongRDelimAstCore =\n  '^[^_*]*?__[^_*]*?\\\\*[^_*]*?(?=__)' // Skip orphan inside strong\n+ '|[^*]+(?=[^*])' // Consume to delim\n+ '|(?!\\\\*)punct(\\\\*+)(?=[\\\\s]|$)' // (1) #*** can only be a Right Delimiter\n+ '|notPunctSpace(\\\\*+)(?!\\\\*)(?=punctSpace|$)' // (2) a***#, a*** can only be a Right Delimiter\n+ '|(?!\\\\*)punctSpace(\\\\*+)(?=notPunctSpace)' // (3) #***a, ***a can only be Left Delimiter\n+ '|[\\\\s](\\\\*+)(?!\\\\*)(?=punct)' // (4) ***# can only be Left Delimiter\n+ '|(?!\\\\*)punct(\\\\*+)(?!\\\\*)(?=punct)' // (5) #***# can be either Left or Right Delimiter\n+ '|notPunctSpace(\\\\*+)(?=notPunctSpace)'; // (6) a***a can be either Left or Right Delimiter\n\nconst emStrongRDelimAst = edit(emStrongRDelimAstCore, 'gu')\n  .replace(/notPunctSpace/g, _notPunctuationOrSpace)\n  .replace(/punctSpace/g, _punctuationOrSpace)\n  .replace(/punct/g, _punctuation)\n  .getRegex();\n\nconst emStrongRDelimAstGfm = edit(emStrongRDelimAstCore, 'gu')\n  .replace(/notPunctSpace/g, _notPunctuationOrSpaceGfmStrongEm)\n  .replace(/punctSpace/g, _punctuationOrSpaceGfmStrongEm)\n  .replace(/punct/g, _punctuationGfmStrongEm)\n  .getRegex();\n\n// (6) Not allowed for _\nconst emStrongRDelimUnd = edit(\n  '^[^_*]*?\\\\*\\\\*[^_*]*?_[^_*]*?(?=\\\\*\\\\*)' // Skip orphan inside strong\n+ '|[^_]+(?=[^_])' // Consume to delim\n+ '|(?!_)punct(_+)(?=[\\\\s]|$)' // (1) #___ can only be a Right Delimiter\n+ '|notPunctSpace(_+)(?!_)(?=punctSpace|$)' // (2) a___#, a___ can only be a Right Delimiter\n+ '|(?!_)punctSpace(_+)(?=notPunctSpace)' // (3) #___a, ___a can only be Left Delimiter\n+ '|[\\\\s](_+)(?!_)(?=punct)' // (4) ___# can only be Left Delimiter\n+ '|(?!_)punct(_+)(?!_)(?=punct)', 'gu') // (5) #___# can be either Left or Right Delimiter\n  .replace(/notPunctSpace/g, _notPunctuationOrSpace)\n  .replace(/punctSpace/g, _punctuationOrSpace)\n  .replace(/punct/g, _punctuation)\n  .getRegex();\n\nconst anyPunctuation = edit(/\\\\(punct)/, 'gu')\n  .replace(/punct/g, _punctuation)\n  .getRegex();\n\nconst autolink = edit(/^<(scheme:[^\\s\\x00-\\x1f<>]*|email)>/)\n  .replace('scheme', /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/)\n  .replace('email', /[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  .getRegex();\n\nconst _inlineComment = edit(_comment).replace('(?:-->|$)', '-->').getRegex();\nconst tag = edit(\n  '^comment'\n    + '|^</[a-zA-Z][\\\\w:-]*\\\\s*>' // self-closing tag\n    + '|^<[a-zA-Z][\\\\w-]*(?:attribute)*?\\\\s*/?>' // open tag\n    + '|^<\\\\?[\\\\s\\\\S]*?\\\\?>' // processing instruction, e.g. <?php ?>\n    + '|^<![a-zA-Z]+\\\\s[\\\\s\\\\S]*?>' // declaration, e.g. <!DOCTYPE html>\n    + '|^<!\\\\[CDATA\\\\[[\\\\s\\\\S]*?\\\\]\\\\]>') // CDATA section\n  .replace('comment', _inlineComment)\n  .replace('attribute', /\\s+[a-zA-Z:_][\\w.:-]*(?:\\s*=\\s*\"[^\"]*\"|\\s*=\\s*'[^']*'|\\s*=\\s*[^\\s\"'=<>`]+)?/)\n  .getRegex();\n\nconst _inlineLabel = /(?:\\[(?:\\\\[\\s\\S]|[^\\[\\]\\\\])*\\]|\\\\[\\s\\S]|`[^`]*`|[^\\[\\]\\\\`])*?/;\n\nconst link = edit(/^!?\\[(label)\\]\\(\\s*(href)(?:(?:[ \\t]*(?:\\n[ \\t]*)?)(title))?\\s*\\)/)\n  .replace('label', _inlineLabel)\n  .replace('href', /<(?:\\\\.|[^\\n<>\\\\])+>|[^ \\t\\n\\x00-\\x1f]*/)\n  .replace('title', /\"(?:\\\\\"?|[^\"\\\\])*\"|'(?:\\\\'?|[^'\\\\])*'|\\((?:\\\\\\)?|[^)\\\\])*\\)/)\n  .getRegex();\n\nconst reflink = edit(/^!?\\[(label)\\]\\[(ref)\\]/)\n  .replace('label', _inlineLabel)\n  .replace('ref', _blockLabel)\n  .getRegex();\n\nconst nolink = edit(/^!?\\[(ref)\\](?:\\[\\])?/)\n  .replace('ref', _blockLabel)\n  .getRegex();\n\nconst reflinkSearch = edit('reflink|nolink(?!\\\\()', 'g')\n  .replace('reflink', reflink)\n  .replace('nolink', nolink)\n  .getRegex();\n\n/**\n * Normal Inline Grammar\n */\n\nconst inlineNormal = {\n  _backpedal: noopTest, // only used for GFM url\n  anyPunctuation,\n  autolink,\n  blockSkip,\n  br,\n  code: inlineCode,\n  del: noopTest,\n  emStrongLDelim,\n  emStrongRDelimAst,\n  emStrongRDelimUnd,\n  escape,\n  link,\n  nolink,\n  punctuation,\n  reflink,\n  reflinkSearch,\n  tag,\n  text: inlineText,\n  url: noopTest,\n};\n\ntype InlineKeys = keyof typeof inlineNormal;\n\n/**\n * Pedantic Inline Grammar\n */\n\nconst inlinePedantic: Record<InlineKeys, RegExp> = {\n  ...inlineNormal,\n  link: edit(/^!?\\[(label)\\]\\((.*?)\\)/)\n    .replace('label', _inlineLabel)\n    .getRegex(),\n  reflink: edit(/^!?\\[(label)\\]\\s*\\[([^\\]]*)\\]/)\n    .replace('label', _inlineLabel)\n    .getRegex(),\n};\n\n/**\n * GFM Inline Grammar\n */\n\nconst inlineGfm: Record<InlineKeys, RegExp> = {\n  ...inlineNormal,\n  emStrongRDelimAst: emStrongRDelimAstGfm,\n  emStrongLDelim: emStrongLDelimGfm,\n  url: edit(/^((?:ftp|https?):\\/\\/|www\\.)(?:[a-zA-Z0-9\\-]+\\.?)+[^\\s<]*|^email/, 'i')\n    .replace('email', /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/)\n    .getRegex(),\n  _backpedal: /(?:[^?!.,:;*_'\"~()&]+|\\([^)]*\\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_'\"~)]+(?!$))+/,\n  del: /^(~~?)(?=[^\\s~])((?:\\\\[\\s\\S]|[^\\\\])*?(?:\\\\[\\s\\S]|[^\\s~\\\\]))\\1(?=[^~]|$)/,\n  text: /^([`~]+|[^`~])(?:(?= {2,}\\n)|(?=[a-zA-Z0-9.!#$%&'*+\\/=?_`{\\|}~-]+@)|[\\s\\S]*?(?:(?=[\\\\<!\\[`*~_]|\\b_|https?:\\/\\/|ftp:\\/\\/|www\\.|$)|[^ ](?= {2,}\\n)|[^a-zA-Z0-9.!#$%&'*+\\/=?_`{\\|}~-](?=[a-zA-Z0-9.!#$%&'*+\\/=?_`{\\|}~-]+@)))/,\n};\n\n/**\n * GFM + Line Breaks Inline Grammar\n */\n\nconst inlineBreaks: Record<InlineKeys, RegExp> = {\n  ...inlineGfm,\n  br: edit(br).replace('{2,}', '*').getRegex(),\n  text: edit(inlineGfm.text)\n    .replace('\\\\b_', '\\\\b_| {2,}\\\\n')\n    .replace(/\\{2,\\}/g, '*')\n    .getRegex(),\n};\n\n/**\n * exports\n */\n\nexport const block = {\n  normal: blockNormal,\n  gfm: blockGfm,\n  pedantic: blockPedantic,\n};\n\nexport const inline = {\n  normal: inlineNormal,\n  gfm: inlineGfm,\n  breaks: inlineBreaks,\n  pedantic: inlinePedantic,\n};\n\nexport interface Rules {\n  other: typeof other\n  block: Record<BlockKeys, RegExp>\n  inline: Record<InlineKeys, RegExp>\n}\n","import { other } from './rules.ts';\n\n/**\n * Helpers\n */\nconst escapeReplacements: { [index: string]: string } = {\n  '&': '&amp;',\n  '<': '&lt;',\n  '>': '&gt;',\n  '\"': '&quot;',\n  \"'\": '&#39;',\n};\nconst getEscapeReplacement = (ch: string) => escapeReplacements[ch];\n\nexport function escape(html: string, encode?: boolean) {\n  if (encode) {\n    if (other.escapeTest.test(html)) {\n      return html.replace(other.escapeReplace, getEscapeReplacement);\n    }\n  } else {\n    if (other.escapeTestNoEncode.test(html)) {\n      return html.replace(other.escapeReplaceNoEncode, getEscapeReplacement);\n    }\n  }\n\n  return html;\n}\n\nexport function unescape(html: string) {\n  // explicitly match decimal, hex, and named HTML entities\n  return html.replace(other.unescapeTest, (_, n) => {\n    n = n.toLowerCase();\n    if (n === 'colon') return ':';\n    if (n.charAt(0) === '#') {\n      return n.charAt(1) === 'x'\n        ? String.fromCharCode(parseInt(n.substring(2), 16))\n        : String.fromCharCode(+n.substring(1));\n    }\n    return '';\n  });\n}\n\nexport function cleanUrl(href: string) {\n  try {\n    href = encodeURI(href).replace(other.percentDecode, '%');\n  } catch {\n    return null;\n  }\n  return href;\n}\n\nexport function splitCells(tableRow: string, count?: number) {\n  // ensure that every cell-delimiting pipe has a space\n  // before it to distinguish it from an escaped pipe\n  const row = tableRow.replace(other.findPipe, (match, offset, str) => {\n      let escaped = false;\n      let curr = offset;\n      while (--curr >= 0 && str[curr] === '\\\\') escaped = !escaped;\n      if (escaped) {\n        // odd number of slashes means | is escaped\n        // so we leave it alone\n        return '|';\n      } else {\n        // add space before unescaped |\n        return ' |';\n      }\n    }),\n    cells = row.split(other.splitPipe);\n  let i = 0;\n\n  // First/last cell in a row cannot be empty if it has no leading/trailing pipe\n  if (!cells[0].trim()) {\n    cells.shift();\n  }\n  if (cells.length > 0 && !cells.at(-1)?.trim()) {\n    cells.pop();\n  }\n\n  if (count) {\n    if (cells.length > count) {\n      cells.splice(count);\n    } else {\n      while (cells.length < count) cells.push('');\n    }\n  }\n\n  for (; i < cells.length; i++) {\n    // leading or trailing whitespace is ignored per the gfm spec\n    cells[i] = cells[i].trim().replace(other.slashPipe, '|');\n  }\n  return cells;\n}\n\n/**\n * Remove trailing 'c's. Equivalent to str.replace(/c*$/, '').\n * /c*$/ is vulnerable to REDOS.\n *\n * @param str\n * @param c\n * @param invert Remove suffix of non-c chars instead. Default falsey.\n */\nexport function rtrim(str: string, c: string, invert?: boolean) {\n  const l = str.length;\n  if (l === 0) {\n    return '';\n  }\n\n  // Length of suffix matching the invert condition.\n  let suffLen = 0;\n\n  // Step left until we fail to match the invert condition.\n  while (suffLen < l) {\n    const currChar = str.charAt(l - suffLen - 1);\n    if (currChar === c && !invert) {\n      suffLen++;\n    } else if (currChar !== c && invert) {\n      suffLen++;\n    } else {\n      break;\n    }\n  }\n\n  return str.slice(0, l - suffLen);\n}\n\nexport function findClosingBracket(str: string, b: string) {\n  if (str.indexOf(b[1]) === -1) {\n    return -1;\n  }\n\n  let level = 0;\n  for (let i = 0; i < str.length; i++) {\n    if (str[i] === '\\\\') {\n      i++;\n    } else if (str[i] === b[0]) {\n      level++;\n    } else if (str[i] === b[1]) {\n      level--;\n      if (level < 0) {\n        return i;\n      }\n    }\n  }\n  if (level > 0) {\n    return -2;\n  }\n\n  return -1;\n}\n","import { _defaults } from './defaults.ts';\nimport {\n  rtrim,\n  splitCells,\n  findClosingBracket,\n} from './helpers.ts';\nimport type { Rules } from './rules.ts';\nimport type { _Lexer } from './Lexer.ts';\nimport type { Links, Tokens, Token } from './Tokens.ts';\nimport type { MarkedOptions } from './MarkedOptions.ts';\n\nfunction outputLink(cap: string[], link: Pick<Tokens.Link, 'href' | 'title'>, raw: string, lexer: _Lexer, rules: Rules): Tokens.Link | Tokens.Image {\n  const href = link.href;\n  const title = link.title || null;\n  const text = cap[1].replace(rules.other.outputLinkReplace, '$1');\n\n  lexer.state.inLink = true;\n  const token: Tokens.Link | Tokens.Image = {\n    type: cap[0].charAt(0) === '!' ? 'image' : 'link',\n    raw,\n    href,\n    title,\n    text,\n    tokens: lexer.inlineTokens(text),\n  };\n  lexer.state.inLink = false;\n  return token;\n}\n\nfunction indentCodeCompensation(raw: string, text: string, rules: Rules) {\n  const matchIndentToCode = raw.match(rules.other.indentCodeCompensation);\n\n  if (matchIndentToCode === null) {\n    return text;\n  }\n\n  const indentToCode = matchIndentToCode[1];\n\n  return text\n    .split('\\n')\n    .map(node => {\n      const matchIndentInNode = node.match(rules.other.beginningSpace);\n      if (matchIndentInNode === null) {\n        return node;\n      }\n\n      const [indentInNode] = matchIndentInNode;\n\n      if (indentInNode.length >= indentToCode.length) {\n        return node.slice(indentToCode.length);\n      }\n\n      return node;\n    })\n    .join('\\n');\n}\n\n/**\n * Tokenizer\n */\nexport class _Tokenizer<ParserOutput = string, RendererOutput = string> {\n  options: MarkedOptions<ParserOutput, RendererOutput>;\n  rules!: Rules; // set by the lexer\n  lexer!: _Lexer<ParserOutput, RendererOutput>; // set by the lexer\n\n  constructor(options?: MarkedOptions<ParserOutput, RendererOutput>) {\n    this.options = options || _defaults;\n  }\n\n  space(src: string): Tokens.Space | undefined {\n    const cap = this.rules.block.newline.exec(src);\n    if (cap && cap[0].length > 0) {\n      return {\n        type: 'space',\n        raw: cap[0],\n      };\n    }\n  }\n\n  code(src: string): Tokens.Code | undefined {\n    const cap = this.rules.block.code.exec(src);\n    if (cap) {\n      const text = cap[0].replace(this.rules.other.codeRemoveIndent, '');\n      return {\n        type: 'code',\n        raw: cap[0],\n        codeBlockStyle: 'indented',\n        text: !this.options.pedantic\n          ? rtrim(text, '\\n')\n          : text,\n      };\n    }\n  }\n\n  fences(src: string): Tokens.Code | undefined {\n    const cap = this.rules.block.fences.exec(src);\n    if (cap) {\n      const raw = cap[0];\n      const text = indentCodeCompensation(raw, cap[3] || '', this.rules);\n\n      return {\n        type: 'code',\n        raw,\n        lang: cap[2] ? cap[2].trim().replace(this.rules.inline.anyPunctuation, '$1') : cap[2],\n        text,\n      };\n    }\n  }\n\n  heading(src: string): Tokens.Heading | undefined {\n    const cap = this.rules.block.heading.exec(src);\n    if (cap) {\n      let text = cap[2].trim();\n\n      // remove trailing #s\n      if (this.rules.other.endingHash.test(text)) {\n        const trimmed = rtrim(text, '#');\n        if (this.options.pedantic) {\n          text = trimmed.trim();\n        } else if (!trimmed || this.rules.other.endingSpaceChar.test(trimmed)) {\n          // CommonMark requires space before trailing #s\n          text = trimmed.trim();\n        }\n      }\n\n      return {\n        type: 'heading',\n        raw: cap[0],\n        depth: cap[1].length,\n        text,\n        tokens: this.lexer.inline(text),\n      };\n    }\n  }\n\n  hr(src: string): Tokens.Hr | undefined {\n    const cap = this.rules.block.hr.exec(src);\n    if (cap) {\n      return {\n        type: 'hr',\n        raw: rtrim(cap[0], '\\n'),\n      };\n    }\n  }\n\n  blockquote(src: string): Tokens.Blockquote | undefined {\n    const cap = this.rules.block.blockquote.exec(src);\n    if (cap) {\n      let lines = rtrim(cap[0], '\\n').split('\\n');\n      let raw = '';\n      let text = '';\n      const tokens: Token[] = [];\n\n      while (lines.length > 0) {\n        let inBlockquote = false;\n        const currentLines = [];\n\n        let i;\n        for (i = 0; i < lines.length; i++) {\n          // get lines up to a continuation\n          if (this.rules.other.blockquoteStart.test(lines[i])) {\n            currentLines.push(lines[i]);\n            inBlockquote = true;\n          } else if (!inBlockquote) {\n            currentLines.push(lines[i]);\n          } else {\n            break;\n          }\n        }\n        lines = lines.slice(i);\n\n        const currentRaw = currentLines.join('\\n');\n        const currentText = currentRaw\n          // precede setext continuation with 4 spaces so it isn't a setext\n          .replace(this.rules.other.blockquoteSetextReplace, '\\n    $1')\n          .replace(this.rules.other.blockquoteSetextReplace2, '');\n        raw = raw ? `${raw}\\n${currentRaw}` : currentRaw;\n        text = text ? `${text}\\n${currentText}` : currentText;\n\n        // parse blockquote lines as top level tokens\n        // merge paragraphs if this is a continuation\n        const top = this.lexer.state.top;\n        this.lexer.state.top = true;\n        this.lexer.blockTokens(currentText, tokens, true);\n        this.lexer.state.top = top;\n\n        // if there is no continuation then we are done\n        if (lines.length === 0) {\n          break;\n        }\n\n        const lastToken = tokens.at(-1);\n\n        if (lastToken?.type === 'code') {\n          // blockquote continuation cannot be preceded by a code block\n          break;\n        } else if (lastToken?.type === 'blockquote') {\n          // include continuation in nested blockquote\n          const oldToken = lastToken as Tokens.Blockquote;\n          const newText = oldToken.raw + '\\n' + lines.join('\\n');\n          const newToken = this.blockquote(newText)!;\n          tokens[tokens.length - 1] = newToken;\n\n          raw = raw.substring(0, raw.length - oldToken.raw.length) + newToken.raw;\n          text = text.substring(0, text.length - oldToken.text.length) + newToken.text;\n          break;\n        } else if (lastToken?.type === 'list') {\n          // include continuation in nested list\n          const oldToken = lastToken as Tokens.List;\n          const newText = oldToken.raw + '\\n' + lines.join('\\n');\n          const newToken = this.list(newText)!;\n          tokens[tokens.length - 1] = newToken;\n\n          raw = raw.substring(0, raw.length - lastToken.raw.length) + newToken.raw;\n          text = text.substring(0, text.length - oldToken.raw.length) + newToken.raw;\n          lines = newText.substring(tokens.at(-1)!.raw.length).split('\\n');\n          continue;\n        }\n      }\n\n      return {\n        type: 'blockquote',\n        raw,\n        tokens,\n        text,\n      };\n    }\n  }\n\n  list(src: string): Tokens.List | undefined {\n    let cap = this.rules.block.list.exec(src);\n    if (cap) {\n      let bull = cap[1].trim();\n      const isordered = bull.length > 1;\n\n      const list: Tokens.List = {\n        type: 'list',\n        raw: '',\n        ordered: isordered,\n        start: isordered ? +bull.slice(0, -1) : '',\n        loose: false,\n        items: [],\n      };\n\n      bull = isordered ? `\\\\d{1,9}\\\\${bull.slice(-1)}` : `\\\\${bull}`;\n\n      if (this.options.pedantic) {\n        bull = isordered ? bull : '[*+-]';\n      }\n\n      // Get next list item\n      const itemRegex = this.rules.other.listItemRegex(bull);\n      let endsWithBlankLine = false;\n      // Check if current bullet point can start a new List Item\n      while (src) {\n        let endEarly = false;\n        let raw = '';\n        let itemContents = '';\n        if (!(cap = itemRegex.exec(src))) {\n          break;\n        }\n\n        if (this.rules.block.hr.test(src)) { // End list if bullet was actually HR (possibly move into itemRegex?)\n          break;\n        }\n\n        raw = cap[0];\n        src = src.substring(raw.length);\n\n        let line = cap[2].split('\\n', 1)[0].replace(this.rules.other.listReplaceTabs, (t: string) => ' '.repeat(3 * t.length));\n        let nextLine = src.split('\\n', 1)[0];\n        let blankLine = !line.trim();\n\n        let indent = 0;\n        if (this.options.pedantic) {\n          indent = 2;\n          itemContents = line.trimStart();\n        } else if (blankLine) {\n          indent = cap[1].length + 1;\n        } else {\n          indent = cap[2].search(this.rules.other.nonSpaceChar); // Find first non-space char\n          indent = indent > 4 ? 1 : indent; // Treat indented code blocks (> 4 spaces) as having only 1 indent\n          itemContents = line.slice(indent);\n          indent += cap[1].length;\n        }\n\n        if (blankLine && this.rules.other.blankLine.test(nextLine)) { // Items begin with at most one blank line\n          raw += nextLine + '\\n';\n          src = src.substring(nextLine.length + 1);\n          endEarly = true;\n        }\n\n        if (!endEarly) {\n          const nextBulletRegex = this.rules.other.nextBulletRegex(indent);\n          const hrRegex = this.rules.other.hrRegex(indent);\n          const fencesBeginRegex = this.rules.other.fencesBeginRegex(indent);\n          const headingBeginRegex = this.rules.other.headingBeginRegex(indent);\n          const htmlBeginRegex = this.rules.other.htmlBeginRegex(indent);\n\n          // Check if following lines should be included in List Item\n          while (src) {\n            const rawLine = src.split('\\n', 1)[0];\n            let nextLineWithoutTabs;\n            nextLine = rawLine;\n\n            // Re-align to follow commonmark nesting rules\n            if (this.options.pedantic) {\n              nextLine = nextLine.replace(this.rules.other.listReplaceNesting, '  ');\n              nextLineWithoutTabs = nextLine;\n            } else {\n              nextLineWithoutTabs = nextLine.replace(this.rules.other.tabCharGlobal, '    ');\n            }\n\n            // End list item if found code fences\n            if (fencesBeginRegex.test(nextLine)) {\n              break;\n            }\n\n            // End list item if found start of new heading\n            if (headingBeginRegex.test(nextLine)) {\n              break;\n            }\n\n            // End list item if found start of html block\n            if (htmlBeginRegex.test(nextLine)) {\n              break;\n            }\n\n            // End list item if found start of new bullet\n            if (nextBulletRegex.test(nextLine)) {\n              break;\n            }\n\n            // Horizontal rule found\n            if (hrRegex.test(nextLine)) {\n              break;\n            }\n\n            if (nextLineWithoutTabs.search(this.rules.other.nonSpaceChar) >= indent || !nextLine.trim()) { // Dedent if possible\n              itemContents += '\\n' + nextLineWithoutTabs.slice(indent);\n            } else {\n              // not enough indentation\n              if (blankLine) {\n                break;\n              }\n\n              // paragraph continuation unless last line was a different block level element\n              if (line.replace(this.rules.other.tabCharGlobal, '    ').search(this.rules.other.nonSpaceChar) >= 4) { // indented code block\n                break;\n              }\n              if (fencesBeginRegex.test(line)) {\n                break;\n              }\n              if (headingBeginRegex.test(line)) {\n                break;\n              }\n              if (hrRegex.test(line)) {\n                break;\n              }\n\n              itemContents += '\\n' + nextLine;\n            }\n\n            if (!blankLine && !nextLine.trim()) { // Check if current line is blank\n              blankLine = true;\n            }\n\n            raw += rawLine + '\\n';\n            src = src.substring(rawLine.length + 1);\n            line = nextLineWithoutTabs.slice(indent);\n          }\n        }\n\n        if (!list.loose) {\n          // If the previous item ended with a blank line, the list is loose\n          if (endsWithBlankLine) {\n            list.loose = true;\n          } else if (this.rules.other.doubleBlankLine.test(raw)) {\n            endsWithBlankLine = true;\n          }\n        }\n\n        let istask: RegExpExecArray | null = null;\n        let ischecked: boolean | undefined;\n        // Check for task list items\n        if (this.options.gfm) {\n          istask = this.rules.other.listIsTask.exec(itemContents);\n          if (istask) {\n            ischecked = istask[0] !== '[ ] ';\n            itemContents = itemContents.replace(this.rules.other.listReplaceTask, '');\n          }\n        }\n\n        list.items.push({\n          type: 'list_item',\n          raw,\n          task: !!istask,\n          checked: ischecked,\n          loose: false,\n          text: itemContents,\n          tokens: [],\n        });\n\n        list.raw += raw;\n      }\n\n      // Do not consume newlines at end of final item. Alternatively, make itemRegex *start* with any newlines to simplify/speed up endsWithBlankLine logic\n      const lastItem = list.items.at(-1);\n      if (lastItem) {\n        lastItem.raw = lastItem.raw.trimEnd();\n        lastItem.text = lastItem.text.trimEnd();\n      } else {\n        // not a list since there were no items\n        return;\n      }\n      list.raw = list.raw.trimEnd();\n\n      // Item child tokens handled here at end because we needed to have the final item to trim it first\n      for (let i = 0; i < list.items.length; i++) {\n        this.lexer.state.top = false;\n        list.items[i].tokens = this.lexer.blockTokens(list.items[i].text, []);\n\n        if (!list.loose) {\n          // Check if list should be loose\n          const spacers = list.items[i].tokens.filter(t => t.type === 'space');\n          const hasMultipleLineBreaks = spacers.length > 0 && spacers.some(t => this.rules.other.anyLine.test(t.raw));\n\n          list.loose = hasMultipleLineBreaks;\n        }\n      }\n\n      // Set all items to loose if list is loose\n      if (list.loose) {\n        for (let i = 0; i < list.items.length; i++) {\n          list.items[i].loose = true;\n        }\n      }\n\n      return list;\n    }\n  }\n\n  html(src: string): Tokens.HTML | undefined {\n    const cap = this.rules.block.html.exec(src);\n    if (cap) {\n      const token: Tokens.HTML = {\n        type: 'html',\n        block: true,\n        raw: cap[0],\n        pre: cap[1] === 'pre' || cap[1] === 'script' || cap[1] === 'style',\n        text: cap[0],\n      };\n      return token;\n    }\n  }\n\n  def(src: string): Tokens.Def | undefined {\n    const cap = this.rules.block.def.exec(src);\n    if (cap) {\n      const tag = cap[1].toLowerCase().replace(this.rules.other.multipleSpaceGlobal, ' ');\n      const href = cap[2] ? cap[2].replace(this.rules.other.hrefBrackets, '$1').replace(this.rules.inline.anyPunctuation, '$1') : '';\n      const title = cap[3] ? cap[3].substring(1, cap[3].length - 1).replace(this.rules.inline.anyPunctuation, '$1') : cap[3];\n      return {\n        type: 'def',\n        tag,\n        raw: cap[0],\n        href,\n        title,\n      };\n    }\n  }\n\n  table(src: string): Tokens.Table | undefined {\n    const cap = this.rules.block.table.exec(src);\n    if (!cap) {\n      return;\n    }\n\n    if (!this.rules.other.tableDelimiter.test(cap[2])) {\n      // delimiter row must have a pipe (|) or colon (:) otherwise it is a setext heading\n      return;\n    }\n\n    const headers = splitCells(cap[1]);\n    const aligns = cap[2].replace(this.rules.other.tableAlignChars, '').split('|');\n    const rows = cap[3]?.trim() ? cap[3].replace(this.rules.other.tableRowBlankLine, '').split('\\n') : [];\n\n    const item: Tokens.Table = {\n      type: 'table',\n      raw: cap[0],\n      header: [],\n      align: [],\n      rows: [],\n    };\n\n    if (headers.length !== aligns.length) {\n      // header and align columns must be equal, rows can be different.\n      return;\n    }\n\n    for (const align of aligns) {\n      if (this.rules.other.tableAlignRight.test(align)) {\n        item.align.push('right');\n      } else if (this.rules.other.tableAlignCenter.test(align)) {\n        item.align.push('center');\n      } else if (this.rules.other.tableAlignLeft.test(align)) {\n        item.align.push('left');\n      } else {\n        item.align.push(null);\n      }\n    }\n\n    for (let i = 0; i < headers.length; i++) {\n      item.header.push({\n        text: headers[i],\n        tokens: this.lexer.inline(headers[i]),\n        header: true,\n        align: item.align[i],\n      });\n    }\n\n    for (const row of rows) {\n      item.rows.push(splitCells(row, item.header.length).map((cell, i) => {\n        return {\n          text: cell,\n          tokens: this.lexer.inline(cell),\n          header: false,\n          align: item.align[i],\n        };\n      }));\n    }\n\n    return item;\n  }\n\n  lheading(src: string): Tokens.Heading | undefined {\n    const cap = this.rules.block.lheading.exec(src);\n    if (cap) {\n      return {\n        type: 'heading',\n        raw: cap[0],\n        depth: cap[2].charAt(0) === '=' ? 1 : 2,\n        text: cap[1],\n        tokens: this.lexer.inline(cap[1]),\n      };\n    }\n  }\n\n  paragraph(src: string): Tokens.Paragraph | undefined {\n    const cap = this.rules.block.paragraph.exec(src);\n    if (cap) {\n      const text = cap[1].charAt(cap[1].length - 1) === '\\n'\n        ? cap[1].slice(0, -1)\n        : cap[1];\n      return {\n        type: 'paragraph',\n        raw: cap[0],\n        text,\n        tokens: this.lexer.inline(text),\n      };\n    }\n  }\n\n  text(src: string): Tokens.Text | undefined {\n    const cap = this.rules.block.text.exec(src);\n    if (cap) {\n      return {\n        type: 'text',\n        raw: cap[0],\n        text: cap[0],\n        tokens: this.lexer.inline(cap[0]),\n      };\n    }\n  }\n\n  escape(src: string): Tokens.Escape | undefined {\n    const cap = this.rules.inline.escape.exec(src);\n    if (cap) {\n      return {\n        type: 'escape',\n        raw: cap[0],\n        text: cap[1],\n      };\n    }\n  }\n\n  tag(src: string): Tokens.Tag | undefined {\n    const cap = this.rules.inline.tag.exec(src);\n    if (cap) {\n      if (!this.lexer.state.inLink && this.rules.other.startATag.test(cap[0])) {\n        this.lexer.state.inLink = true;\n      } else if (this.lexer.state.inLink && this.rules.other.endATag.test(cap[0])) {\n        this.lexer.state.inLink = false;\n      }\n      if (!this.lexer.state.inRawBlock && this.rules.other.startPreScriptTag.test(cap[0])) {\n        this.lexer.state.inRawBlock = true;\n      } else if (this.lexer.state.inRawBlock && this.rules.other.endPreScriptTag.test(cap[0])) {\n        this.lexer.state.inRawBlock = false;\n      }\n\n      return {\n        type: 'html',\n        raw: cap[0],\n        inLink: this.lexer.state.inLink,\n        inRawBlock: this.lexer.state.inRawBlock,\n        block: false,\n        text: cap[0],\n      };\n    }\n  }\n\n  link(src: string): Tokens.Link | Tokens.Image | undefined {\n    const cap = this.rules.inline.link.exec(src);\n    if (cap) {\n      const trimmedUrl = cap[2].trim();\n      if (!this.options.pedantic && this.rules.other.startAngleBracket.test(trimmedUrl)) {\n        // commonmark requires matching angle brackets\n        if (!(this.rules.other.endAngleBracket.test(trimmedUrl))) {\n          return;\n        }\n\n        // ending angle bracket cannot be escaped\n        const rtrimSlash = rtrim(trimmedUrl.slice(0, -1), '\\\\');\n        if ((trimmedUrl.length - rtrimSlash.length) % 2 === 0) {\n          return;\n        }\n      } else {\n        // find closing parenthesis\n        const lastParenIndex = findClosingBracket(cap[2], '()');\n        if (lastParenIndex === -2) {\n          // more open parens than closed\n          return;\n        }\n\n        if (lastParenIndex > -1) {\n          const start = cap[0].indexOf('!') === 0 ? 5 : 4;\n          const linkLen = start + cap[1].length + lastParenIndex;\n          cap[2] = cap[2].substring(0, lastParenIndex);\n          cap[0] = cap[0].substring(0, linkLen).trim();\n          cap[3] = '';\n        }\n      }\n      let href = cap[2];\n      let title = '';\n      if (this.options.pedantic) {\n        // split pedantic href and title\n        const link = this.rules.other.pedanticHrefTitle.exec(href);\n\n        if (link) {\n          href = link[1];\n          title = link[3];\n        }\n      } else {\n        title = cap[3] ? cap[3].slice(1, -1) : '';\n      }\n\n      href = href.trim();\n      if (this.rules.other.startAngleBracket.test(href)) {\n        if (this.options.pedantic && !(this.rules.other.endAngleBracket.test(trimmedUrl))) {\n          // pedantic allows starting angle bracket without ending angle bracket\n          href = href.slice(1);\n        } else {\n          href = href.slice(1, -1);\n        }\n      }\n      return outputLink(cap, {\n        href: href ? href.replace(this.rules.inline.anyPunctuation, '$1') : href,\n        title: title ? title.replace(this.rules.inline.anyPunctuation, '$1') : title,\n      }, cap[0], this.lexer, this.rules);\n    }\n  }\n\n  reflink(src: string, links: Links): Tokens.Link | Tokens.Image | Tokens.Text | undefined {\n    let cap;\n    if ((cap = this.rules.inline.reflink.exec(src))\n      || (cap = this.rules.inline.nolink.exec(src))) {\n      const linkString = (cap[2] || cap[1]).replace(this.rules.other.multipleSpaceGlobal, ' ');\n      const link = links[linkString.toLowerCase()];\n      if (!link) {\n        const text = cap[0].charAt(0);\n        return {\n          type: 'text',\n          raw: text,\n          text,\n        };\n      }\n      return outputLink(cap, link, cap[0], this.lexer, this.rules);\n    }\n  }\n\n  emStrong(src: string, maskedSrc: string, prevChar = ''): Tokens.Em | Tokens.Strong | undefined {\n    let match = this.rules.inline.emStrongLDelim.exec(src);\n    if (!match) return;\n\n    // _ can't be between two alphanumerics. \\p{L}\\p{N} includes non-english alphabet/numbers as well\n    if (match[3] && prevChar.match(this.rules.other.unicodeAlphaNumeric)) return;\n\n    const nextChar = match[1] || match[2] || '';\n\n    if (!nextChar || !prevChar || this.rules.inline.punctuation.exec(prevChar)) {\n      // unicode Regex counts emoji as 1 char; spread into array for proper count (used multiple times below)\n      const lLength = [...match[0]].length - 1;\n      let rDelim, rLength, delimTotal = lLength, midDelimTotal = 0;\n\n      const endReg = match[0][0] === '*' ? this.rules.inline.emStrongRDelimAst : this.rules.inline.emStrongRDelimUnd;\n      endReg.lastIndex = 0;\n\n      // Clip maskedSrc to same section of string as src (move to lexer?)\n      maskedSrc = maskedSrc.slice(-1 * src.length + lLength);\n\n      while ((match = endReg.exec(maskedSrc)) != null) {\n        rDelim = match[1] || match[2] || match[3] || match[4] || match[5] || match[6];\n\n        if (!rDelim) continue; // skip single * in __abc*abc__\n\n        rLength = [...rDelim].length;\n\n        if (match[3] || match[4]) { // found another Left Delim\n          delimTotal += rLength;\n          continue;\n        } else if (match[5] || match[6]) { // either Left or Right Delim\n          if (lLength % 3 && !((lLength + rLength) % 3)) {\n            midDelimTotal += rLength;\n            continue; // CommonMark Emphasis Rules 9-10\n          }\n        }\n\n        delimTotal -= rLength;\n\n        if (delimTotal > 0) continue; // Haven't found enough closing delimiters\n\n        // Remove extra characters. *a*** -> *a*\n        rLength = Math.min(rLength, rLength + delimTotal + midDelimTotal);\n        // char length can be >1 for unicode characters;\n        const lastCharLength = [...match[0]][0].length;\n        const raw = src.slice(0, lLength + match.index + lastCharLength + rLength);\n\n        // Create `em` if smallest delimiter has odd char count. *a***\n        if (Math.min(lLength, rLength) % 2) {\n          const text = raw.slice(1, -1);\n          return {\n            type: 'em',\n            raw,\n            text,\n            tokens: this.lexer.inlineTokens(text),\n          };\n        }\n\n        // Create 'strong' if smallest delimiter has even char count. **a***\n        const text = raw.slice(2, -2);\n        return {\n          type: 'strong',\n          raw,\n          text,\n          tokens: this.lexer.inlineTokens(text),\n        };\n      }\n    }\n  }\n\n  codespan(src: string): Tokens.Codespan | undefined {\n    const cap = this.rules.inline.code.exec(src);\n    if (cap) {\n      let text = cap[2].replace(this.rules.other.newLineCharGlobal, ' ');\n      const hasNonSpaceChars = this.rules.other.nonSpaceChar.test(text);\n      const hasSpaceCharsOnBothEnds = this.rules.other.startingSpaceChar.test(text) && this.rules.other.endingSpaceChar.test(text);\n      if (hasNonSpaceChars && hasSpaceCharsOnBothEnds) {\n        text = text.substring(1, text.length - 1);\n      }\n      return {\n        type: 'codespan',\n        raw: cap[0],\n        text,\n      };\n    }\n  }\n\n  br(src: string): Tokens.Br | undefined {\n    const cap = this.rules.inline.br.exec(src);\n    if (cap) {\n      return {\n        type: 'br',\n        raw: cap[0],\n      };\n    }\n  }\n\n  del(src: string): Tokens.Del | undefined {\n    const cap = this.rules.inline.del.exec(src);\n    if (cap) {\n      return {\n        type: 'del',\n        raw: cap[0],\n        text: cap[2],\n        tokens: this.lexer.inlineTokens(cap[2]),\n      };\n    }\n  }\n\n  autolink(src: string): Tokens.Link | undefined {\n    const cap = this.rules.inline.autolink.exec(src);\n    if (cap) {\n      let text, href;\n      if (cap[2] === '@') {\n        text = cap[1];\n        href = 'mailto:' + text;\n      } else {\n        text = cap[1];\n        href = text;\n      }\n\n      return {\n        type: 'link',\n        raw: cap[0],\n        text,\n        href,\n        tokens: [\n          {\n            type: 'text',\n            raw: text,\n            text,\n          },\n        ],\n      };\n    }\n  }\n\n  url(src: string): Tokens.Link | undefined {\n    let cap;\n    if (cap = this.rules.inline.url.exec(src)) {\n      let text, href;\n      if (cap[2] === '@') {\n        text = cap[0];\n        href = 'mailto:' + text;\n      } else {\n        // do extended autolink path validation\n        let prevCapZero;\n        do {\n          prevCapZero = cap[0];\n          cap[0] = this.rules.inline._backpedal.exec(cap[0])?.[0] ?? '';\n        } while (prevCapZero !== cap[0]);\n        text = cap[0];\n        if (cap[1] === 'www.') {\n          href = 'http://' + cap[0];\n        } else {\n          href = cap[0];\n        }\n      }\n      return {\n        type: 'link',\n        raw: cap[0],\n        text,\n        href,\n        tokens: [\n          {\n            type: 'text',\n            raw: text,\n            text,\n          },\n        ],\n      };\n    }\n  }\n\n  inlineText(src: string): Tokens.Text | undefined {\n    const cap = this.rules.inline.text.exec(src);\n    if (cap) {\n      const escaped = this.lexer.state.inRawBlock;\n      return {\n        type: 'text',\n        raw: cap[0],\n        text: cap[0],\n        escaped,\n      };\n    }\n  }\n}\n","import { _Tokenizer } from './Tokenizer.ts';\nimport { _defaults } from './defaults.ts';\nimport { other, block, inline } from './rules.ts';\nimport type { Token, TokensList, Tokens } from './Tokens.ts';\nimport type { MarkedOptions } from './MarkedOptions.ts';\n\n/**\n * Block Lexer\n */\nexport class _Lexer<ParserOutput = string, RendererOutput = string> {\n  tokens: TokensList;\n  options: MarkedOptions<ParserOutput, RendererOutput>;\n  state: {\n    inLink: boolean;\n    inRawBlock: boolean;\n    top: boolean;\n  };\n\n  private tokenizer: _Tokenizer<ParserOutput, RendererOutput>;\n  private inlineQueue: { src: string, tokens: Token[] }[];\n\n  constructor(options?: MarkedOptions<ParserOutput, RendererOutput>) {\n    // TokenList cannot be created in one go\n    this.tokens = [] as unknown as TokensList;\n    this.tokens.links = Object.create(null);\n    this.options = options || _defaults;\n    this.options.tokenizer = this.options.tokenizer || new _Tokenizer<ParserOutput, RendererOutput>();\n    this.tokenizer = this.options.tokenizer;\n    this.tokenizer.options = this.options;\n    this.tokenizer.lexer = this;\n    this.inlineQueue = [];\n    this.state = {\n      inLink: false,\n      inRawBlock: false,\n      top: true,\n    };\n\n    const rules = {\n      other,\n      block: block.normal,\n      inline: inline.normal,\n    };\n\n    if (this.options.pedantic) {\n      rules.block = block.pedantic;\n      rules.inline = inline.pedantic;\n    } else if (this.options.gfm) {\n      rules.block = block.gfm;\n      if (this.options.breaks) {\n        rules.inline = inline.breaks;\n      } else {\n        rules.inline = inline.gfm;\n      }\n    }\n    this.tokenizer.rules = rules;\n  }\n\n  /**\n   * Expose Rules\n   */\n  static get rules() {\n    return {\n      block,\n      inline,\n    };\n  }\n\n  /**\n   * Static Lex Method\n   */\n  static lex<ParserOutput = string, RendererOutput = string>(src: string, options?: MarkedOptions<ParserOutput, RendererOutput>) {\n    const lexer = new _Lexer<ParserOutput, RendererOutput>(options);\n    return lexer.lex(src);\n  }\n\n  /**\n   * Static Lex Inline Method\n   */\n  static lexInline<ParserOutput = string, RendererOutput = string>(src: string, options?: MarkedOptions<ParserOutput, RendererOutput>) {\n    const lexer = new _Lexer<ParserOutput, RendererOutput>(options);\n    return lexer.inlineTokens(src);\n  }\n\n  /**\n   * Preprocessing\n   */\n  lex(src: string) {\n    src = src.replace(other.carriageReturn, '\\n');\n\n    this.blockTokens(src, this.tokens);\n\n    for (let i = 0; i < this.inlineQueue.length; i++) {\n      const next = this.inlineQueue[i];\n      this.inlineTokens(next.src, next.tokens);\n    }\n    this.inlineQueue = [];\n\n    return this.tokens;\n  }\n\n  /**\n   * Lexing\n   */\n  blockTokens(src: string, tokens?: Token[], lastParagraphClipped?: boolean): Token[];\n  blockTokens(src: string, tokens?: TokensList, lastParagraphClipped?: boolean): TokensList;\n  blockTokens(src: string, tokens: Token[] = [], lastParagraphClipped = false) {\n    if (this.options.pedantic) {\n      src = src.replace(other.tabCharGlobal, '    ').replace(other.spaceLine, '');\n    }\n\n    while (src) {\n      let token: Tokens.Generic | undefined;\n\n      if (this.options.extensions?.block?.some((extTokenizer) => {\n        if (token = extTokenizer.call({ lexer: this }, src, tokens)) {\n          src = src.substring(token.raw.length);\n          tokens.push(token);\n          return true;\n        }\n        return false;\n      })) {\n        continue;\n      }\n\n      // newline\n      if (token = this.tokenizer.space(src)) {\n        src = src.substring(token.raw.length);\n        const lastToken = tokens.at(-1);\n        if (token.raw.length === 1 && lastToken !== undefined) {\n          // if there's a single \\n as a spacer, it's terminating the last line,\n          // so move it there so that we don't get unnecessary paragraph tags\n          lastToken.raw += '\\n';\n        } else {\n          tokens.push(token);\n        }\n        continue;\n      }\n\n      // code\n      if (token = this.tokenizer.code(src)) {\n        src = src.substring(token.raw.length);\n        const lastToken = tokens.at(-1);\n        // An indented code block cannot interrupt a paragraph.\n        if (lastToken?.type === 'paragraph' || lastToken?.type === 'text') {\n          lastToken.raw += (lastToken.raw.endsWith('\\n') ? '' : '\\n') + token.raw;\n          lastToken.text += '\\n' + token.text;\n          this.inlineQueue.at(-1)!.src = lastToken.text;\n        } else {\n          tokens.push(token);\n        }\n        continue;\n      }\n\n      // fences\n      if (token = this.tokenizer.fences(src)) {\n        src = src.substring(token.raw.length);\n        tokens.push(token);\n        continue;\n      }\n\n      // heading\n      if (token = this.tokenizer.heading(src)) {\n        src = src.substring(token.raw.length);\n        tokens.push(token);\n        continue;\n      }\n\n      // hr\n      if (token = this.tokenizer.hr(src)) {\n        src = src.substring(token.raw.length);\n        tokens.push(token);\n        continue;\n      }\n\n      // blockquote\n      if (token = this.tokenizer.blockquote(src)) {\n        src = src.substring(token.raw.length);\n        tokens.push(token);\n        continue;\n      }\n\n      // list\n      if (token = this.tokenizer.list(src)) {\n        src = src.substring(token.raw.length);\n        tokens.push(token);\n        continue;\n      }\n\n      // html\n      if (token = this.tokenizer.html(src)) {\n        src = src.substring(token.raw.length);\n        tokens.push(token);\n        continue;\n      }\n\n      // def\n      if (token = this.tokenizer.def(src)) {\n        src = src.substring(token.raw.length);\n        const lastToken = tokens.at(-1);\n        if (lastToken?.type === 'paragraph' || lastToken?.type === 'text') {\n          lastToken.raw += (lastToken.raw.endsWith('\\n') ? '' : '\\n') + token.raw;\n          lastToken.text += '\\n' + token.raw;\n          this.inlineQueue.at(-1)!.src = lastToken.text;\n        } else if (!this.tokens.links[token.tag]) {\n          this.tokens.links[token.tag] = {\n            href: token.href,\n            title: token.title,\n          };\n          tokens.push(token);\n        }\n        continue;\n      }\n\n      // table (gfm)\n      if (token = this.tokenizer.table(src)) {\n        src = src.substring(token.raw.length);\n        tokens.push(token);\n        continue;\n      }\n\n      // lheading\n      if (token = this.tokenizer.lheading(src)) {\n        src = src.substring(token.raw.length);\n        tokens.push(token);\n        continue;\n      }\n\n      // top-level paragraph\n      // prevent paragraph consuming extensions by clipping 'src' to extension start\n      let cutSrc = src;\n      if (this.options.extensions?.startBlock) {\n        let startIndex = Infinity;\n        const tempSrc = src.slice(1);\n        let tempStart;\n        this.options.extensions.startBlock.forEach((getStartIndex) => {\n          tempStart = getStartIndex.call({ lexer: this }, tempSrc);\n          if (typeof tempStart === 'number' && tempStart >= 0) {\n            startIndex = Math.min(startIndex, tempStart);\n          }\n        });\n        if (startIndex < Infinity && startIndex >= 0) {\n          cutSrc = src.substring(0, startIndex + 1);\n        }\n      }\n      if (this.state.top && (token = this.tokenizer.paragraph(cutSrc))) {\n        const lastToken = tokens.at(-1);\n        if (lastParagraphClipped && lastToken?.type === 'paragraph') {\n          lastToken.raw += (lastToken.raw.endsWith('\\n') ? '' : '\\n') + token.raw;\n          lastToken.text += '\\n' + token.text;\n          this.inlineQueue.pop();\n          this.inlineQueue.at(-1)!.src = lastToken.text;\n        } else {\n          tokens.push(token);\n        }\n        lastParagraphClipped = cutSrc.length !== src.length;\n        src = src.substring(token.raw.length);\n        continue;\n      }\n\n      // text\n      if (token = this.tokenizer.text(src)) {\n        src = src.substring(token.raw.length);\n        const lastToken = tokens.at(-1);\n        if (lastToken?.type === 'text') {\n          lastToken.raw += (lastToken.raw.endsWith('\\n') ? '' : '\\n') + token.raw;\n          lastToken.text += '\\n' + token.text;\n          this.inlineQueue.pop();\n          this.inlineQueue.at(-1)!.src = lastToken.text;\n        } else {\n          tokens.push(token);\n        }\n        continue;\n      }\n\n      if (src) {\n        const errMsg = 'Infinite loop on byte: ' + src.charCodeAt(0);\n        if (this.options.silent) {\n          console.error(errMsg);\n          break;\n        } else {\n          throw new Error(errMsg);\n        }\n      }\n    }\n\n    this.state.top = true;\n    return tokens;\n  }\n\n  inline(src: string, tokens: Token[] = []) {\n    this.inlineQueue.push({ src, tokens });\n    return tokens;\n  }\n\n  /**\n   * Lexing/Compiling\n   */\n  inlineTokens(src: string, tokens: Token[] = []): Token[] {\n    // String with links masked to avoid interference with em and strong\n    let maskedSrc = src;\n    let match: RegExpExecArray | null = null;\n\n    // Mask out reflinks\n    if (this.tokens.links) {\n      const links = Object.keys(this.tokens.links);\n      if (links.length > 0) {\n        while ((match = this.tokenizer.rules.inline.reflinkSearch.exec(maskedSrc)) != null) {\n          if (links.includes(match[0].slice(match[0].lastIndexOf('[') + 1, -1))) {\n            maskedSrc = maskedSrc.slice(0, match.index)\n              + '[' + 'a'.repeat(match[0].length - 2) + ']'\n              + maskedSrc.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex);\n          }\n        }\n      }\n    }\n\n    // Mask out escaped characters\n    while ((match = this.tokenizer.rules.inline.anyPunctuation.exec(maskedSrc)) != null) {\n      maskedSrc = maskedSrc.slice(0, match.index) + '++' + maskedSrc.slice(this.tokenizer.rules.inline.anyPunctuation.lastIndex);\n    }\n\n    // Mask out other blocks\n    while ((match = this.tokenizer.rules.inline.blockSkip.exec(maskedSrc)) != null) {\n      maskedSrc = maskedSrc.slice(0, match.index) + '[' + 'a'.repeat(match[0].length - 2) + ']' + maskedSrc.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);\n    }\n\n    let keepPrevChar = false;\n    let prevChar = '';\n    while (src) {\n      if (!keepPrevChar) {\n        prevChar = '';\n      }\n      keepPrevChar = false;\n\n      let token: Tokens.Generic | undefined;\n\n      // extensions\n      if (this.options.extensions?.inline?.some((extTokenizer) => {\n        if (token = extTokenizer.call({ lexer: this }, src, tokens)) {\n          src = src.substring(token.raw.length);\n          tokens.push(token);\n          return true;\n        }\n        return false;\n      })) {\n        continue;\n      }\n\n      // escape\n      if (token = this.tokenizer.escape(src)) {\n        src = src.substring(token.raw.length);\n        tokens.push(token);\n        continue;\n      }\n\n      // tag\n      if (token = this.tokenizer.tag(src)) {\n        src = src.substring(token.raw.length);\n        tokens.push(token);\n        continue;\n      }\n\n      // link\n      if (token = this.tokenizer.link(src)) {\n        src = src.substring(token.raw.length);\n        tokens.push(token);\n        continue;\n      }\n\n      // reflink, nolink\n      if (token = this.tokenizer.reflink(src, this.tokens.links)) {\n        src = src.substring(token.raw.length);\n        const lastToken = tokens.at(-1);\n        if (token.type === 'text' && lastToken?.type === 'text') {\n          lastToken.raw += token.raw;\n          lastToken.text += token.text;\n        } else {\n          tokens.push(token);\n        }\n        continue;\n      }\n\n      // em & strong\n      if (token = this.tokenizer.emStrong(src, maskedSrc, prevChar)) {\n        src = src.substring(token.raw.length);\n        tokens.push(token);\n        continue;\n      }\n\n      // code\n      if (token = this.tokenizer.codespan(src)) {\n        src = src.substring(token.raw.length);\n        tokens.push(token);\n        continue;\n      }\n\n      // br\n      if (token = this.tokenizer.br(src)) {\n        src = src.substring(token.raw.length);\n        tokens.push(token);\n        continue;\n      }\n\n      // del (gfm)\n      if (token = this.tokenizer.del(src)) {\n        src = src.substring(token.raw.length);\n        tokens.push(token);\n        continue;\n      }\n\n      // autolink\n      if (token = this.tokenizer.autolink(src)) {\n        src = src.substring(token.raw.length);\n        tokens.push(token);\n        continue;\n      }\n\n      // url (gfm)\n      if (!this.state.inLink && (token = this.tokenizer.url(src))) {\n        src = src.substring(token.raw.length);\n        tokens.push(token);\n        continue;\n      }\n\n      // text\n      // prevent inlineText consuming extensions by clipping 'src' to extension start\n      let cutSrc = src;\n      if (this.options.extensions?.startInline) {\n        let startIndex = Infinity;\n        const tempSrc = src.slice(1);\n        let tempStart;\n        this.options.extensions.startInline.forEach((getStartIndex) => {\n          tempStart = getStartIndex.call({ lexer: this }, tempSrc);\n          if (typeof tempStart === 'number' && tempStart >= 0) {\n            startIndex = Math.min(startIndex, tempStart);\n          }\n        });\n        if (startIndex < Infinity && startIndex >= 0) {\n          cutSrc = src.substring(0, startIndex + 1);\n        }\n      }\n      if (token = this.tokenizer.inlineText(cutSrc)) {\n        src = src.substring(token.raw.length);\n        if (token.raw.slice(-1) !== '_') { // Track prevChar before string of ____ started\n          prevChar = token.raw.slice(-1);\n        }\n        keepPrevChar = true;\n        const lastToken = tokens.at(-1);\n        if (lastToken?.type === 'text') {\n          lastToken.raw += token.raw;\n          lastToken.text += token.text;\n        } else {\n          tokens.push(token);\n        }\n        continue;\n      }\n\n      if (src) {\n        const errMsg = 'Infinite loop on byte: ' + src.charCodeAt(0);\n        if (this.options.silent) {\n          console.error(errMsg);\n          break;\n        } else {\n          throw new Error(errMsg);\n        }\n      }\n    }\n\n    return tokens;\n  }\n}\n","import { _defaults } from './defaults.ts';\nimport {\n  cleanUrl,\n  escape,\n} from './helpers.ts';\nimport { other } from './rules.ts';\nimport type { MarkedOptions } from './MarkedOptions.ts';\nimport type { Tokens } from './Tokens.ts';\nimport type { _Parser } from './Parser.ts';\n\n/**\n * Renderer\n */\nexport class _Renderer<ParserOutput = string, RendererOutput = string> {\n  options: MarkedOptions<ParserOutput, RendererOutput>;\n  parser!: _Parser<ParserOutput, RendererOutput>; // set by the parser\n  constructor(options?: MarkedOptions<ParserOutput, RendererOutput>) {\n    this.options = options || _defaults;\n  }\n\n  space(token: Tokens.Space): RendererOutput {\n    return '' as RendererOutput;\n  }\n\n  code({ text, lang, escaped }: Tokens.Code): RendererOutput {\n    const langString = (lang || '').match(other.notSpaceStart)?.[0];\n\n    const code = text.replace(other.endingNewline, '') + '\\n';\n\n    if (!langString) {\n      return '<pre><code>'\n        + (escaped ? code : escape(code, true))\n        + '</code></pre>\\n' as RendererOutput;\n    }\n\n    return '<pre><code class=\"language-'\n      + escape(langString)\n      + '\">'\n      + (escaped ? code : escape(code, true))\n      + '</code></pre>\\n' as RendererOutput;\n  }\n\n  blockquote({ tokens }: Tokens.Blockquote): RendererOutput {\n    const body = this.parser.parse(tokens);\n    return `<blockquote>\\n${body}</blockquote>\\n` as RendererOutput;\n  }\n\n  html({ text }: Tokens.HTML | Tokens.Tag): RendererOutput {\n    return text as RendererOutput;\n  }\n\n  def(token: Tokens.Def): RendererOutput {\n    return '' as RendererOutput;\n  }\n\n  heading({ tokens, depth }: Tokens.Heading): RendererOutput {\n    return `<h${depth}>${this.parser.parseInline(tokens)}</h${depth}>\\n` as RendererOutput;\n  }\n\n  hr(token: Tokens.Hr): RendererOutput {\n    return '<hr>\\n' as RendererOutput;\n  }\n\n  list(token: Tokens.List): RendererOutput {\n    const ordered = token.ordered;\n    const start = token.start;\n\n    let body = '';\n    for (let j = 0; j < token.items.length; j++) {\n      const item = token.items[j];\n      body += this.listitem(item);\n    }\n\n    const type = ordered ? 'ol' : 'ul';\n    const startAttr = (ordered && start !== 1) ? (' start=\"' + start + '\"') : '';\n    return '<' + type + startAttr + '>\\n' + body + '</' + type + '>\\n' as RendererOutput;\n  }\n\n  listitem(item: Tokens.ListItem): RendererOutput {\n    let itemBody = '';\n    if (item.task) {\n      const checkbox = this.checkbox({ checked: !!item.checked });\n      if (item.loose) {\n        if (item.tokens[0]?.type === 'paragraph') {\n          item.tokens[0].text = checkbox + ' ' + item.tokens[0].text;\n          if (item.tokens[0].tokens && item.tokens[0].tokens.length > 0 && item.tokens[0].tokens[0].type === 'text') {\n            item.tokens[0].tokens[0].text = checkbox + ' ' + escape(item.tokens[0].tokens[0].text);\n            item.tokens[0].tokens[0].escaped = true;\n          }\n        } else {\n          item.tokens.unshift({\n            type: 'text',\n            raw: checkbox + ' ',\n            text: checkbox + ' ',\n            escaped: true,\n          });\n        }\n      } else {\n        itemBody += checkbox + ' ';\n      }\n    }\n\n    itemBody += this.parser.parse(item.tokens, !!item.loose);\n\n    return `<li>${itemBody}</li>\\n` as RendererOutput;\n  }\n\n  checkbox({ checked }: Tokens.Checkbox): RendererOutput {\n    return '<input '\n      + (checked ? 'checked=\"\" ' : '')\n      + 'disabled=\"\" type=\"checkbox\">' as RendererOutput;\n  }\n\n  paragraph({ tokens }: Tokens.Paragraph): RendererOutput {\n    return `<p>${this.parser.parseInline(tokens)}</p>\\n` as RendererOutput;\n  }\n\n  table(token: Tokens.Table): RendererOutput {\n    let header = '';\n\n    // header\n    let cell = '';\n    for (let j = 0; j < token.header.length; j++) {\n      cell += this.tablecell(token.header[j]);\n    }\n    header += this.tablerow({ text: cell as ParserOutput });\n\n    let body = '';\n    for (let j = 0; j < token.rows.length; j++) {\n      const row = token.rows[j];\n\n      cell = '';\n      for (let k = 0; k < row.length; k++) {\n        cell += this.tablecell(row[k]);\n      }\n\n      body += this.tablerow({ text: cell as ParserOutput });\n    }\n    if (body) body = `<tbody>${body}</tbody>`;\n\n    return '<table>\\n'\n      + '<thead>\\n'\n      + header\n      + '</thead>\\n'\n      + body\n      + '</table>\\n' as RendererOutput;\n  }\n\n  tablerow({ text }: Tokens.TableRow<ParserOutput>): RendererOutput {\n    return `<tr>\\n${text}</tr>\\n` as RendererOutput;\n  }\n\n  tablecell(token: Tokens.TableCell): RendererOutput {\n    const content = this.parser.parseInline(token.tokens);\n    const type = token.header ? 'th' : 'td';\n    const tag = token.align\n      ? `<${type} align=\"${token.align}\">`\n      : `<${type}>`;\n    return tag + content + `</${type}>\\n` as RendererOutput;\n  }\n\n  /**\n   * span level renderer\n   */\n  strong({ tokens }: Tokens.Strong): RendererOutput {\n    return `<strong>${this.parser.parseInline(tokens)}</strong>` as RendererOutput;\n  }\n\n  em({ tokens }: Tokens.Em): RendererOutput {\n    return `<em>${this.parser.parseInline(tokens)}</em>` as RendererOutput;\n  }\n\n  codespan({ text }: Tokens.Codespan): RendererOutput {\n    return `<code>${escape(text, true)}</code>` as RendererOutput;\n  }\n\n  br(token: Tokens.Br): RendererOutput {\n    return '<br>' as RendererOutput;\n  }\n\n  del({ tokens }: Tokens.Del): RendererOutput {\n    return `<del>${this.parser.parseInline(tokens)}</del>` as RendererOutput;\n  }\n\n  link({ href, title, tokens }: Tokens.Link): RendererOutput {\n    const text = this.parser.parseInline(tokens) as string;\n    const cleanHref = cleanUrl(href);\n    if (cleanHref === null) {\n      return text as RendererOutput;\n    }\n    href = cleanHref;\n    let out = '<a href=\"' + href + '\"';\n    if (title) {\n      out += ' title=\"' + (escape(title)) + '\"';\n    }\n    out += '>' + text + '</a>';\n    return out as RendererOutput;\n  }\n\n  image({ href, title, text, tokens }: Tokens.Image): RendererOutput {\n    if (tokens) {\n      text = this.parser.parseInline(tokens, this.parser.textRenderer) as string;\n    }\n    const cleanHref = cleanUrl(href);\n    if (cleanHref === null) {\n      return escape(text) as RendererOutput;\n    }\n    href = cleanHref;\n\n    let out = `<img src=\"${href}\" alt=\"${text}\"`;\n    if (title) {\n      out += ` title=\"${escape(title)}\"`;\n    }\n    out += '>';\n    return out as RendererOutput;\n  }\n\n  text(token: Tokens.Text | Tokens.Escape): RendererOutput {\n    return 'tokens' in token && token.tokens\n      ? this.parser.parseInline(token.tokens) as unknown as RendererOutput\n      : ('escaped' in token && token.escaped ? token.text as RendererOutput : escape(token.text) as RendererOutput);\n  }\n}\n","import type { Tokens } from './Tokens.ts';\n\n/**\n * TextRenderer\n * returns only the textual part of the token\n */\nexport class _TextRenderer<RendererOutput = string> {\n  // no need for block level renderers\n  strong({ text }: Tokens.Strong): RendererOutput {\n    return text as RendererOutput;\n  }\n\n  em({ text }: Tokens.Em): RendererOutput {\n    return text as RendererOutput;\n  }\n\n  codespan({ text }: Tokens.Codespan): RendererOutput {\n    return text as RendererOutput;\n  }\n\n  del({ text }: Tokens.Del): RendererOutput {\n    return text as RendererOutput;\n  }\n\n  html({ text }: Tokens.HTML | Tokens.Tag): RendererOutput {\n    return text as RendererOutput;\n  }\n\n  text({ text }: Tokens.Text | Tokens.Escape | Tokens.Tag): RendererOutput {\n    return text as RendererOutput;\n  }\n\n  link({ text }: Tokens.Link): RendererOutput {\n    return '' + text as RendererOutput;\n  }\n\n  image({ text }: Tokens.Image): RendererOutput {\n    return '' + text as RendererOutput;\n  }\n\n  br(): RendererOutput {\n    return '' as RendererOutput;\n  }\n}\n","import { _Renderer } from './Renderer.ts';\nimport { _TextRenderer } from './TextRenderer.ts';\nimport { _defaults } from './defaults.ts';\nimport type { MarkedToken, Token, Tokens } from './Tokens.ts';\nimport type { MarkedOptions } from './MarkedOptions.ts';\n\n/**\n * Parsing & Compiling\n */\nexport class _Parser<ParserOutput = string, RendererOutput = string> {\n  options: MarkedOptions<ParserOutput, RendererOutput>;\n  renderer: _Renderer<ParserOutput, RendererOutput>;\n  textRenderer: _TextRenderer<RendererOutput>;\n  constructor(options?: MarkedOptions<ParserOutput, RendererOutput>) {\n    this.options = options || _defaults;\n    this.options.renderer = this.options.renderer || new _Renderer<ParserOutput, RendererOutput>();\n    this.renderer = this.options.renderer;\n    this.renderer.options = this.options;\n    this.renderer.parser = this;\n    this.textRenderer = new _TextRenderer<RendererOutput>();\n  }\n\n  /**\n   * Static Parse Method\n   */\n  static parse<ParserOutput = string, RendererOutput = string>(tokens: Token[], options?: MarkedOptions<ParserOutput, RendererOutput>) {\n    const parser = new _Parser<ParserOutput, RendererOutput>(options);\n    return parser.parse(tokens);\n  }\n\n  /**\n   * Static Parse Inline Method\n   */\n  static parseInline<ParserOutput = string, RendererOutput = string>(tokens: Token[], options?: MarkedOptions<ParserOutput, RendererOutput>) {\n    const parser = new _Parser<ParserOutput, RendererOutput>(options);\n    return parser.parseInline(tokens);\n  }\n\n  /**\n   * Parse Loop\n   */\n  parse(tokens: Token[], top = true): ParserOutput {\n    let out = '';\n\n    for (let i = 0; i < tokens.length; i++) {\n      const anyToken = tokens[i];\n\n      // Run any renderer extensions\n      if (this.options.extensions?.renderers?.[anyToken.type]) {\n        const genericToken = anyToken as Tokens.Generic;\n        const ret = this.options.extensions.renderers[genericToken.type].call({ parser: this }, genericToken);\n        if (ret !== false || !['space', 'hr', 'heading', 'code', 'table', 'blockquote', 'list', 'html', 'def', 'paragraph', 'text'].includes(genericToken.type)) {\n          out += ret || '';\n          continue;\n        }\n      }\n\n      const token = anyToken as MarkedToken;\n\n      switch (token.type) {\n        case 'space': {\n          out += this.renderer.space(token);\n          continue;\n        }\n        case 'hr': {\n          out += this.renderer.hr(token);\n          continue;\n        }\n        case 'heading': {\n          out += this.renderer.heading(token);\n          continue;\n        }\n        case 'code': {\n          out += this.renderer.code(token);\n          continue;\n        }\n        case 'table': {\n          out += this.renderer.table(token);\n          continue;\n        }\n        case 'blockquote': {\n          out += this.renderer.blockquote(token);\n          continue;\n        }\n        case 'list': {\n          out += this.renderer.list(token);\n          continue;\n        }\n        case 'html': {\n          out += this.renderer.html(token);\n          continue;\n        }\n        case 'def': {\n          out += this.renderer.def(token);\n          continue;\n        }\n        case 'paragraph': {\n          out += this.renderer.paragraph(token);\n          continue;\n        }\n        case 'text': {\n          let textToken = token;\n          let body = this.renderer.text(textToken) as string;\n          while (i + 1 < tokens.length && tokens[i + 1].type === 'text') {\n            textToken = tokens[++i] as Tokens.Text;\n            body += ('\\n' + this.renderer.text(textToken));\n          }\n          if (top) {\n            out += this.renderer.paragraph({\n              type: 'paragraph',\n              raw: body,\n              text: body,\n              tokens: [{ type: 'text', raw: body, text: body, escaped: true }],\n            });\n          } else {\n            out += body;\n          }\n          continue;\n        }\n\n        default: {\n          const errMsg = 'Token with \"' + token.type + '\" type was not found.';\n          if (this.options.silent) {\n            console.error(errMsg);\n            return '' as ParserOutput;\n          } else {\n            throw new Error(errMsg);\n          }\n        }\n      }\n    }\n\n    return out as ParserOutput;\n  }\n\n  /**\n   * Parse Inline Tokens\n   */\n  parseInline(tokens: Token[], renderer: _Renderer<ParserOutput, RendererOutput> | _TextRenderer<RendererOutput> = this.renderer): ParserOutput {\n    let out = '';\n\n    for (let i = 0; i < tokens.length; i++) {\n      const anyToken = tokens[i];\n\n      // Run any renderer extensions\n      if (this.options.extensions?.renderers?.[anyToken.type]) {\n        const ret = this.options.extensions.renderers[anyToken.type].call({ parser: this }, anyToken);\n        if (ret !== false || !['escape', 'html', 'link', 'image', 'strong', 'em', 'codespan', 'br', 'del', 'text'].includes(anyToken.type)) {\n          out += ret || '';\n          continue;\n        }\n      }\n\n      const token = anyToken as MarkedToken;\n\n      switch (token.type) {\n        case 'escape': {\n          out += renderer.text(token);\n          break;\n        }\n        case 'html': {\n          out += renderer.html(token);\n          break;\n        }\n        case 'link': {\n          out += renderer.link(token);\n          break;\n        }\n        case 'image': {\n          out += renderer.image(token);\n          break;\n        }\n        case 'strong': {\n          out += renderer.strong(token);\n          break;\n        }\n        case 'em': {\n          out += renderer.em(token);\n          break;\n        }\n        case 'codespan': {\n          out += renderer.codespan(token);\n          break;\n        }\n        case 'br': {\n          out += renderer.br(token);\n          break;\n        }\n        case 'del': {\n          out += renderer.del(token);\n          break;\n        }\n        case 'text': {\n          out += renderer.text(token);\n          break;\n        }\n        default: {\n          const errMsg = 'Token with \"' + token.type + '\" type was not found.';\n          if (this.options.silent) {\n            console.error(errMsg);\n            return '' as ParserOutput;\n          } else {\n            throw new Error(errMsg);\n          }\n        }\n      }\n    }\n    return out as ParserOutput;\n  }\n}\n","import { _defaults } from './defaults.ts';\nimport { _Lexer } from './Lexer.ts';\nimport { _Parser } from './Parser.ts';\nimport type { MarkedOptions } from './MarkedOptions.ts';\nimport type { Token, TokensList } from './Tokens.ts';\n\nexport class _Hooks<ParserOutput = string, RendererOutput = string> {\n  options: MarkedOptions<ParserOutput, RendererOutput>;\n  block?: boolean;\n\n  constructor(options?: MarkedOptions<ParserOutput, RendererOutput>) {\n    this.options = options || _defaults;\n  }\n\n  static passThroughHooks = new Set([\n    'preprocess',\n    'postprocess',\n    'processAllTokens',\n  ]);\n\n  /**\n   * Process markdown before marked\n   */\n  preprocess(markdown: string) {\n    return markdown;\n  }\n\n  /**\n   * Process HTML after marked is finished\n   */\n  postprocess(html: ParserOutput) {\n    return html;\n  }\n\n  /**\n   * Process all tokens before walk tokens\n   */\n  processAllTokens(tokens: Token[] | TokensList) {\n    return tokens;\n  }\n\n  /**\n   * Provide function to tokenize markdown\n   */\n  provideLexer() {\n    return this.block ? _Lexer.lex : _Lexer.lexInline;\n  }\n\n  /**\n   * Provide function to parse tokens\n   */\n  provideParser() {\n    return this.block ? _Parser.parse<ParserOutput, RendererOutput> : _Parser.parseInline<ParserOutput, RendererOutput>;\n  }\n}\n","import { _getDefaults } from './defaults.ts';\nimport { _Lexer } from './Lexer.ts';\nimport { _Parser } from './Parser.ts';\nimport { _Hooks } from './Hooks.ts';\nimport { _Renderer } from './Renderer.ts';\nimport { _Tokenizer } from './Tokenizer.ts';\nimport { _TextRenderer } from './TextRenderer.ts';\nimport { escape } from './helpers.ts';\nimport type { MarkedExtension, MarkedOptions } from './MarkedOptions.ts';\nimport type { Token, Tokens, TokensList } from './Tokens.ts';\n\nexport type MaybePromise = void | Promise<void>;\n\ntype UnknownFunction = (...args: unknown[]) => unknown;\ntype GenericRendererFunction = (...args: unknown[]) => string | false;\n\nexport class Marked<ParserOutput = string, RendererOutput = string> {\n  defaults = _getDefaults<ParserOutput, RendererOutput>();\n  options = this.setOptions;\n\n  parse = this.parseMarkdown(true);\n  parseInline = this.parseMarkdown(false);\n\n  Parser = _Parser<ParserOutput, RendererOutput>;\n  Renderer = _Renderer<ParserOutput, RendererOutput>;\n  TextRenderer = _TextRenderer<RendererOutput>;\n  Lexer = _Lexer;\n  Tokenizer = _Tokenizer<ParserOutput, RendererOutput>;\n  Hooks = _Hooks<ParserOutput, RendererOutput>;\n\n  constructor(...args: MarkedExtension<ParserOutput, RendererOutput>[]) {\n    this.use(...args);\n  }\n\n  /**\n   * Run callback for every token\n   */\n  walkTokens(tokens: Token[] | TokensList, callback: (token: Token) => MaybePromise | MaybePromise[]) {\n    let values: MaybePromise[] = [];\n    for (const token of tokens) {\n      values = values.concat(callback.call(this, token));\n      switch (token.type) {\n        case 'table': {\n          const tableToken = token as Tokens.Table;\n          for (const cell of tableToken.header) {\n            values = values.concat(this.walkTokens(cell.tokens, callback));\n          }\n          for (const row of tableToken.rows) {\n            for (const cell of row) {\n              values = values.concat(this.walkTokens(cell.tokens, callback));\n            }\n          }\n          break;\n        }\n        case 'list': {\n          const listToken = token as Tokens.List;\n          values = values.concat(this.walkTokens(listToken.items, callback));\n          break;\n        }\n        default: {\n          const genericToken = token as Tokens.Generic;\n          if (this.defaults.extensions?.childTokens?.[genericToken.type]) {\n            this.defaults.extensions.childTokens[genericToken.type].forEach((childTokens) => {\n              const tokens = genericToken[childTokens].flat(Infinity) as Token[] | TokensList;\n              values = values.concat(this.walkTokens(tokens, callback));\n            });\n          } else if (genericToken.tokens) {\n            values = values.concat(this.walkTokens(genericToken.tokens, callback));\n          }\n        }\n      }\n    }\n    return values;\n  }\n\n  use(...args: MarkedExtension<ParserOutput, RendererOutput>[]) {\n    const extensions: MarkedOptions<ParserOutput, RendererOutput>['extensions'] = this.defaults.extensions || { renderers: {}, childTokens: {} };\n\n    args.forEach((pack) => {\n      // copy options to new object\n      const opts = { ...pack } as MarkedOptions<ParserOutput, RendererOutput>;\n\n      // set async to true if it was set to true before\n      opts.async = this.defaults.async || opts.async || false;\n\n      // ==-- Parse \"addon\" extensions --== //\n      if (pack.extensions) {\n        pack.extensions.forEach((ext) => {\n          if (!ext.name) {\n            throw new Error('extension name required');\n          }\n          if ('renderer' in ext) { // Renderer extensions\n            const prevRenderer = extensions.renderers[ext.name];\n            if (prevRenderer) {\n              // Replace extension with func to run new extension but fall back if false\n              extensions.renderers[ext.name] = function(...args) {\n                let ret = ext.renderer.apply(this, args);\n                if (ret === false) {\n                  ret = prevRenderer.apply(this, args);\n                }\n                return ret;\n              };\n            } else {\n              extensions.renderers[ext.name] = ext.renderer;\n            }\n          }\n          if ('tokenizer' in ext) { // Tokenizer Extensions\n            if (!ext.level || (ext.level !== 'block' && ext.level !== 'inline')) {\n              throw new Error(\"extension level must be 'block' or 'inline'\");\n            }\n            const extLevel = extensions[ext.level];\n            if (extLevel) {\n              extLevel.unshift(ext.tokenizer);\n            } else {\n              extensions[ext.level] = [ext.tokenizer];\n            }\n            if (ext.start) { // Function to check for start of token\n              if (ext.level === 'block') {\n                if (extensions.startBlock) {\n                  extensions.startBlock.push(ext.start);\n                } else {\n                  extensions.startBlock = [ext.start];\n                }\n              } else if (ext.level === 'inline') {\n                if (extensions.startInline) {\n                  extensions.startInline.push(ext.start);\n                } else {\n                  extensions.startInline = [ext.start];\n                }\n              }\n            }\n          }\n          if ('childTokens' in ext && ext.childTokens) { // Child tokens to be visited by walkTokens\n            extensions.childTokens[ext.name] = ext.childTokens;\n          }\n        });\n        opts.extensions = extensions;\n      }\n\n      // ==-- Parse \"overwrite\" extensions --== //\n      if (pack.renderer) {\n        const renderer = this.defaults.renderer || new _Renderer<ParserOutput, RendererOutput>(this.defaults);\n        for (const prop in pack.renderer) {\n          if (!(prop in renderer)) {\n            throw new Error(`renderer '${prop}' does not exist`);\n          }\n          if (['options', 'parser'].includes(prop)) {\n            // ignore options property\n            continue;\n          }\n          const rendererProp = prop as Exclude<keyof _Renderer<ParserOutput, RendererOutput>, 'options' | 'parser'>;\n          const rendererFunc = pack.renderer[rendererProp] as GenericRendererFunction;\n          const prevRenderer = renderer[rendererProp] as GenericRendererFunction;\n          // Replace renderer with func to run extension, but fall back if false\n          renderer[rendererProp] = (...args: unknown[]) => {\n            let ret = rendererFunc.apply(renderer, args);\n            if (ret === false) {\n              ret = prevRenderer.apply(renderer, args);\n            }\n            return (ret || '') as RendererOutput;\n          };\n        }\n        opts.renderer = renderer;\n      }\n      if (pack.tokenizer) {\n        const tokenizer = this.defaults.tokenizer || new _Tokenizer<ParserOutput, RendererOutput>(this.defaults);\n        for (const prop in pack.tokenizer) {\n          if (!(prop in tokenizer)) {\n            throw new Error(`tokenizer '${prop}' does not exist`);\n          }\n          if (['options', 'rules', 'lexer'].includes(prop)) {\n            // ignore options, rules, and lexer properties\n            continue;\n          }\n          const tokenizerProp = prop as Exclude<keyof _Tokenizer<ParserOutput, RendererOutput>, 'options' | 'rules' | 'lexer'>;\n          const tokenizerFunc = pack.tokenizer[tokenizerProp] as UnknownFunction;\n          const prevTokenizer = tokenizer[tokenizerProp] as UnknownFunction;\n          // Replace tokenizer with func to run extension, but fall back if false\n          // @ts-expect-error cannot type tokenizer function dynamically\n          tokenizer[tokenizerProp] = (...args: unknown[]) => {\n            let ret = tokenizerFunc.apply(tokenizer, args);\n            if (ret === false) {\n              ret = prevTokenizer.apply(tokenizer, args);\n            }\n            return ret;\n          };\n        }\n        opts.tokenizer = tokenizer;\n      }\n\n      // ==-- Parse Hooks extensions --== //\n      if (pack.hooks) {\n        const hooks = this.defaults.hooks || new _Hooks<ParserOutput, RendererOutput>();\n        for (const prop in pack.hooks) {\n          if (!(prop in hooks)) {\n            throw new Error(`hook '${prop}' does not exist`);\n          }\n          if (['options', 'block'].includes(prop)) {\n            // ignore options and block properties\n            continue;\n          }\n          const hooksProp = prop as Exclude<keyof _Hooks<ParserOutput, RendererOutput>, 'options' | 'block'>;\n          const hooksFunc = pack.hooks[hooksProp] as UnknownFunction;\n          const prevHook = hooks[hooksProp] as UnknownFunction;\n          if (_Hooks.passThroughHooks.has(prop)) {\n            // @ts-expect-error cannot type hook function dynamically\n            hooks[hooksProp] = (arg: unknown) => {\n              if (this.defaults.async) {\n                return Promise.resolve(hooksFunc.call(hooks, arg)).then(ret => {\n                  return prevHook.call(hooks, ret);\n                });\n              }\n\n              const ret = hooksFunc.call(hooks, arg);\n              return prevHook.call(hooks, ret);\n            };\n          } else {\n            // @ts-expect-error cannot type hook function dynamically\n            hooks[hooksProp] = (...args: unknown[]) => {\n              let ret = hooksFunc.apply(hooks, args);\n              if (ret === false) {\n                ret = prevHook.apply(hooks, args);\n              }\n              return ret;\n            };\n          }\n        }\n        opts.hooks = hooks;\n      }\n\n      // ==-- Parse WalkTokens extensions --== //\n      if (pack.walkTokens) {\n        const walkTokens = this.defaults.walkTokens;\n        const packWalktokens = pack.walkTokens;\n        opts.walkTokens = function(token) {\n          let values: MaybePromise[] = [];\n          values.push(packWalktokens.call(this, token));\n          if (walkTokens) {\n            values = values.concat(walkTokens.call(this, token));\n          }\n          return values;\n        };\n      }\n\n      this.defaults = { ...this.defaults, ...opts };\n    });\n\n    return this;\n  }\n\n  setOptions(opt: MarkedOptions<ParserOutput, RendererOutput>) {\n    this.defaults = { ...this.defaults, ...opt };\n    return this;\n  }\n\n  lexer(src: string, options?: MarkedOptions<ParserOutput, RendererOutput>) {\n    return _Lexer.lex(src, options ?? this.defaults);\n  }\n\n  parser(tokens: Token[], options?: MarkedOptions<ParserOutput, RendererOutput>) {\n    return _Parser.parse<ParserOutput, RendererOutput>(tokens, options ?? this.defaults);\n  }\n\n  private parseMarkdown(blockType: boolean) {\n    type overloadedParse = {\n      (src: string, options: MarkedOptions<ParserOutput, RendererOutput> & { async: true }): Promise<ParserOutput>;\n      (src: string, options: MarkedOptions<ParserOutput, RendererOutput> & { async: false }): ParserOutput;\n      (src: string, options?: MarkedOptions<ParserOutput, RendererOutput> | null): ParserOutput | Promise<ParserOutput>;\n    };\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const parse: overloadedParse = (src: string, options?: MarkedOptions<ParserOutput, RendererOutput> | null): any => {\n      const origOpt = { ...options };\n      const opt = { ...this.defaults, ...origOpt };\n\n      const throwError = this.onError(!!opt.silent, !!opt.async);\n\n      // throw error if an extension set async to true but parse was called with async: false\n      if (this.defaults.async === true && origOpt.async === false) {\n        return throwError(new Error('marked(): The async option was set to true by an extension. Remove async: false from the parse options object to return a Promise.'));\n      }\n\n      // throw error in case of non string input\n      if (typeof src === 'undefined' || src === null) {\n        return throwError(new Error('marked(): input parameter is undefined or null'));\n      }\n      if (typeof src !== 'string') {\n        return throwError(new Error('marked(): input parameter is of type '\n          + Object.prototype.toString.call(src) + ', string expected'));\n      }\n\n      if (opt.hooks) {\n        opt.hooks.options = opt;\n        opt.hooks.block = blockType;\n      }\n\n      const lexer = opt.hooks ? opt.hooks.provideLexer() : (blockType ? _Lexer.lex : _Lexer.lexInline);\n      const parser = opt.hooks ? opt.hooks.provideParser() : (blockType ? _Parser.parse : _Parser.parseInline);\n\n      if (opt.async) {\n        return Promise.resolve(opt.hooks ? opt.hooks.preprocess(src) : src)\n          .then(src => lexer(src, opt))\n          .then(tokens => opt.hooks ? opt.hooks.processAllTokens(tokens) : tokens)\n          .then(tokens => opt.walkTokens ? Promise.all(this.walkTokens(tokens, opt.walkTokens)).then(() => tokens) : tokens)\n          .then(tokens => parser(tokens, opt))\n          .then(html => opt.hooks ? opt.hooks.postprocess(html) : html)\n          .catch(throwError);\n      }\n\n      try {\n        if (opt.hooks) {\n          src = opt.hooks.preprocess(src) as string;\n        }\n        let tokens = lexer(src, opt);\n        if (opt.hooks) {\n          tokens = opt.hooks.processAllTokens(tokens);\n        }\n        if (opt.walkTokens) {\n          this.walkTokens(tokens, opt.walkTokens);\n        }\n        let html = parser(tokens, opt);\n        if (opt.hooks) {\n          html = opt.hooks.postprocess(html);\n        }\n        return html;\n      } catch(e) {\n        return throwError(e as Error);\n      }\n    };\n\n    return parse;\n  }\n\n  private onError(silent: boolean, async: boolean) {\n    return (e: Error): string | Promise<string> => {\n      e.message += '\\nPlease report this to https://github.com/markedjs/marked.';\n\n      if (silent) {\n        const msg = '<p>An error occurred:</p><pre>'\n          + escape(e.message + '', true)\n          + '</pre>';\n        if (async) {\n          return Promise.resolve(msg);\n        }\n        return msg;\n      }\n\n      if (async) {\n        return Promise.reject(e);\n      }\n      throw e;\n    };\n  }\n}\n","import { _Lexer } from './Lexer.ts';\nimport { _Parser } from './Parser.ts';\nimport { _Tokenizer } from './Tokenizer.ts';\nimport { _Renderer } from './Renderer.ts';\nimport { _TextRenderer } from './TextRenderer.ts';\nimport { _Hooks } from './Hooks.ts';\nimport { Marked } from './Instance.ts';\nimport {\n  _getDefaults,\n  changeDefaults,\n  _defaults,\n} from './defaults.ts';\nimport type { MarkedExtension, MarkedOptions } from './MarkedOptions.ts';\nimport type { Token, TokensList } from './Tokens.ts';\nimport type { MaybePromise } from './Instance.ts';\n\nconst markedInstance = new Marked();\n\n/**\n * Compiles markdown to HTML asynchronously.\n *\n * @param src String of markdown source to be compiled\n * @param options Hash of options, having async: true\n * @return Promise of string of compiled HTML\n */\nexport function marked(src: string, options: MarkedOptions & { async: true }): Promise<string>;\n\n/**\n * Compiles markdown to HTML.\n *\n * @param src String of markdown source to be compiled\n * @param options Optional hash of options\n * @return String of compiled HTML. Will be a Promise of string if async is set to true by any extensions.\n */\nexport function marked(src: string, options: MarkedOptions & { async: false }): string;\nexport function marked(src: string, options: MarkedOptions & { async: true }): Promise<string>;\nexport function marked(src: string, options?: MarkedOptions | null): string | Promise<string>;\nexport function marked(src: string, opt?: MarkedOptions | null): string | Promise<string> {\n  return markedInstance.parse(src, opt);\n}\n\n/**\n * Sets the default options.\n *\n * @param options Hash of options\n */\nmarked.options =\nmarked.setOptions = function(options: MarkedOptions) {\n  markedInstance.setOptions(options);\n  marked.defaults = markedInstance.defaults;\n  changeDefaults(marked.defaults);\n  return marked;\n};\n\n/**\n * Gets the original marked default options.\n */\nmarked.getDefaults = _getDefaults;\n\nmarked.defaults = _defaults;\n\n/**\n * Use Extension\n */\n\nmarked.use = function(...args: MarkedExtension[]) {\n  markedInstance.use(...args);\n  marked.defaults = markedInstance.defaults;\n  changeDefaults(marked.defaults);\n  return marked;\n};\n\n/**\n * Run callback for every token\n */\n\nmarked.walkTokens = function(tokens: Token[] | TokensList, callback: (token: Token) => MaybePromise | MaybePromise[]) {\n  return markedInstance.walkTokens(tokens, callback);\n};\n\n/**\n * Compiles markdown to HTML without enclosing `p` tag.\n *\n * @param src String of markdown source to be compiled\n * @param options Hash of options\n * @return String of compiled HTML\n */\nmarked.parseInline = markedInstance.parseInline;\n\n/**\n * Expose\n */\nmarked.Parser = _Parser;\nmarked.parser = _Parser.parse;\nmarked.Renderer = _Renderer;\nmarked.TextRenderer = _TextRenderer;\nmarked.Lexer = _Lexer;\nmarked.lexer = _Lexer.lex;\nmarked.Tokenizer = _Tokenizer;\nmarked.Hooks = _Hooks;\nmarked.parse = marked;\n\nexport const options = marked.options;\nexport const setOptions = marked.setOptions;\nexport const use = marked.use;\nexport const walkTokens = marked.walkTokens;\nexport const parseInline = marked.parseInline;\nexport const parse = marked;\nexport const parser = _Parser.parse;\nexport const lexer = _Lexer.lex;\nexport { _defaults as defaults, _getDefaults as getDefaults } from './defaults.ts';\nexport { _Lexer as Lexer } from './Lexer.ts';\nexport { _Parser as Parser } from './Parser.ts';\nexport { _Tokenizer as Tokenizer } from './Tokenizer.ts';\nexport { _Renderer as Renderer } from './Renderer.ts';\nexport { _TextRenderer as TextRenderer } from './TextRenderer.ts';\nexport { _Hooks as Hooks } from './Hooks.ts';\nexport { Marked } from './Instance.ts';\nexport type * from './MarkedOptions.ts';\nexport type * from './Tokens.ts';\n"],"names":["module","exports","a","n","TypeError","__esModule","toPropertyKey","require","_defineProperties","e","r","t","length","o","enumerable","configurable","writable","Object","defineProperty","key","prototype","value","_extends","assign","bind","arguments","hasOwnProperty","call","apply","_typeof","Symbol","toPrimitive","i","String","Number","iterator","constructor","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","undefined","__webpack_modules__","d","definition","get","obj","prop","L","async","breaks","extensions","gfm","hooks","pedantic","renderer","silent","tokenizer","walkTokens","O","H","l","E","exec","h","source","replace","s","m","caret","getRegex","RegExp","codeRemoveIndent","outputLinkReplace","indentCodeCompensation","beginningSpace","endingHash","startingSpaceChar","endingSpaceChar","nonSpaceChar","newLineCharGlobal","tabCharGlobal","multipleSpaceGlobal","blankLine","doubleBlankLine","blockquoteStart","blockquoteSetextReplace","blockquoteSetextReplace2","listReplaceTabs","listReplaceNesting","listIsTask","listReplaceTask","anyLine","hrefBrackets","tableDelimiter","tableAlignChars","tableRowBlankLine","tableAlignRight","tableAlignCenter","tableAlignLeft","startATag","endATag","startPreScriptTag","endPreScriptTag","startAngleBracket","endAngleBracket","pedanticHrefTitle","unicodeAlphaNumeric","escapeTest","escapeReplace","escapeTestNoEncode","escapeReplaceNoEncode","unescapeTest","percentDecode","findPipe","splitPipe","slashPipe","carriageReturn","spaceLine","notSpaceStart","endingNewline","listItemRegex","nextBulletRegex","Math","min","hrRegex","fencesBeginRegex","headingBeginRegex","htmlBeginRegex","C","j","se","ie","Te","F","Q","ye","Pe","v","U","Se","oe","K","blockquote","code","def","fences","heading","hr","html","lheading","list","newline","paragraph","table","text","re","_e","Le","ae","D","W","le","Ee","ue","pe","qe","ve","ce","De","Ze","Ge","He","Ne","je","Fe","q","Qe","he","de","X","_backpedal","anyPunctuation","autolink","blockSkip","br","del","emStrongLDelim","emStrongRDelimAst","emStrongRDelimUnd","escape","link","nolink","punctuation","reflink","reflinkSearch","tag","url","Ke","N","We","I","normal","M","Xe","ke","w","test","J","encodeURI","V","_n$at","u","split","trim","shift","at","pop","splice","push","z","charAt","slice","fe","href","title","other","state","inLink","type","raw","tokens","inlineTokens","y","_createClass","_classCallCheck","_defineProperty","this","options","rules","block","codeBlockStyle","match","map","join","Je","lang","inline","depth","lexer","p","c","f","top","blockTokens","k","x","g","T","substring","ordered","start","loose","items","Z","repeat","trimStart","search","ee","te","ne","me","A","G","Y","task","checked","trimEnd","filter","some","pre","toLowerCase","_t$","header","align","rows","inRawBlock","indexOf","ge","lastIndex","index","_this$rules$inline$_b","_this$rules$inline$_b2","escaped","b","links","create","inlineQueue","src","_this$options$extensi","_this$options$extensi2","space","endsWith","startBlock","forEach","charCodeAt","console","error","Error","keys","includes","lastIndexOf","_this$options$extensi3","_this$options$extensi4","emStrong","codespan","startInline","inlineText","lex","P","_ref","_match","_ref2","parser","parse","_ref3","_ref4","parseInline","listitem","_e$tokens$","checkbox","unshift","_ref5","_ref6","tablecell","tablerow","_ref7","_ref8","_ref9","_ref0","_ref1","_ref10","_ref11","textRenderer","S","_ref12","_ref13","_ref14","_ref15","_ref16","_ref17","_ref18","_ref19","R","_this$options$extensi5","renderers","_this$options$extensi6","image","strong","em","$","_Class3","lexInline","Set","B","setOptions","parseMarkdown","use","concat","_this$defaults$extens","defaults","childTokens","flat","_len","Array","_key","name","_len2","_key2","level","_len3","_key3","_len4","_key4","passThroughHooks","has","Promise","resolve","then","_len5","_key5","onError","toString","provideLexer","provideParser","preprocess","processAllTokens","all","postprocess","catch","message","reject","_","getDefaults","Parser","Renderer","TextRenderer","Lexer","Tokenizer","Hooks","Dt","Zt","Gt","Ht","Nt","jt","Ft","Qt"]}