quite a big commit

52 files changed, 0 insertions, 6054 deletions

diff --git a/packages/markdown-it-14.1.0/lib/common/html_blocks.mjs b/packages/markdown-it-14.1.0/lib/common/html_blocks.mjs
deleted file mode 100644
index 1e27a7f..0000000
--- a/packages/markdown-it-14.1.0/lib/common/html_blocks.mjs
+++ /dev/null
@@ -1,67 +0,0 @@
-// List of valid html blocks names, according to commonmark spec
-// https://spec.commonmark.org/0.30/#html-blocks
-
-export default [
-  'address',
-  'article',
-  'aside',
-  'base',
-  'basefont',
-  'blockquote',
-  'body',
-  'caption',
-  'center',
-  'col',
-  'colgroup',
-  'dd',
-  'details',
-  'dialog',
-  'dir',
-  'div',
-  'dl',
-  'dt',
-  'fieldset',
-  'figcaption',
-  'figure',
-  'footer',
-  'form',
-  'frame',
-  'frameset',
-  'h1',
-  'h2',
-  'h3',
-  'h4',
-  'h5',
-  'h6',
-  'head',
-  'header',
-  'hr',
-  'html',
-  'iframe',
-  'legend',
-  'li',
-  'link',
-  'main',
-  'menu',
-  'menuitem',
-  'nav',
-  'noframes',
-  'ol',
-  'optgroup',
-  'option',
-  'p',
-  'param',
-  'search',
-  'section',
-  'summary',
-  'table',
-  'tbody',
-  'td',
-  'tfoot',
-  'th',
-  'thead',
-  'title',
-  'tr',
-  'track',
-  'ul'
-]
diff --git a/packages/markdown-it-14.1.0/lib/common/html_re.mjs b/packages/markdown-it-14.1.0/lib/common/html_re.mjs
deleted file mode 100644
index ccfbf87..0000000
--- a/packages/markdown-it-14.1.0/lib/common/html_re.mjs
+++ /dev/null
@@ -1,25 +0,0 @@
-// Regexps to match html elements
-
-const attr_name     = '[a-zA-Z_:][a-zA-Z0-9:._-]*'
-
-const unquoted      = '[^"\'=<>`\\x00-\\x20]+'
-const single_quoted = "'[^']*'"
-const double_quoted = '"[^"]*"'
-
-const attr_value  = '(?:' + unquoted + '|' + single_quoted + '|' + double_quoted + ')'
-
-const attribute   = '(?:\\s+' + attr_name + '(?:\\s*=\\s*' + attr_value + ')?)'
-
-const open_tag    = '<[A-Za-z][A-Za-z0-9\\-]*' + attribute + '*\\s*\\/?>'
-
-const close_tag   = '<\\/[A-Za-z][A-Za-z0-9\\-]*\\s*>'
-const comment     = '<!---?>|<!--(?:[^-]|-[^-]|--[^>])*-->'
-const processing  = '<[?][\\s\\S]*?[?]>'
-const declaration = '<![A-Za-z][^>]*>'
-const cdata       = '<!\\[CDATA\\[[\\s\\S]*?\\]\\]>'
-
-const HTML_TAG_RE = new RegExp('^(?:' + open_tag + '|' + close_tag + '|' + comment +
-                        '|' + processing + '|' + declaration + '|' + cdata + ')')
-const HTML_OPEN_CLOSE_TAG_RE = new RegExp('^(?:' + open_tag + '|' + close_tag + ')')
-
-export { HTML_TAG_RE, HTML_OPEN_CLOSE_TAG_RE }
diff --git a/packages/markdown-it-14.1.0/lib/common/utils.mjs b/packages/markdown-it-14.1.0/lib/common/utils.mjs
deleted file mode 100644
index b78c9b0..0000000
--- a/packages/markdown-it-14.1.0/lib/common/utils.mjs
+++ /dev/null
@@ -1,304 +0,0 @@
-// Utilities
-//
-
-import * as mdurl from 'mdurl'
-import * as ucmicro from 'uc.micro'
-import { decodeHTML } from 'entities'
-
-function _class (obj) { return Object.prototype.toString.call(obj) }
-
-function isString (obj) { return _class(obj) === '[object String]' }
-
-const _hasOwnProperty = Object.prototype.hasOwnProperty
-
-function has (object, key) {
-  return _hasOwnProperty.call(object, key)
-}
-
-// Merge objects
-//
-function assign (obj /* from1, from2, from3, ... */) {
-  const sources = Array.prototype.slice.call(arguments, 1)
-
-  sources.forEach(function (source) {
-    if (!source) { return }
-
-    if (typeof source !== 'object') {
-      throw new TypeError(source + 'must be object')
-    }
-
-    Object.keys(source).forEach(function (key) {
-      obj[key] = source[key]
-    })
-  })
-
-  return obj
-}
-
-// Remove element from array and put another array at those position.
-// Useful for some operations with tokens
-function arrayReplaceAt (src, pos, newElements) {
-  return [].concat(src.slice(0, pos), newElements, src.slice(pos + 1))
-}
-
-function isValidEntityCode (c) {
-  /* eslint no-bitwise:0 */
-  // broken sequence
-  if (c >= 0xD800 && c <= 0xDFFF) { return false }
-  // never used
-  if (c >= 0xFDD0 && c <= 0xFDEF) { return false }
-  if ((c & 0xFFFF) === 0xFFFF || (c & 0xFFFF) === 0xFFFE) { return false }
-  // control codes
-  if (c >= 0x00 && c <= 0x08) { return false }
-  if (c === 0x0B) { return false }
-  if (c >= 0x0E && c <= 0x1F) { return false }
-  if (c >= 0x7F && c <= 0x9F) { return false }
-  // out of range
-  if (c > 0x10FFFF) { return false }
-  return true
-}
-
-function fromCodePoint (c) {
-  /* eslint no-bitwise:0 */
-  if (c > 0xffff) {
-    c -= 0x10000
-    const surrogate1 = 0xd800 + (c >> 10)
-    const surrogate2 = 0xdc00 + (c & 0x3ff)
-
-    return String.fromCharCode(surrogate1, surrogate2)
-  }
-  return String.fromCharCode(c)
-}
-
-const UNESCAPE_MD_RE  = /\\([!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~])/g
-const ENTITY_RE       = /&([a-z#][a-z0-9]{1,31});/gi
-const UNESCAPE_ALL_RE = new RegExp(UNESCAPE_MD_RE.source + '|' + ENTITY_RE.source, 'gi')
-
-const DIGITAL_ENTITY_TEST_RE = /^#((?:x[a-f0-9]{1,8}|[0-9]{1,8}))$/i
-
-function replaceEntityPattern (match, name) {
-  if (name.charCodeAt(0) === 0x23/* # */ && DIGITAL_ENTITY_TEST_RE.test(name)) {
-    const code = name[1].toLowerCase() === 'x'
-      ? parseInt(name.slice(2), 16)
-      : parseInt(name.slice(1), 10)
-
-    if (isValidEntityCode(code)) {
-      return fromCodePoint(code)
-    }
-
-    return match
-  }
-
-  const decoded = decodeHTML(match)
-  if (decoded !== match) {
-    return decoded
-  }
-
-  return match
-}
-
-/* function replaceEntities(str) {
-  if (str.indexOf('&') < 0) { return str; }
-
-  return str.replace(ENTITY_RE, replaceEntityPattern);
-} */
-
-function unescapeMd (str) {
-  if (str.indexOf('\\') < 0) { return str }
-  return str.replace(UNESCAPE_MD_RE, '$1')
-}
-
-function unescapeAll (str) {
-  if (str.indexOf('\\') < 0 && str.indexOf('&') < 0) { return str }
-
-  return str.replace(UNESCAPE_ALL_RE, function (match, escaped, entity) {
-    if (escaped) { return escaped }
-    return replaceEntityPattern(match, entity)
-  })
-}
-
-const HTML_ESCAPE_TEST_RE = /[&<>"]/
-const HTML_ESCAPE_REPLACE_RE = /[&<>"]/g
-const HTML_REPLACEMENTS = {
-  '&': '&amp;',
-  '<': '&lt;',
-  '>': '&gt;',
-  '"': '&quot;'
-}
-
-function replaceUnsafeChar (ch) {
-  return HTML_REPLACEMENTS[ch]
-}
-
-function escapeHtml (str) {
-  if (HTML_ESCAPE_TEST_RE.test(str)) {
-    return str.replace(HTML_ESCAPE_REPLACE_RE, replaceUnsafeChar)
-  }
-  return str
-}
-
-const REGEXP_ESCAPE_RE = /[.?*+^$[\]\\(){}|-]/g
-
-function escapeRE (str) {
-  return str.replace(REGEXP_ESCAPE_RE, '\\$&')
-}
-
-function isSpace (code) {
-  switch (code) {
-    case 0x09:
-    case 0x20:
-      return true
-  }
-  return false
-}
-
-// Zs (unicode class) || [\t\f\v\r\n]
-function isWhiteSpace (code) {
-  if (code >= 0x2000 && code <= 0x200A) { return true }
-  switch (code) {
-    case 0x09: // \t
-    case 0x0A: // \n
-    case 0x0B: // \v
-    case 0x0C: // \f
-    case 0x0D: // \r
-    case 0x20:
-    case 0xA0:
-    case 0x1680:
-    case 0x202F:
-    case 0x205F:
-    case 0x3000:
-      return true
-  }
-  return false
-}
-
-/* eslint-disable max-len */
-
-// Currently without astral characters support.
-function isPunctChar (ch) {
-  return ucmicro.P.test(ch) || ucmicro.S.test(ch)
-}
-
-// Markdown ASCII punctuation characters.
-//
-// !, ", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, @, [, \, ], ^, _, `, {, |, }, or ~
-// http://spec.commonmark.org/0.15/#ascii-punctuation-character
-//
-// Don't confuse with unicode punctuation !!! It lacks some chars in ascii range.
-//
-function isMdAsciiPunct (ch) {
-  switch (ch) {
-    case 0x21/* ! */:
-    case 0x22/* " */:
-    case 0x23/* # */:
-    case 0x24/* $ */:
-    case 0x25/* % */:
-    case 0x26/* & */:
-    case 0x27/* ' */:
-    case 0x28/* ( */:
-    case 0x29/* ) */:
-    case 0x2A/* * */:
-    case 0x2B/* + */:
-    case 0x2C/* , */:
-    case 0x2D/* - */:
-    case 0x2E/* . */:
-    case 0x2F/* / */:
-    case 0x3A/* : */:
-    case 0x3B/* ; */:
-    case 0x3C/* < */:
-    case 0x3D/* = */:
-    case 0x3E/* > */:
-    case 0x3F/* ? */:
-    case 0x40/* @ */:
-    case 0x5B/* [ */:
-    case 0x5C/* \ */:
-    case 0x5D/* ] */:
-    case 0x5E/* ^ */:
-    case 0x5F/* _ */:
-    case 0x60/* ` */:
-    case 0x7B/* { */:
-    case 0x7C/* | */:
-    case 0x7D/* } */:
-    case 0x7E/* ~ */:
-      return true
-    default:
-      return false
-  }
-}
-
-// Hepler to unify [reference labels].
-//
-function normalizeReference (str) {
-  // Trim and collapse whitespace
-  //
-  str = str.trim().replace(/\s+/g, ' ')
-
-  // In node v10 'ẞ'.toLowerCase() === 'Ṿ', which is presumed to be a bug
-  // fixed in v12 (couldn't find any details).
-  //
-  // So treat this one as a special case
-  // (remove this when node v10 is no longer supported).
-  //
-  if ('ẞ'.toLowerCase() === 'Ṿ') {
-    str = str.replace(/ẞ/g, 'ß')
-  }
-
-  // .toLowerCase().toUpperCase() should get rid of all differences
-  // between letter variants.
-  //
-  // Simple .toLowerCase() doesn't normalize 125 code points correctly,
-  // and .toUpperCase doesn't normalize 6 of them (list of exceptions:
-  // İ, ϴ, ẞ, Ω, K, Å - those are already uppercased, but have differently
-  // uppercased versions).
-  //
-  // Here's an example showing how it happens. Lets take greek letter omega:
-  // uppercase U+0398 (Θ), U+03f4 (ϴ) and lowercase U+03b8 (θ), U+03d1 (ϑ)
-  //
-  // Unicode entries:
-  // 0398;GREEK CAPITAL LETTER THETA;Lu;0;L;;;;;N;;;;03B8;
-  // 03B8;GREEK SMALL LETTER THETA;Ll;0;L;;;;;N;;;0398;;0398
-  // 03D1;GREEK THETA SYMBOL;Ll;0;L;<compat> 03B8;;;;N;GREEK SMALL LETTER SCRIPT THETA;;0398;;0398
-  // 03F4;GREEK CAPITAL THETA SYMBOL;Lu;0;L;<compat> 0398;;;;N;;;;03B8;
-  //
-  // Case-insensitive comparison should treat all of them as equivalent.
-  //
-  // But .toLowerCase() doesn't change ϑ (it's already lowercase),
-  // and .toUpperCase() doesn't change ϴ (already uppercase).
-  //
-  // Applying first lower then upper case normalizes any character:
-  // '\u0398\u03f4\u03b8\u03d1'.toLowerCase().toUpperCase() === '\u0398\u0398\u0398\u0398'
-  //
-  // Note: this is equivalent to unicode case folding; unicode normalization
-  // is a different step that is not required here.
-  //
-  // Final result should be uppercased, because it's later stored in an object
-  // (this avoid a conflict with Object.prototype members,
-  // most notably, `__proto__`)
-  //
-  return str.toLowerCase().toUpperCase()
-}
-
-// Re-export libraries commonly used in both markdown-it and its plugins,
-// so plugins won't have to depend on them explicitly, which reduces their
-// bundled size (e.g. a browser build).
-//
-const lib = { mdurl, ucmicro }
-
-export {
-  lib,
-  assign,
-  isString,
-  has,
-  unescapeMd,
-  unescapeAll,
-  isValidEntityCode,
-  fromCodePoint,
-  escapeHtml,
-  arrayReplaceAt,
-  isSpace,
-  isWhiteSpace,
-  isMdAsciiPunct,
-  isPunctChar,
-  escapeRE,
-  normalizeReference
-}
diff --git a/packages/markdown-it-14.1.0/lib/helpers/index.mjs b/packages/markdown-it-14.1.0/lib/helpers/index.mjs
deleted file mode 100644
index 7ea30af..0000000
--- a/packages/markdown-it-14.1.0/lib/helpers/index.mjs
+++ /dev/null
@@ -1,11 +0,0 @@
-// Just a shortcut for bulk export
-
-import parseLinkLabel from './parse_link_label.mjs'
-import parseLinkDestination from './parse_link_destination.mjs'
-import parseLinkTitle from './parse_link_title.mjs'
-
-export {
-  parseLinkLabel,
-  parseLinkDestination,
-  parseLinkTitle
-}
diff --git a/packages/markdown-it-14.1.0/lib/helpers/parse_link_destination.mjs b/packages/markdown-it-14.1.0/lib/helpers/parse_link_destination.mjs
deleted file mode 100644
index 6a723a6..0000000
--- a/packages/markdown-it-14.1.0/lib/helpers/parse_link_destination.mjs
+++ /dev/null
@@ -1,77 +0,0 @@
-// Parse link destination
-//
-
-import { unescapeAll } from '../common/utils.mjs'
-
-export default function parseLinkDestination (str, start, max) {
-  let code
-  let pos = start
-
-  const result = {
-    ok: false,
-    pos: 0,
-    str: ''
-  }
-
-  if (str.charCodeAt(pos) === 0x3C /* < */) {
-    pos++
-    while (pos < max) {
-      code = str.charCodeAt(pos)
-      if (code === 0x0A /* \n */) { return result }
-      if (code === 0x3C /* < */) { return result }
-      if (code === 0x3E /* > */) {
-        result.pos = pos + 1
-        result.str = unescapeAll(str.slice(start + 1, pos))
-        result.ok = true
-        return result
-      }
-      if (code === 0x5C /* \ */ && pos + 1 < max) {
-        pos += 2
-        continue
-      }
-
-      pos++
-    }
-
-    // no closing '>'
-    return result
-  }
-
-  // this should be ... } else { ... branch
-
-  let level = 0
-  while (pos < max) {
-    code = str.charCodeAt(pos)
-
-    if (code === 0x20) { break }
-
-    // ascii control characters
-    if (code < 0x20 || code === 0x7F) { break }
-
-    if (code === 0x5C /* \ */ && pos + 1 < max) {
-      if (str.charCodeAt(pos + 1) === 0x20) { break }
-      pos += 2
-      continue
-    }
-
-    if (code === 0x28 /* ( */) {
-      level++
-      if (level > 32) { return result }
-    }
-
-    if (code === 0x29 /* ) */) {
-      if (level === 0) { break }
-      level--
-    }
-
-    pos++
-  }
-
-  if (start === pos) { return result }
-  if (level !== 0) { return result }
-
-  result.str = unescapeAll(str.slice(start, pos))
-  result.pos = pos
-  result.ok = true
-  return result
-}
diff --git a/packages/markdown-it-14.1.0/lib/helpers/parse_link_label.mjs b/packages/markdown-it-14.1.0/lib/helpers/parse_link_label.mjs
deleted file mode 100644
index f1a53fa..0000000
--- a/packages/markdown-it-14.1.0/lib/helpers/parse_link_label.mjs
+++ /dev/null
@@ -1,49 +0,0 @@
-// Parse link label
-//
-// this function assumes that first character ("[") already matches;
-// returns the end of the label
-//
-
-export default function parseLinkLabel (state, start, disableNested) {
-  let level, found, marker, prevPos
-
-  const max = state.posMax
-  const oldPos = state.pos
-
-  state.pos = start + 1
-  level = 1
-
-  while (state.pos < max) {
-    marker = state.src.charCodeAt(state.pos)
-    if (marker === 0x5D /* ] */) {
-      level--
-      if (level === 0) {
-        found = true
-        break
-      }
-    }
-
-    prevPos = state.pos
-    state.md.inline.skipToken(state)
-    if (marker === 0x5B /* [ */) {
-      if (prevPos === state.pos - 1) {
-        // increase level if we find text `[`, which is not a part of any token
-        level++
-      } else if (disableNested) {
-        state.pos = oldPos
-        return -1
-      }
-    }
-  }
-
-  let labelEnd = -1
-
-  if (found) {
-    labelEnd = state.pos
-  }
-
-  // restore old state
-  state.pos = oldPos
-
-  return labelEnd
-}
diff --git a/packages/markdown-it-14.1.0/lib/helpers/parse_link_title.mjs b/packages/markdown-it-14.1.0/lib/helpers/parse_link_title.mjs
deleted file mode 100644
index 4605647..0000000
--- a/packages/markdown-it-14.1.0/lib/helpers/parse_link_title.mjs
+++ /dev/null
@@ -1,66 +0,0 @@
-// Parse link title
-//
-
-import { unescapeAll } from '../common/utils.mjs'
-
-// Parse link title within `str` in [start, max] range,
-// or continue previous parsing if `prev_state` is defined (equal to result of last execution).
-//
-export default function parseLinkTitle (str, start, max, prev_state) {
-  let code
-  let pos = start
-
-  const state = {
-    // if `true`, this is a valid link title
-    ok: false,
-    // if `true`, this link can be continued on the next line
-    can_continue: false,
-    // if `ok`, it's the position of the first character after the closing marker
-    pos: 0,
-    // if `ok`, it's the unescaped title
-    str: '',
-    // expected closing marker character code
-    marker: 0
-  }
-
-  if (prev_state) {
-    // this is a continuation of a previous parseLinkTitle call on the next line,
-    // used in reference links only
-    state.str = prev_state.str
-    state.marker = prev_state.marker
-  } else {
-    if (pos >= max) { return state }
-
-    let marker = str.charCodeAt(pos)
-    if (marker !== 0x22 /* " */ && marker !== 0x27 /* ' */ && marker !== 0x28 /* ( */) { return state }
-
-    start++
-    pos++
-
-    // if opening marker is "(", switch it to closing marker ")"
-    if (marker === 0x28) { marker = 0x29 }
-
-    state.marker = marker
-  }
-
-  while (pos < max) {
-    code = str.charCodeAt(pos)
-    if (code === state.marker) {
-      state.pos = pos + 1
-      state.str += unescapeAll(str.slice(start, pos))
-      state.ok = true
-      return state
-    } else if (code === 0x28 /* ( */ && state.marker === 0x29 /* ) */) {
-      return state
-    } else if (code === 0x5C /* \ */ && pos + 1 < max) {
-      pos++
-    }
-
-    pos++
-  }
-
-  // no closing marker found, but this link title may continue on the next line (for references)
-  state.can_continue = true
-  state.str += unescapeAll(str.slice(start, pos))
-  return state
-}
diff --git a/packages/markdown-it-14.1.0/lib/index.mjs b/packages/markdown-it-14.1.0/lib/index.mjs
deleted file mode 100644
index 8a8af9d..0000000
--- a/packages/markdown-it-14.1.0/lib/index.mjs
+++ /dev/null
@@ -1,565 +0,0 @@
-// Main parser class
-
-import * as utils from './common/utils.mjs'
-import * as helpers from './helpers/index.mjs'
-import Renderer from './renderer.mjs'
-import ParserCore from './parser_core.mjs'
-import ParserBlock from './parser_block.mjs'
-import ParserInline from './parser_inline.mjs'
-import LinkifyIt from 'linkify-it'
-import * as mdurl from 'mdurl'
-import punycode from 'punycode.js'
-
-import cfg_default from './presets/default.mjs'
-import cfg_zero from './presets/zero.mjs'
-import cfg_commonmark from './presets/commonmark.mjs'
-
-const config = {
-  default: cfg_default,
-  zero: cfg_zero,
-  commonmark: cfg_commonmark
-}
-
-//
-// This validator can prohibit more than really needed to prevent XSS. It's a
-// tradeoff to keep code simple and to be secure by default.
-//
-// If you need different setup - override validator method as you wish. Or
-// replace it with dummy function and use external sanitizer.
-//
-
-const BAD_PROTO_RE = /^(vbscript|javascript|file|data):/
-const GOOD_DATA_RE = /^data:image\/(gif|png|jpeg|webp);/
-
-function validateLink (url) {
-  // url should be normalized at this point, and existing entities are decoded
-  const str = url.trim().toLowerCase()
-
-  return BAD_PROTO_RE.test(str) ? GOOD_DATA_RE.test(str) : true
-}
-
-const RECODE_HOSTNAME_FOR = ['http:', 'https:', 'mailto:']
-
-function normalizeLink (url) {
-  const parsed = mdurl.parse(url, true)
-
-  if (parsed.hostname) {
-    // Encode hostnames in urls like:
-    // `http://host/`, `https://host/`, `mailto:user@host`, `//host/`
-    //
-    // We don't encode unknown schemas, because it's likely that we encode
-    // something we shouldn't (e.g. `skype:name` treated as `skype:host`)
-    //
-    if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) {
-      try {
-        parsed.hostname = punycode.toASCII(parsed.hostname)
-      } catch (er) { /**/ }
-    }
-  }
-
-  return mdurl.encode(mdurl.format(parsed))
-}
-
-function normalizeLinkText (url) {
-  const parsed = mdurl.parse(url, true)
-
-  if (parsed.hostname) {
-    // Encode hostnames in urls like:
-    // `http://host/`, `https://host/`, `mailto:user@host`, `//host/`
-    //
-    // We don't encode unknown schemas, because it's likely that we encode
-    // something we shouldn't (e.g. `skype:name` treated as `skype:host`)
-    //
-    if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) {
-      try {
-        parsed.hostname = punycode.toUnicode(parsed.hostname)
-      } catch (er) { /**/ }
-    }
-  }
-
-  // add '%' to exclude list because of https://github.com/markdown-it/markdown-it/issues/720
-  return mdurl.decode(mdurl.format(parsed), mdurl.decode.defaultChars + '%')
-}
-
-/**
- * class MarkdownIt
- *
- * Main parser/renderer class.
- *
- * ##### Usage
- *
- * ```javascript
- * // node.js, "classic" way:
- * var MarkdownIt = require('markdown-it'),
- *     md = new MarkdownIt();
- * var result = md.render('# markdown-it rulezz!');
- *
- * // node.js, the same, but with sugar:
- * var md = require('markdown-it')();
- * var result = md.render('# markdown-it rulezz!');
- *
- * // browser without AMD, added to "window" on script load
- * // Note, there are no dash.
- * var md = window.markdownit();
- * var result = md.render('# markdown-it rulezz!');
- * ```
- *
- * Single line rendering, without paragraph wrap:
- *
- * ```javascript
- * var md = require('markdown-it')();
- * var result = md.renderInline('__markdown-it__ rulezz!');
- * ```
- **/
-
-/**
- * new MarkdownIt([presetName, options])
- * - presetName (String): optional, `commonmark` / `zero`
- * - options (Object)
- *
- * Creates parser instanse with given config. Can be called without `new`.
- *
- * ##### presetName
- *
- * MarkdownIt provides named presets as a convenience to quickly
- * enable/disable active syntax rules and options for common use cases.
- *
- * - ["commonmark"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/commonmark.mjs) -
- *   configures parser to strict [CommonMark](http://commonmark.org/) mode.
- * - [default](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/default.mjs) -
- *   similar to GFM, used when no preset name given. Enables all available rules,
- *   but still without html, typographer & autolinker.
- * - ["zero"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/zero.mjs) -
- *   all rules disabled. Useful to quickly setup your config via `.enable()`.
- *   For example, when you need only `bold` and `italic` markup and nothing else.
- *
- * ##### options:
- *
- * - __html__ - `false`. Set `true` to enable HTML tags in source. Be careful!
- *   That's not safe! You may need external sanitizer to protect output from XSS.
- *   It's better to extend features via plugins, instead of enabling HTML.
- * - __xhtmlOut__ - `false`. Set `true` to add '/' when closing single tags
- *   (`<br />`). This is needed only for full CommonMark compatibility. In real
- *   world you will need HTML output.
- * - __breaks__ - `false`. Set `true` to convert `\n` in paragraphs into `<br>`.
- * - __langPrefix__ - `language-`. CSS language class prefix for fenced blocks.
- *   Can be useful for external highlighters.
- * - __linkify__ - `false`. Set `true` to autoconvert URL-like text to links.
- * - __typographer__  - `false`. Set `true` to enable [some language-neutral
- *   replacement](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/replacements.mjs) +
- *   quotes beautification (smartquotes).
- * - __quotes__ - `“”‘’`, String or Array. Double + single quotes replacement
- *   pairs, when typographer enabled and smartquotes on. For example, you can
- *   use `'«»„“'` for Russian, `'„“‚‘'` for German, and
- *   `['«\xA0', '\xA0»', '‹\xA0', '\xA0›']` for French (including nbsp).
- * - __highlight__ - `null`. Highlighter function for fenced code blocks.
- *   Highlighter `function (str, lang)` should return escaped HTML. It can also
- *   return empty string if the source was not changed and should be escaped
- *   externaly. If result starts with <pre... internal wrapper is skipped.
- *
- * ##### Example
- *
- * ```javascript
- * // commonmark mode
- * var md = require('markdown-it')('commonmark');
- *
- * // default mode
- * var md = require('markdown-it')();
- *
- * // enable everything
- * var md = require('markdown-it')({
- *   html: true,
- *   linkify: true,
- *   typographer: true
- * });
- * ```
- *
- * ##### Syntax highlighting
- *
- * ```js
- * var hljs = require('highlight.js') // https://highlightjs.org/
- *
- * var md = require('markdown-it')({
- *   highlight: function (str, lang) {
- *     if (lang && hljs.getLanguage(lang)) {
- *       try {
- *         return hljs.highlight(str, { language: lang, ignoreIllegals: true }).value;
- *       } catch (__) {}
- *     }
- *
- *     return ''; // use external default escaping
- *   }
- * });
- * ```
- *
- * Or with full wrapper override (if you need assign class to `<pre>` or `<code>`):
- *
- * ```javascript
- * var hljs = require('highlight.js') // https://highlightjs.org/
- *
- * // Actual default values
- * var md = require('markdown-it')({
- *   highlight: function (str, lang) {
- *     if (lang && hljs.getLanguage(lang)) {
- *       try {
- *         return '<pre><code class="hljs">' +
- *                hljs.highlight(str, { language: lang, ignoreIllegals: true }).value +
- *                '</code></pre>';
- *       } catch (__) {}
- *     }
- *
- *     return '<pre><code class="hljs">' + md.utils.escapeHtml(str) + '</code></pre>';
- *   }
- * });
- * ```
- *
- **/
-function MarkdownIt (presetName, options) {
-  if (!(this instanceof MarkdownIt)) {
-    return new MarkdownIt(presetName, options)
-  }
-
-  if (!options) {
-    if (!utils.isString(presetName)) {
-      options = presetName || {}
-      presetName = 'default'
-    }
-  }
-
-  /**
-   * MarkdownIt#inline -> ParserInline
-   *
-   * Instance of [[ParserInline]]. You may need it to add new rules when
-   * writing plugins. For simple rules control use [[MarkdownIt.disable]] and
-   * [[MarkdownIt.enable]].
-   **/
-  this.inline = new ParserInline()
-
-  /**
-   * MarkdownIt#block -> ParserBlock
-   *
-   * Instance of [[ParserBlock]]. You may need it to add new rules when
-   * writing plugins. For simple rules control use [[MarkdownIt.disable]] and
-   * [[MarkdownIt.enable]].
-   **/
-  this.block = new ParserBlock()
-
-  /**
-   * MarkdownIt#core -> Core
-   *
-   * Instance of [[Core]] chain executor. You may need it to add new rules when
-   * writing plugins. For simple rules control use [[MarkdownIt.disable]] and
-   * [[MarkdownIt.enable]].
-   **/
-  this.core = new ParserCore()
-
-  /**
-   * MarkdownIt#renderer -> Renderer
-   *
-   * Instance of [[Renderer]]. Use it to modify output look. Or to add rendering
-   * rules for new token types, generated by plugins.
-   *
-   * ##### Example
-   *
-   * ```javascript
-   * var md = require('markdown-it')();
-   *
-   * function myToken(tokens, idx, options, env, self) {
-   *   //...
-   *   return result;
-   * };
-   *
-   * md.renderer.rules['my_token'] = myToken
-   * ```
-   *
-   * See [[Renderer]] docs and [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.mjs).
-   **/
-  this.renderer = new Renderer()
-
-  /**
-   * MarkdownIt#linkify -> LinkifyIt
-   *
-   * [linkify-it](https://github.com/markdown-it/linkify-it) instance.
-   * Used by [linkify](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/linkify.mjs)
-   * rule.
-   **/
-  this.linkify = new LinkifyIt()
-
-  /**
-   * MarkdownIt#validateLink(url) -> Boolean
-   *
-   * Link validation function. CommonMark allows too much in links. By default
-   * we disable `javascript:`, `vbscript:`, `file:` schemas, and almost all `data:...` schemas
-   * except some embedded image types.
-   *
-   * You can change this behaviour:
-   *
-   * ```javascript
-   * var md = require('markdown-it')();
-   * // enable everything
-   * md.validateLink = function () { return true; }
-   * ```
-   **/
-  this.validateLink = validateLink
-
-  /**
-   * MarkdownIt#normalizeLink(url) -> String
-   *
-   * Function used to encode link url to a machine-readable format,
-   * which includes url-encoding, punycode, etc.
-   **/
-  this.normalizeLink = normalizeLink
-
-  /**
-   * MarkdownIt#normalizeLinkText(url) -> String
-   *
-   * Function used to decode link url to a human-readable format`
-   **/
-  this.normalizeLinkText = normalizeLinkText
-
-  // Expose utils & helpers for easy acces from plugins
-
-  /**
-   * MarkdownIt#utils -> utils
-   *
-   * Assorted utility functions, useful to write plugins. See details
-   * [here](https://github.com/markdown-it/markdown-it/blob/master/lib/common/utils.mjs).
-   **/
-  this.utils = utils
-
-  /**
-   * MarkdownIt#helpers -> helpers
-   *
-   * Link components parser functions, useful to write plugins. See details
-   * [here](https://github.com/markdown-it/markdown-it/blob/master/lib/helpers).
-   **/
-  this.helpers = utils.assign({}, helpers)
-
-  this.options = {}
-  this.configure(presetName)
-
-  if (options) { this.set(options) }
-}
-
-/** chainable
- * MarkdownIt.set(options)
- *
- * Set parser options (in the same format as in constructor). Probably, you
- * will never need it, but you can change options after constructor call.
- *
- * ##### Example
- *
- * ```javascript
- * var md = require('markdown-it')()
- *             .set({ html: true, breaks: true })
- *             .set({ typographer, true });
- * ```
- *
- * __Note:__ To achieve the best possible performance, don't modify a
- * `markdown-it` instance options on the fly. If you need multiple configurations
- * it's best to create multiple instances and initialize each with separate
- * config.
- **/
-MarkdownIt.prototype.set = function (options) {
-  utils.assign(this.options, options)
-  return this
-}
-
-/** chainable, internal
- * MarkdownIt.configure(presets)
- *
- * Batch load of all options and compenent settings. This is internal method,
- * and you probably will not need it. But if you will - see available presets
- * and data structure [here](https://github.com/markdown-it/markdown-it/tree/master/lib/presets)
- *
- * We strongly recommend to use presets instead of direct config loads. That
- * will give better compatibility with next versions.
- **/
-MarkdownIt.prototype.configure = function (presets) {
-  const self = this
-
-  if (utils.isString(presets)) {
-    const presetName = presets
-    presets = config[presetName]
-    if (!presets) { throw new Error('Wrong `markdown-it` preset "' + presetName + '", check name') }
-  }
-
-  if (!presets) { throw new Error('Wrong `markdown-it` preset, can\'t be empty') }
-
-  if (presets.options) { self.set(presets.options) }
-
-  if (presets.components) {
-    Object.keys(presets.components).forEach(function (name) {
-      if (presets.components[name].rules) {
-        self[name].ruler.enableOnly(presets.components[name].rules)
-      }
-      if (presets.components[name].rules2) {
-        self[name].ruler2.enableOnly(presets.components[name].rules2)
-      }
-    })
-  }
-  return this
-}
-
-/** chainable
- * MarkdownIt.enable(list, ignoreInvalid)
- * - list (String|Array): rule name or list of rule names to enable
- * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.
- *
- * Enable list or rules. It will automatically find appropriate components,
- * containing rules with given names. If rule not found, and `ignoreInvalid`
- * not set - throws exception.
- *
- * ##### Example
- *
- * ```javascript
- * var md = require('markdown-it')()
- *             .enable(['sub', 'sup'])
- *             .disable('smartquotes');
- * ```
- **/
-MarkdownIt.prototype.enable = function (list, ignoreInvalid) {
-  let result = []
-
-  if (!Array.isArray(list)) { list = [list] }
-
-  ['core', 'block', 'inline'].forEach(function (chain) {
-    result = result.concat(this[chain].ruler.enable(list, true))
-  }, this)
-
-  result = result.concat(this.inline.ruler2.enable(list, true))
-
-  const missed = list.filter(function (name) { return result.indexOf(name) < 0 })
-
-  if (missed.length && !ignoreInvalid) {
-    throw new Error('MarkdownIt. Failed to enable unknown rule(s): ' + missed)
-  }
-
-  return this
-}
-
-/** chainable
- * MarkdownIt.disable(list, ignoreInvalid)
- * - list (String|Array): rule name or list of rule names to disable.
- * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.
- *
- * The same as [[MarkdownIt.enable]], but turn specified rules off.
- **/
-MarkdownIt.prototype.disable = function (list, ignoreInvalid) {
-  let result = []
-
-  if (!Array.isArray(list)) { list = [list] }
-
-  ['core', 'block', 'inline'].forEach(function (chain) {
-    result = result.concat(this[chain].ruler.disable(list, true))
-  }, this)
-
-  result = result.concat(this.inline.ruler2.disable(list, true))
-
-  const missed = list.filter(function (name) { return result.indexOf(name) < 0 })
-
-  if (missed.length && !ignoreInvalid) {
-    throw new Error('MarkdownIt. Failed to disable unknown rule(s): ' + missed)
-  }
-  return this
-}
-
-/** chainable
- * MarkdownIt.use(plugin, params)
- *
- * Load specified plugin with given params into current parser instance.
- * It's just a sugar to call `plugin(md, params)` with curring.
- *
- * ##### Example
- *
- * ```javascript
- * var iterator = require('markdown-it-for-inline');
- * var md = require('markdown-it')()
- *             .use(iterator, 'foo_replace', 'text', function (tokens, idx) {
- *               tokens[idx].content = tokens[idx].content.replace(/foo/g, 'bar');
- *             });
- * ```
- **/
-MarkdownIt.prototype.use = function (plugin /*, params, ... */) {
-  const args = [this].concat(Array.prototype.slice.call(arguments, 1))
-  plugin.apply(plugin, args)
-  return this
-}
-
-/** internal
- * MarkdownIt.parse(src, env) -> Array
- * - src (String): source string
- * - env (Object): environment sandbox
- *
- * Parse input string and return list of block tokens (special token type
- * "inline" will contain list of inline tokens). You should not call this
- * method directly, until you write custom renderer (for example, to produce
- * AST).
- *
- * `env` is used to pass data between "distributed" rules and return additional
- * metadata like reference info, needed for the renderer. It also can be used to
- * inject data in specific cases. Usually, you will be ok to pass `{}`,
- * and then pass updated object to renderer.
- **/
-MarkdownIt.prototype.parse = function (src, env) {
-  if (typeof src !== 'string') {
-    throw new Error('Input data should be a String')
-  }
-
-  const state = new this.core.State(src, this, env)
-
-  this.core.process(state)
-
-  return state.tokens
-}
-
-/**
- * MarkdownIt.render(src [, env]) -> String
- * - src (String): source string
- * - env (Object): environment sandbox
- *
- * Render markdown string into html. It does all magic for you :).
- *
- * `env` can be used to inject additional metadata (`{}` by default).
- * But you will not need it with high probability. See also comment
- * in [[MarkdownIt.parse]].
- **/
-MarkdownIt.prototype.render = function (src, env) {
-  env = env || {}
-
-  return this.renderer.render(this.parse(src, env), this.options, env)
-}
-
-/** internal
- * MarkdownIt.parseInline(src, env) -> Array
- * - src (String): source string
- * - env (Object): environment sandbox
- *
- * The same as [[MarkdownIt.parse]] but skip all block rules. It returns the
- * block tokens list with the single `inline` element, containing parsed inline
- * tokens in `children` property. Also updates `env` object.
- **/
-MarkdownIt.prototype.parseInline = function (src, env) {
-  const state = new this.core.State(src, this, env)
-
-  state.inlineMode = true
-  this.core.process(state)
-
-  return state.tokens
-}
-
-/**
- * MarkdownIt.renderInline(src [, env]) -> String
- * - src (String): source string
- * - env (Object): environment sandbox
- *
- * Similar to [[MarkdownIt.render]] but for single paragraph content. Result
- * will NOT be wrapped into `<p>` tags.
- **/
-MarkdownIt.prototype.renderInline = function (src, env) {
-  env = env || {}
-
-  return this.renderer.render(this.parseInline(src, env), this.options, env)
-}
-
-export default MarkdownIt
diff --git a/packages/markdown-it-14.1.0/lib/parser_block.mjs b/packages/markdown-it-14.1.0/lib/parser_block.mjs
deleted file mode 100644
index 486d68f..0000000
--- a/packages/markdown-it-14.1.0/lib/parser_block.mjs
+++ /dev/null
@@ -1,134 +0,0 @@
-/** internal
- * class ParserBlock
- *
- * Block-level tokenizer.
- **/
-
-import Ruler from './ruler.mjs'
-import StateBlock from './rules_block/state_block.mjs'
-
-import r_table from './rules_block/table.mjs'
-import r_code from './rules_block/code.mjs'
-import r_fence from './rules_block/fence.mjs'
-import r_blockquote from './rules_block/blockquote.mjs'
-import r_hr from './rules_block/hr.mjs'
-import r_list from './rules_block/list.mjs'
-import r_reference from './rules_block/reference.mjs'
-import r_html_block from './rules_block/html_block.mjs'
-import r_heading from './rules_block/heading.mjs'
-import r_lheading from './rules_block/lheading.mjs'
-import r_paragraph from './rules_block/paragraph.mjs'
-
-const _rules = [
-  // First 2 params - rule name & source. Secondary array - list of rules,
-  // which can be terminated by this one.
-  ['table',      r_table,      ['paragraph', 'reference']],
-  ['code',       r_code],
-  ['fence',      r_fence,      ['paragraph', 'reference', 'blockquote', 'list']],
-  ['blockquote', r_blockquote, ['paragraph', 'reference', 'blockquote', 'list']],
-  ['hr',         r_hr,         ['paragraph', 'reference', 'blockquote', 'list']],
-  ['list',       r_list,       ['paragraph', 'reference', 'blockquote']],
-  ['reference',  r_reference],
-  ['html_block', r_html_block, ['paragraph', 'reference', 'blockquote']],
-  ['heading',    r_heading,    ['paragraph', 'reference', 'blockquote']],
-  ['lheading',   r_lheading],
-  ['paragraph',  r_paragraph]
-]
-
-/**
- * new ParserBlock()
- **/
-function ParserBlock () {
-  /**
-   * ParserBlock#ruler -> Ruler
-   *
-   * [[Ruler]] instance. Keep configuration of block rules.
-   **/
-  this.ruler = new Ruler()
-
-  for (let i = 0; i < _rules.length; i++) {
-    this.ruler.push(_rules[i][0], _rules[i][1], { alt: (_rules[i][2] || []).slice() })
-  }
-}
-
-// Generate tokens for input range
-//
-ParserBlock.prototype.tokenize = function (state, startLine, endLine) {
-  const rules = this.ruler.getRules('')
-  const len = rules.length
-  const maxNesting = state.md.options.maxNesting
-  let line = startLine
-  let hasEmptyLines = false
-
-  while (line < endLine) {
-    state.line = line = state.skipEmptyLines(line)
-    if (line >= endLine) { break }
-
-    // Termination condition for nested calls.
-    // Nested calls currently used for blockquotes & lists
-    if (state.sCount[line] < state.blkIndent) { break }
-
-    // If nesting level exceeded - skip tail to the end. That's not ordinary
-    // situation and we should not care about content.
-    if (state.level >= maxNesting) {
-      state.line = endLine
-      break
-    }
-
-    // Try all possible rules.
-    // On success, rule should:
-    //
-    // - update `state.line`
-    // - update `state.tokens`
-    // - return true
-    const prevLine = state.line
-    let ok = false
-
-    for (let i = 0; i < len; i++) {
-      ok = rules[i](state, line, endLine, false)
-      if (ok) {
-        if (prevLine >= state.line) {
-          throw new Error("block rule didn't increment state.line")
-        }
-        break
-      }
-    }
-
-    // this can only happen if user disables paragraph rule
-    if (!ok) throw new Error('none of the block rules matched')
-
-    // set state.tight if we had an empty line before current tag
-    // i.e. latest empty line should not count
-    state.tight = !hasEmptyLines
-
-    // paragraph might "eat" one newline after it in nested lists
-    if (state.isEmpty(state.line - 1)) {
-      hasEmptyLines = true
-    }
-
-    line = state.line
-
-    if (line < endLine && state.isEmpty(line)) {
-      hasEmptyLines = true
-      line++
-      state.line = line
-    }
-  }
-}
-
-/**
- * ParserBlock.parse(str, md, env, outTokens)
- *
- * Process input string and push block tokens into `outTokens`
- **/
-ParserBlock.prototype.parse = function (src, md, env, outTokens) {
-  if (!src) { return }
-
-  const state = new this.State(src, md, env, outTokens)
-
-  this.tokenize(state, state.line, state.lineMax)
-}
-
-ParserBlock.prototype.State = StateBlock
-
-export default ParserBlock
diff --git a/packages/markdown-it-14.1.0/lib/parser_core.mjs b/packages/markdown-it-14.1.0/lib/parser_core.mjs
deleted file mode 100644
index df61d67..0000000
--- a/packages/markdown-it-14.1.0/lib/parser_core.mjs
+++ /dev/null
@@ -1,62 +0,0 @@
-/** internal
- * class Core
- *
- * Top-level rules executor. Glues block/inline parsers and does intermediate
- * transformations.
- **/
-
-import Ruler from './ruler.mjs'
-import StateCore from './rules_core/state_core.mjs'
-
-import r_normalize from './rules_core/normalize.mjs'
-import r_block from './rules_core/block.mjs'
-import r_inline from './rules_core/inline.mjs'
-import r_linkify from './rules_core/linkify.mjs'
-import r_replacements from './rules_core/replacements.mjs'
-import r_smartquotes from './rules_core/smartquotes.mjs'
-import r_text_join from './rules_core/text_join.mjs'
-
-const _rules = [
-  ['normalize',      r_normalize],
-  ['block',          r_block],
-  ['inline',         r_inline],
-  ['linkify',        r_linkify],
-  ['replacements',   r_replacements],
-  ['smartquotes',    r_smartquotes],
-  // `text_join` finds `text_special` tokens (for escape sequences)
-  // and joins them with the rest of the text
-  ['text_join',      r_text_join]
-]
-
-/**
- * new Core()
- **/
-function Core () {
-  /**
-   * Core#ruler -> Ruler
-   *
-   * [[Ruler]] instance. Keep configuration of core rules.
-   **/
-  this.ruler = new Ruler()
-
-  for (let i = 0; i < _rules.length; i++) {
-    this.ruler.push(_rules[i][0], _rules[i][1])
-  }
-}
-
-/**
- * Core.process(state)
- *
- * Executes core chain rules.
- **/
-Core.prototype.process = function (state) {
-  const rules = this.ruler.getRules('')
-
-  for (let i = 0, l = rules.length; i < l; i++) {
-    rules[i](state)
-  }
-}
-
-Core.prototype.State = StateCore
-
-export default Core
diff --git a/packages/markdown-it-14.1.0/lib/parser_inline.mjs b/packages/markdown-it-14.1.0/lib/parser_inline.mjs
deleted file mode 100644
index c2cc6a1..0000000
--- a/packages/markdown-it-14.1.0/lib/parser_inline.mjs
+++ /dev/null
@@ -1,197 +0,0 @@
-/** internal
- * class ParserInline
- *
- * Tokenizes paragraph content.
- **/
-
-import Ruler from './ruler.mjs'
-import StateInline from './rules_inline/state_inline.mjs'
-
-import r_text from './rules_inline/text.mjs'
-import r_linkify from './rules_inline/linkify.mjs'
-import r_newline from './rules_inline/newline.mjs'
-import r_escape from './rules_inline/escape.mjs'
-import r_backticks from './rules_inline/backticks.mjs'
-import r_strikethrough from './rules_inline/strikethrough.mjs'
-import r_emphasis from './rules_inline/emphasis.mjs'
-import r_link from './rules_inline/link.mjs'
-import r_image from './rules_inline/image.mjs'
-import r_autolink from './rules_inline/autolink.mjs'
-import r_html_inline from './rules_inline/html_inline.mjs'
-import r_entity from './rules_inline/entity.mjs'
-
-import r_balance_pairs from './rules_inline/balance_pairs.mjs'
-import r_fragments_join from './rules_inline/fragments_join.mjs'
-
-// Parser rules
-
-const _rules = [
-  ['text',            r_text],
-  ['linkify',         r_linkify],
-  ['newline',         r_newline],
-  ['escape',          r_escape],
-  ['backticks',       r_backticks],
-  ['strikethrough',   r_strikethrough.tokenize],
-  ['emphasis',        r_emphasis.tokenize],
-  ['link',            r_link],
-  ['image',           r_image],
-  ['autolink',        r_autolink],
-  ['html_inline',     r_html_inline],
-  ['entity',          r_entity]
-]
-
-// `rule2` ruleset was created specifically for emphasis/strikethrough
-// post-processing and may be changed in the future.
-//
-// Don't use this for anything except pairs (plugins working with `balance_pairs`).
-//
-const _rules2 = [
-  ['balance_pairs',   r_balance_pairs],
-  ['strikethrough',   r_strikethrough.postProcess],
-  ['emphasis',        r_emphasis.postProcess],
-  // rules for pairs separate '**' into its own text tokens, which may be left unused,
-  // rule below merges unused segments back with the rest of the text
-  ['fragments_join',  r_fragments_join]
-]
-
-/**
- * new ParserInline()
- **/
-function ParserInline () {
-  /**
-   * ParserInline#ruler -> Ruler
-   *
-   * [[Ruler]] instance. Keep configuration of inline rules.
-   **/
-  this.ruler = new Ruler()
-
-  for (let i = 0; i < _rules.length; i++) {
-    this.ruler.push(_rules[i][0], _rules[i][1])
-  }
-
-  /**
-   * ParserInline#ruler2 -> Ruler
-   *
-   * [[Ruler]] instance. Second ruler used for post-processing
-   * (e.g. in emphasis-like rules).
-   **/
-  this.ruler2 = new Ruler()
-
-  for (let i = 0; i < _rules2.length; i++) {
-    this.ruler2.push(_rules2[i][0], _rules2[i][1])
-  }
-}
-
-// Skip single token by running all rules in validation mode;
-// returns `true` if any rule reported success
-//
-ParserInline.prototype.skipToken = function (state) {
-  const pos = state.pos
-  const rules = this.ruler.getRules('')
-  const len = rules.length
-  const maxNesting = state.md.options.maxNesting
-  const cache = state.cache
-
-  if (typeof cache[pos] !== 'undefined') {
-    state.pos = cache[pos]
-    return
-  }
-
-  let ok = false
-
-  if (state.level < maxNesting) {
-    for (let i = 0; i < len; i++) {
-      // Increment state.level and decrement it later to limit recursion.
-      // It's harmless to do here, because no tokens are created. But ideally,
-      // we'd need a separate private state variable for this purpose.
-      //
-      state.level++
-      ok = rules[i](state, true)
-      state.level--
-
-      if (ok) {
-        if (pos >= state.pos) { throw new Error("inline rule didn't increment state.pos") }
-        break
-      }
-    }
-  } else {
-    // Too much nesting, just skip until the end of the paragraph.
-    //
-    // NOTE: this will cause links to behave incorrectly in the following case,
-    //       when an amount of `[` is exactly equal to `maxNesting + 1`:
-    //
-    //       [[[[[[[[[[[[[[[[[[[[[foo]()
-    //
-    // TODO: remove this workaround when CM standard will allow nested links
-    //       (we can replace it by preventing links from being parsed in
-    //       validation mode)
-    //
-    state.pos = state.posMax
-  }
-
-  if (!ok) { state.pos++ }
-  cache[pos] = state.pos
-}
-
-// Generate tokens for input range
-//
-ParserInline.prototype.tokenize = function (state) {
-  const rules = this.ruler.getRules('')
-  const len = rules.length
-  const end = state.posMax
-  const maxNesting = state.md.options.maxNesting
-
-  while (state.pos < end) {
-    // Try all possible rules.
-    // On success, rule should:
-    //
-    // - update `state.pos`
-    // - update `state.tokens`
-    // - return true
-    const prevPos = state.pos
-    let ok = false
-
-    if (state.level < maxNesting) {
-      for (let i = 0; i < len; i++) {
-        ok = rules[i](state, false)
-        if (ok) {
-          if (prevPos >= state.pos) { throw new Error("inline rule didn't increment state.pos") }
-          break
-        }
-      }
-    }
-
-    if (ok) {
-      if (state.pos >= end) { break }
-      continue
-    }
-
-    state.pending += state.src[state.pos++]
-  }
-
-  if (state.pending) {
-    state.pushPending()
-  }
-}
-
-/**
- * ParserInline.parse(str, md, env, outTokens)
- *
- * Process input string and push inline tokens into `outTokens`
- **/
-ParserInline.prototype.parse = function (str, md, env, outTokens) {
-  const state = new this.State(str, md, env, outTokens)
-
-  this.tokenize(state)
-
-  const rules = this.ruler2.getRules('')
-  const len = rules.length
-
-  for (let i = 0; i < len; i++) {
-    rules[i](state)
-  }
-}
-
-ParserInline.prototype.State = StateInline
-
-export default ParserInline
diff --git a/packages/markdown-it-14.1.0/lib/presets/commonmark.mjs b/packages/markdown-it-14.1.0/lib/presets/commonmark.mjs
deleted file mode 100644
index 7e705ad..0000000
--- a/packages/markdown-it-14.1.0/lib/presets/commonmark.mjs
+++ /dev/null
@@ -1,88 +0,0 @@
-// Commonmark default options
-
-export default {
-  options: {
-    // Enable HTML tags in source
-    html: true,
-
-    // Use '/' to close single tags (<br />)
-    xhtmlOut: true,
-
-    // Convert '\n' in paragraphs into <br>
-    breaks: false,
-
-    // CSS language prefix for fenced blocks
-    langPrefix: 'language-',
-
-    // autoconvert URL-like texts to links
-    linkify: false,
-
-    // Enable some language-neutral replacements + quotes beautification
-    typographer: false,
-
-    // Double + single quotes replacement pairs, when typographer enabled,
-    // and smartquotes on. Could be either a String or an Array.
-    //
-    // For example, you can use '«»„“' for Russian, '„“‚‘' for German,
-    // and ['«\xA0', '\xA0»', '‹\xA0', '\xA0›'] for French (including nbsp).
-    quotes: '\u201c\u201d\u2018\u2019', /* “”‘’ */
-
-    // Highlighter function. Should return escaped HTML,
-    // or '' if the source string is not changed and should be escaped externaly.
-    // If result starts with <pre... internal wrapper is skipped.
-    //
-    // function (/*str, lang*/) { return ''; }
-    //
-    highlight: null,
-
-    // Internal protection, recursion limit
-    maxNesting: 20
-  },
-
-  components: {
-
-    core: {
-      rules: [
-        'normalize',
-        'block',
-        'inline',
-        'text_join'
-      ]
-    },
-
-    block: {
-      rules: [
-        'blockquote',
-        'code',
-        'fence',
-        'heading',
-        'hr',
-        'html_block',
-        'lheading',
-        'list',
-        'reference',
-        'paragraph'
-      ]
-    },
-
-    inline: {
-      rules: [
-        'autolink',
-        'backticks',
-        'emphasis',
-        'entity',
-        'escape',
-        'html_inline',
-        'image',
-        'link',
-        'newline',
-        'text'
-      ],
-      rules2: [
-        'balance_pairs',
-        'emphasis',
-        'fragments_join'
-      ]
-    }
-  }
-}
diff --git a/packages/markdown-it-14.1.0/lib/presets/default.mjs b/packages/markdown-it-14.1.0/lib/presets/default.mjs
deleted file mode 100644
index 2540207..0000000
--- a/packages/markdown-it-14.1.0/lib/presets/default.mjs
+++ /dev/null
@@ -1,47 +0,0 @@
-// markdown-it default options
-
-export default {
-  options: {
-    // Enable HTML tags in source
-    html: false,
-
-    // Use '/' to close single tags (<br />)
-    xhtmlOut: false,
-
-    // Convert '\n' in paragraphs into <br>
-    breaks: false,
-
-    // CSS language prefix for fenced blocks
-    langPrefix: 'language-',
-
-    // autoconvert URL-like texts to links
-    linkify: false,
-
-    // Enable some language-neutral replacements + quotes beautification
-    typographer: false,
-
-    // Double + single quotes replacement pairs, when typographer enabled,
-    // and smartquotes on. Could be either a String or an Array.
-    //
-    // For example, you can use '«»„“' for Russian, '„“‚‘' for German,
-    // and ['«\xA0', '\xA0»', '‹\xA0', '\xA0›'] for French (including nbsp).
-    quotes: '\u201c\u201d\u2018\u2019', /* “”‘’ */
-
-    // Highlighter function. Should return escaped HTML,
-    // or '' if the source string is not changed and should be escaped externaly.
-    // If result starts with <pre... internal wrapper is skipped.
-    //
-    // function (/*str, lang*/) { return ''; }
-    //
-    highlight: null,
-
-    // Internal protection, recursion limit
-    maxNesting: 100
-  },
-
-  components: {
-    core: {},
-    block: {},
-    inline: {}
-  }
-}
diff --git a/packages/markdown-it-14.1.0/lib/presets/zero.mjs b/packages/markdown-it-14.1.0/lib/presets/zero.mjs
deleted file mode 100644
index c83a48e..0000000
--- a/packages/markdown-it-14.1.0/lib/presets/zero.mjs
+++ /dev/null
@@ -1,70 +0,0 @@
-// "Zero" preset, with nothing enabled. Useful for manual configuring of simple
-// modes. For example, to parse bold/italic only.
-
-export default {
-  options: {
-    // Enable HTML tags in source
-    html: false,
-
-    // Use '/' to close single tags (<br />)
-    xhtmlOut: false,
-
-    // Convert '\n' in paragraphs into <br>
-    breaks: false,
-
-    // CSS language prefix for fenced blocks
-    langPrefix: 'language-',
-
-    // autoconvert URL-like texts to links
-    linkify: false,
-
-    // Enable some language-neutral replacements + quotes beautification
-    typographer: false,
-
-    // Double + single quotes replacement pairs, when typographer enabled,
-    // and smartquotes on. Could be either a String or an Array.
-    //
-    // For example, you can use '«»„“' for Russian, '„“‚‘' for German,
-    // and ['«\xA0', '\xA0»', '‹\xA0', '\xA0›'] for French (including nbsp).
-    quotes: '\u201c\u201d\u2018\u2019', /* “”‘’ */
-
-    // Highlighter function. Should return escaped HTML,
-    // or '' if the source string is not changed and should be escaped externaly.
-    // If result starts with <pre... internal wrapper is skipped.
-    //
-    // function (/*str, lang*/) { return ''; }
-    //
-    highlight: null,
-
-    // Internal protection, recursion limit
-    maxNesting: 20
-  },
-
-  components: {
-
-    core: {
-      rules: [
-        'normalize',
-        'block',
-        'inline',
-        'text_join'
-      ]
-    },
-
-    block: {
-      rules: [
-        'paragraph'
-      ]
-    },
-
-    inline: {
-      rules: [
-        'text'
-      ],
-      rules2: [
-        'balance_pairs',
-        'fragments_join'
-      ]
-    }
-  }
-}
diff --git a/packages/markdown-it-14.1.0/lib/renderer.mjs b/packages/markdown-it-14.1.0/lib/renderer.mjs
deleted file mode 100644
index a58914c..0000000
--- a/packages/markdown-it-14.1.0/lib/renderer.mjs
+++ /dev/null
@@ -1,322 +0,0 @@
-/**
- * class Renderer
- *
- * Generates HTML from parsed token stream. Each instance has independent
- * copy of rules. Those can be rewritten with ease. Also, you can add new
- * rules if you create plugin and adds new token types.
- **/
-
-import { assign, unescapeAll, escapeHtml } from './common/utils.mjs'
-
-const default_rules = {}
-
-default_rules.code_inline = function (tokens, idx, options, env, slf) {
-  const token = tokens[idx]
-
-  return  '<code' + slf.renderAttrs(token) + '>' +
-          escapeHtml(token.content) +
-          '</code>'
-}
-
-default_rules.code_block = function (tokens, idx, options, env, slf) {
-  const token = tokens[idx]
-
-  return  '<pre' + slf.renderAttrs(token) + '><code>' +
-          escapeHtml(tokens[idx].content) +
-          '</code></pre>\n'
-}
-
-default_rules.fence = function (tokens, idx, options, env, slf) {
-  const token = tokens[idx]
-  const info = token.info ? unescapeAll(token.info).trim() : ''
-  let langName = ''
-  let langAttrs = ''
-
-  if (info) {
-    const arr = info.split(/(\s+)/g)
-    langName = arr[0]
-    langAttrs = arr.slice(2).join('')
-  }
-
-  let highlighted
-  if (options.highlight) {
-    highlighted = options.highlight(token.content, langName, langAttrs) || escapeHtml(token.content)
-  } else {
-    highlighted = escapeHtml(token.content)
-  }
-
-  if (highlighted.indexOf('<pre') === 0) {
-    return highlighted + '\n'
-  }
-
-  // If language exists, inject class gently, without modifying original token.
-  // May be, one day we will add .deepClone() for token and simplify this part, but
-  // now we prefer to keep things local.
-  if (info) {
-    const i = token.attrIndex('class')
-    const tmpAttrs = token.attrs ? token.attrs.slice() : []
-
-    if (i < 0) {
-      tmpAttrs.push(['class', options.langPrefix + langName])
-    } else {
-      tmpAttrs[i] = tmpAttrs[i].slice()
-      tmpAttrs[i][1] += ' ' + options.langPrefix + langName
-    }
-
-    // Fake token just to render attributes
-    const tmpToken = {
-      attrs: tmpAttrs
-    }
-
-    return `<pre><code${slf.renderAttrs(tmpToken)}>${highlighted}</code></pre>\n`
-  }
-
-  return `<pre><code${slf.renderAttrs(token)}>${highlighted}</code></pre>\n`
-}
-
-default_rules.image = function (tokens, idx, options, env, slf) {
-  const token = tokens[idx]
-
-  // "alt" attr MUST be set, even if empty. Because it's mandatory and
-  // should be placed on proper position for tests.
-  //
-  // Replace content with actual value
-
-  token.attrs[token.attrIndex('alt')][1] =
-    slf.renderInlineAsText(token.children, options, env)
-
-  return slf.renderToken(tokens, idx, options)
-}
-
-default_rules.hardbreak = function (tokens, idx, options /*, env */) {
-  return options.xhtmlOut ? '<br />\n' : '<br>\n'
-}
-default_rules.softbreak = function (tokens, idx, options /*, env */) {
-  return options.breaks ? (options.xhtmlOut ? '<br />\n' : '<br>\n') : '\n'
-}
-
-default_rules.text = function (tokens, idx /*, options, env */) {
-  return escapeHtml(tokens[idx].content)
-}
-
-default_rules.html_block = function (tokens, idx /*, options, env */) {
-  return tokens[idx].content
-}
-default_rules.html_inline = function (tokens, idx /*, options, env */) {
-  return tokens[idx].content
-}
-
-/**
- * new Renderer()
- *
- * Creates new [[Renderer]] instance and fill [[Renderer#rules]] with defaults.
- **/
-function Renderer () {
-  /**
-   * Renderer#rules -> Object
-   *
-   * Contains render rules for tokens. Can be updated and extended.
-   *
-   * ##### Example
-   *
-   * ```javascript
-   * var md = require('markdown-it')();
-   *
-   * md.renderer.rules.strong_open  = function () { return '<b>'; };
-   * md.renderer.rules.strong_close = function () { return '</b>'; };
-   *
-   * var result = md.renderInline(...);
-   * ```
-   *
-   * Each rule is called as independent static function with fixed signature:
-   *
-   * ```javascript
-   * function my_token_render(tokens, idx, options, env, renderer) {
-   *   // ...
-   *   return renderedHTML;
-   * }
-   * ```
-   *
-   * See [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.mjs)
-   * for more details and examples.
-   **/
-  this.rules = assign({}, default_rules)
-}
-
-/**
- * Renderer.renderAttrs(token) -> String
- *
- * Render token attributes to string.
- **/
-Renderer.prototype.renderAttrs = function renderAttrs (token) {
-  let i, l, result
-
-  if (!token.attrs) { return '' }
-
-  result = ''
-
-  for (i = 0, l = token.attrs.length; i < l; i++) {
-    result += ' ' + escapeHtml(token.attrs[i][0]) + '="' + escapeHtml(token.attrs[i][1]) + '"'
-  }
-
-  return result
-}
-
-/**
- * Renderer.renderToken(tokens, idx, options) -> String
- * - tokens (Array): list of tokens
- * - idx (Numbed): token index to render
- * - options (Object): params of parser instance
- *
- * Default token renderer. Can be overriden by custom function
- * in [[Renderer#rules]].
- **/
-Renderer.prototype.renderToken = function renderToken (tokens, idx, options) {
-  const token = tokens[idx]
-  let result = ''
-
-  // Tight list paragraphs
-  if (token.hidden) {
-    return ''
-  }
-
-  // Insert a newline between hidden paragraph and subsequent opening
-  // block-level tag.
-  //
-  // For example, here we should insert a newline before blockquote:
-  //  - a
-  //    >
-  //
-  if (token.block && token.nesting !== -1 && idx && tokens[idx - 1].hidden) {
-    result += '\n'
-  }
-
-  // Add token name, e.g. `<img`
-  result += (token.nesting === -1 ? '</' : '<') + token.tag
-
-  // Encode attributes, e.g. `<img src="foo"`
-  result += this.renderAttrs(token)
-
-  // Add a slash for self-closing tags, e.g. `<img src="foo" /`
-  if (token.nesting === 0 && options.xhtmlOut) {
-    result += ' /'
-  }
-
-  // Check if we need to add a newline after this tag
-  let needLf = false
-  if (token.block) {
-    needLf = true
-
-    if (token.nesting === 1) {
-      if (idx + 1 < tokens.length) {
-        const nextToken = tokens[idx + 1]
-
-        if (nextToken.type === 'inline' || nextToken.hidden) {
-          // Block-level tag containing an inline tag.
-          //
-          needLf = false
-        } else if (nextToken.nesting === -1 && nextToken.tag === token.tag) {
-          // Opening tag + closing tag of the same type. E.g. `<li></li>`.
-          //
-          needLf = false
-        }
-      }
-    }
-  }
-
-  result += needLf ? '>\n' : '>'
-
-  return result
-}
-
-/**
- * Renderer.renderInline(tokens, options, env) -> String
- * - tokens (Array): list on block tokens to render
- * - options (Object): params of parser instance
- * - env (Object): additional data from parsed input (references, for example)
- *
- * The same as [[Renderer.render]], but for single token of `inline` type.
- **/
-Renderer.prototype.renderInline = function (tokens, options, env) {
-  let result = ''
-  const rules = this.rules
-
-  for (let i = 0, len = tokens.length; i < len; i++) {
-    const type = tokens[i].type
-
-    if (typeof rules[type] !== 'undefined') {
-      result += rules[type](tokens, i, options, env, this)
-    } else {
-      result += this.renderToken(tokens, i, options)
-    }
-  }
-
-  return result
-}
-
-/** internal
- * Renderer.renderInlineAsText(tokens, options, env) -> String
- * - tokens (Array): list on block tokens to render
- * - options (Object): params of parser instance
- * - env (Object): additional data from parsed input (references, for example)
- *
- * Special kludge for image `alt` attributes to conform CommonMark spec.
- * Don't try to use it! Spec requires to show `alt` content with stripped markup,
- * instead of simple escaping.
- **/
-Renderer.prototype.renderInlineAsText = function (tokens, options, env) {
-  let result = ''
-
-  for (let i = 0, len = tokens.length; i < len; i++) {
-    switch (tokens[i].type) {
-      case 'text':
-        result += tokens[i].content
-        break
-      case 'image':
-        result += this.renderInlineAsText(tokens[i].children, options, env)
-        break
-      case 'html_inline':
-      case 'html_block':
-        result += tokens[i].content
-        break
-      case 'softbreak':
-      case 'hardbreak':
-        result += '\n'
-        break
-      default:
-        // all other tokens are skipped
-    }
-  }
-
-  return result
-}
-
-/**
- * Renderer.render(tokens, options, env) -> String
- * - tokens (Array): list on block tokens to render
- * - options (Object): params of parser instance
- * - env (Object): additional data from parsed input (references, for example)
- *
- * Takes token stream and generates HTML. Probably, you will never need to call
- * this method directly.
- **/
-Renderer.prototype.render = function (tokens, options, env) {
-  let result = ''
-  const rules = this.rules
-
-  for (let i = 0, len = tokens.length; i < len; i++) {
-    const type = tokens[i].type
-
-    if (type === 'inline') {
-      result += this.renderInline(tokens[i].children, options, env)
-    } else if (typeof rules[type] !== 'undefined') {
-      result += rules[type](tokens, i, options, env, this)
-    } else {
-      result += this.renderToken(tokens, i, options, env)
-    }
-  }
-
-  return result
-}
-
-export default Renderer
diff --git a/packages/markdown-it-14.1.0/lib/ruler.mjs b/packages/markdown-it-14.1.0/lib/ruler.mjs
deleted file mode 100644
index 92c98e9..0000000
--- a/packages/markdown-it-14.1.0/lib/ruler.mjs
+++ /dev/null
@@ -1,340 +0,0 @@
-/**
- * class Ruler
- *
- * Helper class, used by [[MarkdownIt#core]], [[MarkdownIt#block]] and
- * [[MarkdownIt#inline]] to manage sequences of functions (rules):
- *
- * - keep rules in defined order
- * - assign the name to each rule
- * - enable/disable rules
- * - add/replace rules
- * - allow assign rules to additional named chains (in the same)
- * - cacheing lists of active rules
- *
- * You will not need use this class directly until write plugins. For simple
- * rules control use [[MarkdownIt.disable]], [[MarkdownIt.enable]] and
- * [[MarkdownIt.use]].
- **/
-
-/**
- * new Ruler()
- **/
-function Ruler () {
-  // List of added rules. Each element is:
-  //
-  // {
-  //   name: XXX,
-  //   enabled: Boolean,
-  //   fn: Function(),
-  //   alt: [ name2, name3 ]
-  // }
-  //
-  this.__rules__ = []
-
-  // Cached rule chains.
-  //
-  // First level - chain name, '' for default.
-  // Second level - diginal anchor for fast filtering by charcodes.
-  //
-  this.__cache__ = null
-}
-
-// Helper methods, should not be used directly
-
-// Find rule index by name
-//
-Ruler.prototype.__find__ = function (name) {
-  for (let i = 0; i < this.__rules__.length; i++) {
-    if (this.__rules__[i].name === name) {
-      return i
-    }
-  }
-  return -1
-}
-
-// Build rules lookup cache
-//
-Ruler.prototype.__compile__ = function () {
-  const self = this
-  const chains = ['']
-
-  // collect unique names
-  self.__rules__.forEach(function (rule) {
-    if (!rule.enabled) { return }
-
-    rule.alt.forEach(function (altName) {
-      if (chains.indexOf(altName) < 0) {
-        chains.push(altName)
-      }
-    })
-  })
-
-  self.__cache__ = {}
-
-  chains.forEach(function (chain) {
-    self.__cache__[chain] = []
-    self.__rules__.forEach(function (rule) {
-      if (!rule.enabled) { return }
-
-      if (chain && rule.alt.indexOf(chain) < 0) { return }
-
-      self.__cache__[chain].push(rule.fn)
-    })
-  })
-}
-
-/**
- * Ruler.at(name, fn [, options])
- * - name (String): rule name to replace.
- * - fn (Function): new rule function.
- * - options (Object): new rule options (not mandatory).
- *
- * Replace rule by name with new function & options. Throws error if name not
- * found.
- *
- * ##### Options:
- *
- * - __alt__ - array with names of "alternate" chains.
- *
- * ##### Example
- *
- * Replace existing typographer replacement rule with new one:
- *
- * ```javascript
- * var md = require('markdown-it')();
- *
- * md.core.ruler.at('replacements', function replace(state) {
- *   //...
- * });
- * ```
- **/
-Ruler.prototype.at = function (name, fn, options) {
-  const index = this.__find__(name)
-  const opt = options || {}
-
-  if (index === -1) { throw new Error('Parser rule not found: ' + name) }
-
-  this.__rules__[index].fn = fn
-  this.__rules__[index].alt = opt.alt || []
-  this.__cache__ = null
-}
-
-/**
- * Ruler.before(beforeName, ruleName, fn [, options])
- * - beforeName (String): new rule will be added before this one.
- * - ruleName (String): name of added rule.
- * - fn (Function): rule function.
- * - options (Object): rule options (not mandatory).
- *
- * Add new rule to chain before one with given name. See also
- * [[Ruler.after]], [[Ruler.push]].
- *
- * ##### Options:
- *
- * - __alt__ - array with names of "alternate" chains.
- *
- * ##### Example
- *
- * ```javascript
- * var md = require('markdown-it')();
- *
- * md.block.ruler.before('paragraph', 'my_rule', function replace(state) {
- *   //...
- * });
- * ```
- **/
-Ruler.prototype.before = function (beforeName, ruleName, fn, options) {
-  const index = this.__find__(beforeName)
-  const opt = options || {}
-
-  if (index === -1) { throw new Error('Parser rule not found: ' + beforeName) }
-
-  this.__rules__.splice(index, 0, {
-    name: ruleName,
-    enabled: true,
-    fn,
-    alt: opt.alt || []
-  })
-
-  this.__cache__ = null
-}
-
-/**
- * Ruler.after(afterName, ruleName, fn [, options])
- * - afterName (String): new rule will be added after this one.
- * - ruleName (String): name of added rule.
- * - fn (Function): rule function.
- * - options (Object): rule options (not mandatory).
- *
- * Add new rule to chain after one with given name. See also
- * [[Ruler.before]], [[Ruler.push]].
- *
- * ##### Options:
- *
- * - __alt__ - array with names of "alternate" chains.
- *
- * ##### Example
- *
- * ```javascript
- * var md = require('markdown-it')();
- *
- * md.inline.ruler.after('text', 'my_rule', function replace(state) {
- *   //...
- * });
- * ```
- **/
-Ruler.prototype.after = function (afterName, ruleName, fn, options) {
-  const index = this.__find__(afterName)
-  const opt = options || {}
-
-  if (index === -1) { throw new Error('Parser rule not found: ' + afterName) }
-
-  this.__rules__.splice(index + 1, 0, {
-    name: ruleName,
-    enabled: true,
-    fn,
-    alt: opt.alt || []
-  })
-
-  this.__cache__ = null
-}
-
-/**
- * Ruler.push(ruleName, fn [, options])
- * - ruleName (String): name of added rule.
- * - fn (Function): rule function.
- * - options (Object): rule options (not mandatory).
- *
- * Push new rule to the end of chain. See also
- * [[Ruler.before]], [[Ruler.after]].
- *
- * ##### Options:
- *
- * - __alt__ - array with names of "alternate" chains.
- *
- * ##### Example
- *
- * ```javascript
- * var md = require('markdown-it')();
- *
- * md.core.ruler.push('my_rule', function replace(state) {
- *   //...
- * });
- * ```
- **/
-Ruler.prototype.push = function (ruleName, fn, options) {
-  const opt = options || {}
-
-  this.__rules__.push({
-    name: ruleName,
-    enabled: true,
-    fn,
-    alt: opt.alt || []
-  })
-
-  this.__cache__ = null
-}
-
-/**
- * Ruler.enable(list [, ignoreInvalid]) -> Array
- * - list (String|Array): list of rule names to enable.
- * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.
- *
- * Enable rules with given names. If any rule name not found - throw Error.
- * Errors can be disabled by second param.
- *
- * Returns list of found rule names (if no exception happened).
- *
- * See also [[Ruler.disable]], [[Ruler.enableOnly]].
- **/
-Ruler.prototype.enable = function (list, ignoreInvalid) {
-  if (!Array.isArray(list)) { list = [list] }
-
-  const result = []
-
-  // Search by name and enable
-  list.forEach(function (name) {
-    const idx = this.__find__(name)
-
-    if (idx < 0) {
-      if (ignoreInvalid) { return }
-      throw new Error('Rules manager: invalid rule name ' + name)
-    }
-    this.__rules__[idx].enabled = true
-    result.push(name)
-  }, this)
-
-  this.__cache__ = null
-  return result
-}
-
-/**
- * Ruler.enableOnly(list [, ignoreInvalid])
- * - list (String|Array): list of rule names to enable (whitelist).
- * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.
- *
- * Enable rules with given names, and disable everything else. If any rule name
- * not found - throw Error. Errors can be disabled by second param.
- *
- * See also [[Ruler.disable]], [[Ruler.enable]].
- **/
-Ruler.prototype.enableOnly = function (list, ignoreInvalid) {
-  if (!Array.isArray(list)) { list = [list] }
-
-  this.__rules__.forEach(function (rule) { rule.enabled = false })
-
-  this.enable(list, ignoreInvalid)
-}
-
-/**
- * Ruler.disable(list [, ignoreInvalid]) -> Array
- * - list (String|Array): list of rule names to disable.
- * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.
- *
- * Disable rules with given names. If any rule name not found - throw Error.
- * Errors can be disabled by second param.
- *
- * Returns list of found rule names (if no exception happened).
- *
- * See also [[Ruler.enable]], [[Ruler.enableOnly]].
- **/
-Ruler.prototype.disable = function (list, ignoreInvalid) {
-  if (!Array.isArray(list)) { list = [list] }
-
-  const result = []
-
-  // Search by name and disable
-  list.forEach(function (name) {
-    const idx = this.__find__(name)
-
-    if (idx < 0) {
-      if (ignoreInvalid) { return }
-      throw new Error('Rules manager: invalid rule name ' + name)
-    }
-    this.__rules__[idx].enabled = false
-    result.push(name)
-  }, this)
-
-  this.__cache__ = null
-  return result
-}
-
-/**
- * Ruler.getRules(chainName) -> Array
- *
- * Return array of active functions (rules) for given chain name. It analyzes
- * rules configuration, compiles caches if not exists and returns result.
- *
- * Default chain name is `''` (empty string). It can't be skipped. That's
- * done intentionally, to keep signature monomorphic for high speed.
- **/
-Ruler.prototype.getRules = function (chainName) {
-  if (this.__cache__ === null) {
-    this.__compile__()
-  }
-
-  // Chain can be empty, if rules disabled. But we still have to return Array.
-  return this.__cache__[chainName] || []
-}
-
-export default Ruler
diff --git a/packages/markdown-it-14.1.0/lib/rules_block/blockquote.mjs b/packages/markdown-it-14.1.0/lib/rules_block/blockquote.mjs
deleted file mode 100644
index b61da02..0000000
--- a/packages/markdown-it-14.1.0/lib/rules_block/blockquote.mjs
+++ /dev/null
@@ -1,209 +0,0 @@
-// Block quotes
-
-import { isSpace } from '../common/utils.mjs'
-
-export default function blockquote (state, startLine, endLine, silent) {
-  let pos = state.bMarks[startLine] + state.tShift[startLine]
-  let max = state.eMarks[startLine]
-
-  const oldLineMax = state.lineMax
-
-  // if it's indented more than 3 spaces, it should be a code block
-  if (state.sCount[startLine] - state.blkIndent >= 4) { return false }
-
-  // check the block quote marker
-  if (state.src.charCodeAt(pos) !== 0x3E/* > */) { return false }
-
-  // we know that it's going to be a valid blockquote,
-  // so no point trying to find the end of it in silent mode
-  if (silent) { return true }
-
-  const oldBMarks  = []
-  const oldBSCount = []
-  const oldSCount  = []
-  const oldTShift  = []
-
-  const terminatorRules = state.md.block.ruler.getRules('blockquote')
-
-  const oldParentType = state.parentType
-  state.parentType = 'blockquote'
-  let lastLineEmpty = false
-  let nextLine
-
-  // Search the end of the block
-  //
-  // Block ends with either:
-  //  1. an empty line outside:
-  //     ```
-  //     > test
-  //
-  //     ```
-  //  2. an empty line inside:
-  //     ```
-  //     >
-  //     test
-  //     ```
-  //  3. another tag:
-  //     ```
-  //     > test
-  //      - - -
-  //     ```
-  for (nextLine = startLine; nextLine < endLine; nextLine++) {
-    // check if it's outdented, i.e. it's inside list item and indented
-    // less than said list item:
-    //
-    // ```
-    // 1. anything
-    //    > current blockquote
-    // 2. checking this line
-    // ```
-    const isOutdented = state.sCount[nextLine] < state.blkIndent
-
-    pos = state.bMarks[nextLine] + state.tShift[nextLine]
-    max = state.eMarks[nextLine]
-
-    if (pos >= max) {
-      // Case 1: line is not inside the blockquote, and this line is empty.
-      break
-    }
-
-    if (state.src.charCodeAt(pos++) === 0x3E/* > */ && !isOutdented) {
-      // This line is inside the blockquote.
-
-      // set offset past spaces and ">"
-      let initial = state.sCount[nextLine] + 1
-      let spaceAfterMarker
-      let adjustTab
-
-      // skip one optional space after '>'
-      if (state.src.charCodeAt(pos) === 0x20 /* space */) {
-        // ' >   test '
-        //     ^ -- position start of line here:
-        pos++
-        initial++
-        adjustTab = false
-        spaceAfterMarker = true
-      } else if (state.src.charCodeAt(pos) === 0x09 /* tab */) {
-        spaceAfterMarker = true
-
-        if ((state.bsCount[nextLine] + initial) % 4 === 3) {
-          // '  >\t  test '
-          //       ^ -- position start of line here (tab has width===1)
-          pos++
-          initial++
-          adjustTab = false
-        } else {
-          // ' >\t  test '
-          //    ^ -- position start of line here + shift bsCount slightly
-          //         to make extra space appear
-          adjustTab = true
-        }
-      } else {
-        spaceAfterMarker = false
-      }
-
-      let offset = initial
-      oldBMarks.push(state.bMarks[nextLine])
-      state.bMarks[nextLine] = pos
-
-      while (pos < max) {
-        const ch = state.src.charCodeAt(pos)
-
-        if (isSpace(ch)) {
-          if (ch === 0x09) {
-            offset += 4 - (offset + state.bsCount[nextLine] + (adjustTab ? 1 : 0)) % 4
-          } else {
-            offset++
-          }
-        } else {
-          break
-        }
-
-        pos++
-      }
-
-      lastLineEmpty = pos >= max
-
-      oldBSCount.push(state.bsCount[nextLine])
-      state.bsCount[nextLine] = state.sCount[nextLine] + 1 + (spaceAfterMarker ? 1 : 0)
-
-      oldSCount.push(state.sCount[nextLine])
-      state.sCount[nextLine] = offset - initial
-
-      oldTShift.push(state.tShift[nextLine])
-      state.tShift[nextLine] = pos - state.bMarks[nextLine]
-      continue
-    }
-
-    // Case 2: line is not inside the blockquote, and the last line was empty.
-    if (lastLineEmpty) { break }
-
-    // Case 3: another tag found.
-    let terminate = false
-    for (let i = 0, l = terminatorRules.length; i < l; i++) {
-      if (terminatorRules[i](state, nextLine, endLine, true)) {
-        terminate = true
-        break
-      }
-    }
-
-    if (terminate) {
-      // Quirk to enforce "hard termination mode" for paragraphs;
-      // normally if you call `tokenize(state, startLine, nextLine)`,
-      // paragraphs will look below nextLine for paragraph continuation,
-      // but if blockquote is terminated by another tag, they shouldn't
-      state.lineMax = nextLine
-
-      if (state.blkIndent !== 0) {
-        // state.blkIndent was non-zero, we now set it to zero,
-        // so we need to re-calculate all offsets to appear as
-        // if indent wasn't changed
-        oldBMarks.push(state.bMarks[nextLine])
-        oldBSCount.push(state.bsCount[nextLine])
-        oldTShift.push(state.tShift[nextLine])
-        oldSCount.push(state.sCount[nextLine])
-        state.sCount[nextLine] -= state.blkIndent
-      }
-
-      break
-    }
-
-    oldBMarks.push(state.bMarks[nextLine])
-    oldBSCount.push(state.bsCount[nextLine])
-    oldTShift.push(state.tShift[nextLine])
-    oldSCount.push(state.sCount[nextLine])
-
-    // A negative indentation means that this is a paragraph continuation
-    //
-    state.sCount[nextLine] = -1
-  }
-
-  const oldIndent = state.blkIndent
-  state.blkIndent = 0
-
-  const token_o  = state.push('blockquote_open', 'blockquote', 1)
-  token_o.markup = '>'
-  const lines = [startLine, 0]
-  token_o.map    = lines
-
-  state.md.block.tokenize(state, startLine, nextLine)
-
-  const token_c  = state.push('blockquote_close', 'blockquote', -1)
-  token_c.markup = '>'
-
-  state.lineMax = oldLineMax
-  state.parentType = oldParentType
-  lines[1] = state.line
-
-  // Restore original tShift; this might not be necessary since the parser
-  // has already been here, but just to make sure we can do that.
-  for (let i = 0; i < oldTShift.length; i++) {
-    state.bMarks[i + startLine] = oldBMarks[i]
-    state.tShift[i + startLine] = oldTShift[i]
-    state.sCount[i + startLine] = oldSCount[i]
-    state.bsCount[i + startLine] = oldBSCount[i]
-  }
-  state.blkIndent = oldIndent
-
-  return true
-}
diff --git a/packages/markdown-it-14.1.0/lib/rules_block/code.mjs b/packages/markdown-it-14.1.0/lib/rules_block/code.mjs
deleted file mode 100644
index e45e6f9..0000000
--- a/packages/markdown-it-14.1.0/lib/rules_block/code.mjs
+++ /dev/null
@@ -1,30 +0,0 @@
-// Code block (4 spaces padded)
-
-export default function code (state, startLine, endLine/*, silent */) {
-  if (state.sCount[startLine] - state.blkIndent < 4) { return false }
-
-  let nextLine = startLine + 1
-  let last = nextLine
-
-  while (nextLine < endLine) {
-    if (state.isEmpty(nextLine)) {
-      nextLine++
-      continue
-    }
-
-    if (state.sCount[nextLine] - state.blkIndent >= 4) {
-      nextLine++
-      last = nextLine
-      continue
-    }
-    break
-  }
-
-  state.line = last
-
-  const token   = state.push('code_block', 'code', 0)
-  token.content = state.getLines(startLine, last, 4 + state.blkIndent, false) + '\n'
-  token.map     = [startLine, state.line]
-
-  return true
-}
diff --git a/packages/markdown-it-14.1.0/lib/rules_block/fence.mjs b/packages/markdown-it-14.1.0/lib/rules_block/fence.mjs
deleted file mode 100644
index 930f7b3..0000000
--- a/packages/markdown-it-14.1.0/lib/rules_block/fence.mjs
+++ /dev/null
@@ -1,94 +0,0 @@
-// fences (``` lang, ~~~ lang)
-
-export default function fence (state, startLine, endLine, silent) {
-  let pos = state.bMarks[startLine] + state.tShift[startLine]
-  let max = state.eMarks[startLine]
-
-  // if it's indented more than 3 spaces, it should be a code block
-  if (state.sCount[startLine] - state.blkIndent >= 4) { return false }
-
-  if (pos + 3 > max) { return false }
-
-  const marker = state.src.charCodeAt(pos)
-
-  if (marker !== 0x7E/* ~ */ && marker !== 0x60 /* ` */) {
-    return false
-  }
-
-  // scan marker length
-  let mem = pos
-  pos = state.skipChars(pos, marker)
-
-  let len = pos - mem
-
-  if (len < 3) { return false }
-
-  const markup = state.src.slice(mem, pos)
-  const params = state.src.slice(pos, max)
-
-  if (marker === 0x60 /* ` */) {
-    if (params.indexOf(String.fromCharCode(marker)) >= 0) {
-      return false
-    }
-  }
-
-  // Since start is found, we can report success here in validation mode
-  if (silent) { return true }
-
-  // search end of block
-  let nextLine = startLine
-  let haveEndMarker = false
-
-  for (;;) {
-    nextLine++
-    if (nextLine >= endLine) {
-      // unclosed block should be autoclosed by end of document.
-      // also block seems to be autoclosed by end of parent
-      break
-    }
-
-    pos = mem = state.bMarks[nextLine] + state.tShift[nextLine]
-    max = state.eMarks[nextLine]
-
-    if (pos < max && state.sCount[nextLine] < state.blkIndent) {
-      // non-empty line with negative indent should stop the list:
-      // - ```
-      //  test
-      break
-    }
-
-    if (state.src.charCodeAt(pos) !== marker) { continue }
-
-    if (state.sCount[nextLine] - state.blkIndent >= 4) {
-      // closing fence should be indented less than 4 spaces
-      continue
-    }
-
-    pos = state.skipChars(pos, marker)
-
-    // closing code fence must be at least as long as the opening one
-    if (pos - mem < len) { continue }
-
-    // make sure tail has spaces only
-    pos = state.skipSpaces(pos)
-
-    if (pos < max) { continue }
-
-    haveEndMarker = true
-    // found!
-    break
-  }
-
-  // If a fence has heading spaces, they should be removed from its inner block
-  len = state.sCount[startLine]
-
-  state.line = nextLine + (haveEndMarker ? 1 : 0)
-
-  const token   = state.push('fence', 'code', 0)
-  token.info    = params
-  token.content = state.getLines(startLine + 1, nextLine, len, true)
-  token.markup  = markup
-  token.map     = [startLine, state.line]
-
-  return true
-}
diff --git a/packages/markdown-it-14.1.0/lib/rules_block/heading.mjs b/packages/markdown-it-14.1.0/lib/rules_block/heading.mjs
deleted file mode 100644
index d2f7b79..0000000
--- a/packages/markdown-it-14.1.0/lib/rules_block/heading.mjs
+++ /dev/null
@@ -1,51 +0,0 @@
-// heading (#, ##, ...)
-
-import { isSpace } from '../common/utils.mjs'
-
-export default function heading (state, startLine, endLine, silent) {
-  let pos = state.bMarks[startLine] + state.tShift[startLine]
-  let max = state.eMarks[startLine]
-
-  // if it's indented more than 3 spaces, it should be a code block
-  if (state.sCount[startLine] - state.blkIndent >= 4) { return false }
-
-  let ch  = state.src.charCodeAt(pos)
-
-  if (ch !== 0x23/* # */ || pos >= max) { return false }
-
-  // count heading level
-  let level = 1
-  ch = state.src.charCodeAt(++pos)
-  while (ch === 0x23/* # */ && pos < max && level <= 6) {
-    level++
-    ch = state.src.charCodeAt(++pos)
-  }
-
-  if (level > 6 || (pos < max && !isSpace(ch))) { return false }
-
-  if (silent) { return true }
-
-  // Let's cut tails like '    ###  ' from the end of string
-
-  max = state.skipSpacesBack(max, pos)
-  const tmp = state.skipCharsBack(max, 0x23, pos) // #
-  if (tmp > pos && isSpace(state.src.charCodeAt(tmp - 1))) {
-    max = tmp
-  }
-
-  state.line = startLine + 1
-
-  const token_o  = state.push('heading_open', 'h' + String(level), 1)
-  token_o.markup = '########'.slice(0, level)
-  token_o.map    = [startLine, state.line]
-
-  const token_i    = state.push('inline', '', 0)
-  token_i.content  = state.src.slice(pos, max).trim()
-  token_i.map      = [startLine, state.line]
-  token_i.children = []
-
-  const token_c  = state.push('heading_close', 'h' + String(level), -1)
-  token_c.markup = '########'.slice(0, level)
-
-  return true
-}
diff --git a/packages/markdown-it-14.1.0/lib/rules_block/hr.mjs b/packages/markdown-it-14.1.0/lib/rules_block/hr.mjs
deleted file mode 100644
index d467b21..0000000
--- a/packages/markdown-it-14.1.0/lib/rules_block/hr.mjs
+++ /dev/null
@@ -1,40 +0,0 @@
-// Horizontal rule
-
-import { isSpace } from '../common/utils.mjs'
-
-export default function hr (state, startLine, endLine, silent) {
-  const max = state.eMarks[startLine]
-  // if it's indented more than 3 spaces, it should be a code block
-  if (state.sCount[startLine] - state.blkIndent >= 4) { return false }
-
-  let pos = state.bMarks[startLine] + state.tShift[startLine]
-  const marker = state.src.charCodeAt(pos++)
-
-  // Check hr marker
-  if (marker !== 0x2A/* * */ &&
-      marker !== 0x2D/* - */ &&
-      marker !== 0x5F/* _ */) {
-    return false
-  }
-
-  // markers can be mixed with spaces, but there should be at least 3 of them
-
-  let cnt = 1
-  while (pos < max) {
-    const ch = state.src.charCodeAt(pos++)
-    if (ch !== marker && !isSpace(ch)) { return false }
-    if (ch === marker) { cnt++ }
-  }
-
-  if (cnt < 3) { return false }
-
-  if (silent) { return true }
-
-  state.line = startLine + 1
-
-  const token  = state.push('hr', 'hr', 0)
-  token.map    = [startLine, state.line]
-  token.markup = Array(cnt + 1).join(String.fromCharCode(marker))
-
-  return true
-}
diff --git a/packages/markdown-it-14.1.0/lib/rules_block/html_block.mjs b/packages/markdown-it-14.1.0/lib/rules_block/html_block.mjs
deleted file mode 100644
index 197520f..0000000
--- a/packages/markdown-it-14.1.0/lib/rules_block/html_block.mjs
+++ /dev/null
@@ -1,69 +0,0 @@
-// HTML block
-
-import block_names from '../common/html_blocks.mjs'
-import { HTML_OPEN_CLOSE_TAG_RE } from '../common/html_re.mjs'
-
-// An array of opening and corresponding closing sequences for html tags,
-// last argument defines whether it can terminate a paragraph or not
-//
-const HTML_SEQUENCES = [
-  [/^<(script|pre|style|textarea)(?=(\s|>|$))/i, /<\/(script|pre|style|textarea)>/i, true],
-  [/^<!--/,        /-->/,   true],
-  [/^<\?/,         /\?>/,   true],
-  [/^<![A-Z]/,     />/,     true],
-  [/^<!\[CDATA\[/, /\]\]>/, true],
-  [new RegExp('^</?(' + block_names.join('|') + ')(?=(\\s|/?>|$))', 'i'), /^$/, true],
-  [new RegExp(HTML_OPEN_CLOSE_TAG_RE.source + '\\s*$'),  /^$/, false]
-]
-
-export default function html_block (state, startLine, endLine, silent) {
-  let pos = state.bMarks[startLine] + state.tShift[startLine]
-  let max = state.eMarks[startLine]
-
-  // if it's indented more than 3 spaces, it should be a code block
-  if (state.sCount[startLine] - state.blkIndent >= 4) { return false }
-
-  if (!state.md.options.html) { return false }
-
-  if (state.src.charCodeAt(pos) !== 0x3C/* < */) { return false }
-
-  let lineText = state.src.slice(pos, max)
-
-  let i = 0
-  for (; i < HTML_SEQUENCES.length; i++) {
-    if (HTML_SEQUENCES[i][0].test(lineText)) { break }
-  }
-  if (i === HTML_SEQUENCES.length) { return false }
-
-  if (silent) {
-    // true if this sequence can be a terminator, false otherwise
-    return HTML_SEQUENCES[i][2]
-  }
-
-  let nextLine = startLine + 1
-
-  // If we are here - we detected HTML block.
-  // Let's roll down till block end.
-  if (!HTML_SEQUENCES[i][1].test(lineText)) {
-    for (; nextLine < endLine; nextLine++) {
-      if (state.sCount[nextLine] < state.blkIndent) { break }
-
-      pos = state.bMarks[nextLine] + state.tShift[nextLine]
-      max = state.eMarks[nextLine]
-      lineText = state.src.slice(pos, max)
-
-      if (HTML_SEQUENCES[i][1].test(lineText)) {
-        if (lineText.length !== 0) { nextLine++ }
-        break
-      }
-    }
-  }
-
-  state.line = nextLine
-
-  const token   = state.push('html_block', '', 0)
-  token.map     = [startLine, nextLine]
-  token.content = state.getLines(startLine, nextLine, state.blkIndent, true)
-
-  return true
-}
diff --git a/packages/markdown-it-14.1.0/lib/rules_block/lheading.mjs b/packages/markdown-it-14.1.0/lib/rules_block/lheading.mjs
deleted file mode 100644
index ee3b9a3..0000000
--- a/packages/markdown-it-14.1.0/lib/rules_block/lheading.mjs
+++ /dev/null
@@ -1,82 +0,0 @@
-// lheading (---, ===)
-
-export default function lheading (state, startLine, endLine/*, silent */) {
-  const terminatorRules = state.md.block.ruler.getRules('paragraph')
-
-  // if it's indented more than 3 spaces, it should be a code block
-  if (state.sCount[startLine] - state.blkIndent >= 4) { return false }
-
-  const oldParentType = state.parentType
-  state.parentType = 'paragraph' // use paragraph to match terminatorRules
-
-  // jump line-by-line until empty one or EOF
-  let level = 0
-  let marker
-  let nextLine = startLine + 1
-
-  for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {
-    // this would be a code block normally, but after paragraph
-    // it's considered a lazy continuation regardless of what's there
-    if (state.sCount[nextLine] - state.blkIndent > 3) { continue }
-
-    //
-    // Check for underline in setext header
-    //
-    if (state.sCount[nextLine] >= state.blkIndent) {
-      let pos = state.bMarks[nextLine] + state.tShift[nextLine]
-      const max = state.eMarks[nextLine]
-
-      if (pos < max) {
-        marker = state.src.charCodeAt(pos)
-
-        if (marker === 0x2D/* - */ || marker === 0x3D/* = */) {
-          pos = state.skipChars(pos, marker)
-          pos = state.skipSpaces(pos)
-
-          if (pos >= max) {
-            level = (marker === 0x3D/* = */ ? 1 : 2)
-            break
-          }
-        }
-      }
-    }
-
-    // quirk for blockquotes, this line should already be checked by that rule
-    if (state.sCount[nextLine] < 0) { continue }
-
-    // Some tags can terminate paragraph without empty line.
-    let terminate = false
-    for (let i = 0, l = terminatorRules.length; i < l; i++) {
-      if (terminatorRules[i](state, nextLine, endLine, true)) {
-        terminate = true
-        break
-      }
-    }
-    if (terminate) { break }
-  }
-
-  if (!level) {
-    // Didn't find valid underline
-    return false
-  }
-
-  const content = state.getLines(startLine, nextLine, state.blkIndent, false).trim()
-
-  state.line = nextLine + 1
-
-  const token_o    = state.push('heading_open', 'h' + String(level), 1)
-  token_o.markup   = String.fromCharCode(marker)
-  token_o.map      = [startLine, state.line]
-
-  const token_i    = state.push('inline', '', 0)
-  token_i.content  = content
-  token_i.map      = [startLine, state.line - 1]
-  token_i.children = []
-
-  const token_c    = state.push('heading_close', 'h' + String(level), -1)
-  token_c.markup   = String.fromCharCode(marker)
-
-  state.parentType = oldParentType
-
-  return true
-}
diff --git a/packages/markdown-it-14.1.0/lib/rules_block/list.mjs b/packages/markdown-it-14.1.0/lib/rules_block/list.mjs
deleted file mode 100644
index fb53abd..0000000
--- a/packages/markdown-it-14.1.0/lib/rules_block/list.mjs
+++ /dev/null
@@ -1,331 +0,0 @@
-// Lists
-
-import { isSpace } from '../common/utils.mjs'
-
-// Search `[-+*][\n ]`, returns next pos after marker on success
-// or -1 on fail.
-function skipBulletListMarker (state, startLine) {
-  const max = state.eMarks[startLine]
-  let pos = state.bMarks[startLine] + state.tShift[startLine]
-
-  const marker = state.src.charCodeAt(pos++)
-  // Check bullet
-  if (marker !== 0x2A/* * */ &&
-      marker !== 0x2D/* - */ &&
-      marker !== 0x2B/* + */) {
-    return -1
-  }
-
-  if (pos < max) {
-    const ch = state.src.charCodeAt(pos)
-
-    if (!isSpace(ch)) {
-      // " -test " - is not a list item
-      return -1
-    }
-  }
-
-  return pos
-}
-
-// Search `\d+[.)][\n ]`, returns next pos after marker on success
-// or -1 on fail.
-function skipOrderedListMarker (state, startLine) {
-  const start = state.bMarks[startLine] + state.tShift[startLine]
-  const max = state.eMarks[startLine]
-  let pos = start
-
-  // List marker should have at least 2 chars (digit + dot)
-  if (pos + 1 >= max) { return -1 }
-
-  let ch = state.src.charCodeAt(pos++)
-
-  if (ch < 0x30/* 0 */ || ch > 0x39/* 9 */) { return -1 }
-
-  for (;;) {
-    // EOL -> fail
-    if (pos >= max) { return -1 }
-
-    ch = state.src.charCodeAt(pos++)
-
-    if (ch >= 0x30/* 0 */ && ch <= 0x39/* 9 */) {
-      // List marker should have no more than 9 digits
-      // (prevents integer overflow in browsers)
-      if (pos - start >= 10) { return -1 }
-
-      continue
-    }
-
-    // found valid marker
-    if (ch === 0x29/* ) */ || ch === 0x2e/* . */) {
-      break
-    }
-
-    return -1
-  }
-
-  if (pos < max) {
-    ch = state.src.charCodeAt(pos)
-
-    if (!isSpace(ch)) {
-      // " 1.test " - is not a list item
-      return -1
-    }
-  }
-  return pos
-}
-
-function markTightParagraphs (state, idx) {
-  const level = state.level + 2
-
-  for (let i = idx + 2, l = state.tokens.length - 2; i < l; i++) {
-    if (state.tokens[i].level === level && state.tokens[i].type === 'paragraph_open') {
-      state.tokens[i + 2].hidden = true
-      state.tokens[i].hidden = true
-      i += 2
-    }
-  }
-}
-
-export default function list (state, startLine, endLine, silent) {
-  let max, pos, start, token
-  let nextLine = startLine
-  let tight = true
-
-  // if it's indented more than 3 spaces, it should be a code block
-  if (state.sCount[nextLine] - state.blkIndent >= 4) { return false }
-
-  // Special case:
-  //  - item 1
-  //   - item 2
-  //    - item 3
-  //     - item 4
-  //      - this one is a paragraph continuation
-  if (state.listIndent >= 0 &&
-      state.sCount[nextLine] - state.listIndent >= 4 &&
-      state.sCount[nextLine] < state.blkIndent) {
-    return false
-  }
-
-  let isTerminatingParagraph = false
-
-  // limit conditions when list can interrupt
-  // a paragraph (validation mode only)
-  if (silent && state.parentType === 'paragraph') {
-    // Next list item should still terminate previous list item;
-    //
-    // This code can fail if plugins use blkIndent as well as lists,
-    // but I hope the spec gets fixed long before that happens.
-    //
-    if (state.sCount[nextLine] >= state.blkIndent) {
-      isTerminatingParagraph = true
-    }
-  }
-
-  // Detect list type and position after marker
-  let isOrdered
-  let markerValue
-  let posAfterMarker
-  if ((posAfterMarker = skipOrderedListMarker(state, nextLine)) >= 0) {
-    isOrdered = true
-    start = state.bMarks[nextLine] + state.tShift[nextLine]
-    markerValue = Number(state.src.slice(start, posAfterMarker - 1))
-
-    // If we're starting a new ordered list right after
-    // a paragraph, it should start with 1.
-    if (isTerminatingParagraph && markerValue !== 1) return false
-  } else if ((posAfterMarker = skipBulletListMarker(state, nextLine)) >= 0) {
-    isOrdered = false
-  } else {
-    return false
-  }
-
-  // If we're starting a new unordered list right after
-  // a paragraph, first line should not be empty.
-  if (isTerminatingParagraph) {
-    if (state.skipSpaces(posAfterMarker) >= state.eMarks[nextLine]) return false
-  }
-
-  // For validation mode we can terminate immediately
-  if (silent) { return true }
-
-  // We should terminate list on style change. Remember first one to compare.
-  const markerCharCode = state.src.charCodeAt(posAfterMarker - 1)
-
-  // Start list
-  const listTokIdx = state.tokens.length
-
-  if (isOrdered) {
-    token       = state.push('ordered_list_open', 'ol', 1)
-    if (markerValue !== 1) {
-      token.attrs = [['start', markerValue]]
-    }
-  } else {
-    token       = state.push('bullet_list_open', 'ul', 1)
-  }
-
-  const listLines = [nextLine, 0]
-  token.map    = listLines
-  token.markup = String.fromCharCode(markerCharCode)
-
-  //
-  // Iterate list items
-  //
-
-  let prevEmptyEnd = false
-  const terminatorRules = state.md.block.ruler.getRules('list')
-
-  const oldParentType = state.parentType
-  state.parentType = 'list'
-
-  while (nextLine < endLine) {
-    pos = posAfterMarker
-    max = state.eMarks[nextLine]
-
-    const initial = state.sCount[nextLine] + posAfterMarker - (state.bMarks[nextLine] + state.tShift[nextLine])
-    let offset = initial
-
-    while (pos < max) {
-      const ch = state.src.charCodeAt(pos)
-
-      if (ch === 0x09) {
-        offset += 4 - (offset + state.bsCount[nextLine]) % 4
-      } else if (ch === 0x20) {
-        offset++
-      } else {
-        break
-      }
-
-      pos++
-    }
-
-    const contentStart = pos
-    let indentAfterMarker
-
-    if (contentStart >= max) {
-      // trimming space in "-    \n  3" case, indent is 1 here
-      indentAfterMarker = 1
-    } else {
-      indentAfterMarker = offset - initial
-    }
-
-    // If we have more than 4 spaces, the indent is 1
-    // (the rest is just indented code block)
-    if (indentAfterMarker > 4) { indentAfterMarker = 1 }
-
-    // "  -  test"
-    //  ^^^^^ - calculating total length of this thing
-    const indent = initial + indentAfterMarker
-
-    // Run subparser & write tokens
-    token        = state.push('list_item_open', 'li', 1)
-    token.markup = String.fromCharCode(markerCharCode)
-    const itemLines = [nextLine, 0]
-    token.map    = itemLines
-    if (isOrdered) {
-      token.info = state.src.slice(start, posAfterMarker - 1)
-    }
-
-    // change current state, then restore it after parser subcall
-    const oldTight = state.tight
-    const oldTShift = state.tShift[nextLine]
-    const oldSCount = state.sCount[nextLine]
-
-    //  - example list
-    // ^ listIndent position will be here
-    //   ^ blkIndent position will be here
-    //
-    const oldListIndent = state.listIndent
-    state.listIndent = state.blkIndent
-    state.blkIndent = indent
-
-    state.tight = true
-    state.tShift[nextLine] = contentStart - state.bMarks[nextLine]
-    state.sCount[nextLine] = offset
-
-    if (contentStart >= max && state.isEmpty(nextLine + 1)) {
-      // workaround for this case
-      // (list item is empty, list terminates before "foo"):
-      // ~~~~~~~~
-      //   -
-      //
-      //     foo
-      // ~~~~~~~~
-      state.line = Math.min(state.line + 2, endLine)
-    } else {
-      state.md.block.tokenize(state, nextLine, endLine, true)
-    }
-
-    // If any of list item is tight, mark list as tight
-    if (!state.tight || prevEmptyEnd) {
-      tight = false
-    }
-    // Item become loose if finish with empty line,
-    // but we should filter last element, because it means list finish
-    prevEmptyEnd = (state.line - nextLine) > 1 && state.isEmpty(state.line - 1)
-
-    state.blkIndent = state.listIndent
-    state.listIndent = oldListIndent
-    state.tShift[nextLine] = oldTShift
-    state.sCount[nextLine] = oldSCount
-    state.tight = oldTight
-
-    token        = state.push('list_item_close', 'li', -1)
-    token.markup = String.fromCharCode(markerCharCode)
-
-    nextLine = state.line
-    itemLines[1] = nextLine
-
-    if (nextLine >= endLine) { break }
-
-    //
-    // Try to check if list is terminated or continued.
-    //
-    if (state.sCount[nextLine] < state.blkIndent) { break }
-
-    // if it's indented more than 3 spaces, it should be a code block
-    if (state.sCount[nextLine] - state.blkIndent >= 4) { break }
-
-    // fail if terminating block found
-    let terminate = false
-    for (let i = 0, l = terminatorRules.length; i < l; i++) {
-      if (terminatorRules[i](state, nextLine, endLine, true)) {
-        terminate = true
-        break
-      }
-    }
-    if (terminate) { break }
-
-    // fail if list has another type
-    if (isOrdered) {
-      posAfterMarker = skipOrderedListMarker(state, nextLine)
-      if (posAfterMarker < 0) { break }
-      start = state.bMarks[nextLine] + state.tShift[nextLine]
-    } else {
-      posAfterMarker = skipBulletListMarker(state, nextLine)
-      if (posAfterMarker < 0) { break }
-    }
-
-    if (markerCharCode !== state.src.charCodeAt(posAfterMarker - 1)) { break }
-  }
-
-  // Finalize list
-  if (isOrdered) {
-    token = state.push('ordered_list_close', 'ol', -1)
-  } else {
-    token = state.push('bullet_list_close', 'ul', -1)
-  }
-  token.markup = String.fromCharCode(markerCharCode)
-
-  listLines[1] = nextLine
-  state.line = nextLine
-
-  state.parentType = oldParentType
-
-  // mark paragraphs tight if needed
-  if (tight) {
-    markTightParagraphs(state, listTokIdx)
-  }
-
-  return true
-}
diff --git a/packages/markdown-it-14.1.0/lib/rules_block/paragraph.mjs b/packages/markdown-it-14.1.0/lib/rules_block/paragraph.mjs
deleted file mode 100644
index 6ecdcef..0000000
--- a/packages/markdown-it-14.1.0/lib/rules_block/paragraph.mjs
+++ /dev/null
@@ -1,46 +0,0 @@
-// Paragraph
-
-export default function paragraph (state, startLine, endLine) {
-  const terminatorRules = state.md.block.ruler.getRules('paragraph')
-  const oldParentType = state.parentType
-  let nextLine = startLine + 1
-  state.parentType = 'paragraph'
-
-  // jump line-by-line until empty one or EOF
-  for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {
-    // this would be a code block normally, but after paragraph
-    // it's considered a lazy continuation regardless of what's there
-    if (state.sCount[nextLine] - state.blkIndent > 3) { continue }
-
-    // quirk for blockquotes, this line should already be checked by that rule
-    if (state.sCount[nextLine] < 0) { continue }
-
-    // Some tags can terminate paragraph without empty line.
-    let terminate = false
-    for (let i = 0, l = terminatorRules.length; i < l; i++) {
-      if (terminatorRules[i](state, nextLine, endLine, true)) {
-        terminate = true
-        break
-      }
-    }
-    if (terminate) { break }
-  }
-
-  const content = state.getLines(startLine, nextLine, state.blkIndent, false).trim()
-
-  state.line = nextLine
-
-  const token_o    = state.push('paragraph_open', 'p', 1)
-  token_o.map      = [startLine, state.line]
-
-  const token_i    = state.push('inline', '', 0)
-  token_i.content  = content
-  token_i.map      = [startLine, state.line]
-  token_i.children = []
-
-  state.push('paragraph_close', 'p', -1)
-
-  state.parentType = oldParentType
-
-  return true
-}
diff --git a/packages/markdown-it-14.1.0/lib/rules_block/reference.mjs b/packages/markdown-it-14.1.0/lib/rules_block/reference.mjs
deleted file mode 100644
index 4166286..0000000
--- a/packages/markdown-it-14.1.0/lib/rules_block/reference.mjs
+++ /dev/null
@@ -1,212 +0,0 @@
-import { isSpace, normalizeReference } from '../common/utils.mjs'
-
-export default function reference (state, startLine, _endLine, silent) {
-  let pos = state.bMarks[startLine] + state.tShift[startLine]
-  let max = state.eMarks[startLine]
-  let nextLine = startLine + 1
-
-  // if it's indented more than 3 spaces, it should be a code block
-  if (state.sCount[startLine] - state.blkIndent >= 4) { return false }
-
-  if (state.src.charCodeAt(pos) !== 0x5B/* [ */) { return false }
-
-  function getNextLine (nextLine) {
-    const endLine = state.lineMax
-
-    if (nextLine >= endLine || state.isEmpty(nextLine)) {
-      // empty line or end of input
-      return null
-    }
-
-    let isContinuation = false
-
-    // this would be a code block normally, but after paragraph
-    // it's considered a lazy continuation regardless of what's there
-    if (state.sCount[nextLine] - state.blkIndent > 3) { isContinuation = true }
-
-    // quirk for blockquotes, this line should already be checked by that rule
-    if (state.sCount[nextLine] < 0) { isContinuation = true }
-
-    if (!isContinuation) {
-      const terminatorRules = state.md.block.ruler.getRules('reference')
-      const oldParentType = state.parentType
-      state.parentType = 'reference'
-
-      // Some tags can terminate paragraph without empty line.
-      let terminate = false
-      for (let i = 0, l = terminatorRules.length; i < l; i++) {
-        if (terminatorRules[i](state, nextLine, endLine, true)) {
-          terminate = true
-          break
-        }
-      }
-
-      state.parentType = oldParentType
-      if (terminate) {
-        // terminated by another block
-        return null
-      }
-    }
-
-    const pos = state.bMarks[nextLine] + state.tShift[nextLine]
-    const max = state.eMarks[nextLine]
-
-    // max + 1 explicitly includes the newline
-    return state.src.slice(pos, max + 1)
-  }
-
-  let str = state.src.slice(pos, max + 1)
-
-  max = str.length
-  let labelEnd = -1
-
-  for (pos = 1; pos < max; pos++) {
-    const ch = str.charCodeAt(pos)
-    if (ch === 0x5B /* [ */) {
-      return false
-    } else if (ch === 0x5D /* ] */) {
-      labelEnd = pos
-      break
-    } else if (ch === 0x0A /* \n */) {
-      const lineContent = getNextLine(nextLine)
-      if (lineContent !== null) {
-        str += lineContent
-        max = str.length
-        nextLine++
-      }
-    } else if (ch === 0x5C /* \ */) {
-      pos++
-      if (pos < max && str.charCodeAt(pos) === 0x0A) {
-        const lineContent = getNextLine(nextLine)
-        if (lineContent !== null) {
-          str += lineContent
-          max = str.length
-          nextLine++
-        }
-      }
-    }
-  }
-
-  if (labelEnd < 0 || str.charCodeAt(labelEnd + 1) !== 0x3A/* : */) { return false }
-
-  // [label]:   destination   'title'
-  //         ^^^ skip optional whitespace here
-  for (pos = labelEnd + 2; pos < max; pos++) {
-    const ch = str.charCodeAt(pos)
-    if (ch === 0x0A) {
-      const lineContent = getNextLine(nextLine)
-      if (lineContent !== null) {
-        str += lineContent
-        max = str.length
-        nextLine++
-      }
-    } else if (isSpace(ch)) {
-      /* eslint no-empty:0 */
-    } else {
-      break
-    }
-  }
-
-  // [label]:   destination   'title'
-  //            ^^^^^^^^^^^ parse this
-  const destRes = state.md.helpers.parseLinkDestination(str, pos, max)
-  if (!destRes.ok) { return false }
-
-  const href = state.md.normalizeLink(destRes.str)
-  if (!state.md.validateLink(href)) { return false }
-
-  pos = destRes.pos
-
-  // save cursor state, we could require to rollback later
-  const destEndPos = pos
-  const destEndLineNo = nextLine
-
-  // [label]:   destination   'title'
-  //                       ^^^ skipping those spaces
-  const start = pos
-  for (; pos < max; pos++) {
-    const ch = str.charCodeAt(pos)
-    if (ch === 0x0A) {
-      const lineContent = getNextLine(nextLine)
-      if (lineContent !== null) {
-        str += lineContent
-        max = str.length
-        nextLine++
-      }
-    } else if (isSpace(ch)) {
-      /* eslint no-empty:0 */
-    } else {
-      break
-    }
-  }
-
-  // [label]:   destination   'title'
-  //                          ^^^^^^^ parse this
-  let titleRes = state.md.helpers.parseLinkTitle(str, pos, max)
-  while (titleRes.can_continue) {
-    const lineContent = getNextLine(nextLine)
-    if (lineContent === null) break
-    str += lineContent
-    pos = max
-    max = str.length
-    nextLine++
-    titleRes = state.md.helpers.parseLinkTitle(str, pos, max, titleRes)
-  }
-  let title
-
-  if (pos < max && start !== pos && titleRes.ok) {
-    title = titleRes.str
-    pos = titleRes.pos
-  } else {
-    title = ''
-    pos = destEndPos
-    nextLine = destEndLineNo
-  }
-
-  // skip trailing spaces until the rest of the line
-  while (pos < max) {
-    const ch = str.charCodeAt(pos)
-    if (!isSpace(ch)) { break }
-    pos++
-  }
-
-  if (pos < max && str.charCodeAt(pos) !== 0x0A) {
-    if (title) {
-      // garbage at the end of the line after title,
-      // but it could still be a valid reference if we roll back
-      title = ''
-      pos = destEndPos
-      nextLine = destEndLineNo
-      while (pos < max) {
-        const ch = str.charCodeAt(pos)
-        if (!isSpace(ch)) { break }
-        pos++
-      }
-    }
-  }
-
-  if (pos < max && str.charCodeAt(pos) !== 0x0A) {
-    // garbage at the end of the line
-    return false
-  }
-
-  const label = normalizeReference(str.slice(1, labelEnd))
-  if (!label) {
-    // CommonMark 0.20 disallows empty labels
-    return false
-  }
-
-  // Reference can not terminate anything. This check is for safety only.
-  /* istanbul ignore if */
-  if (silent) { return true }
-
-  if (typeof state.env.references === 'undefined') {
-    state.env.references = {}
-  }
-  if (typeof state.env.references[label] === 'undefined') {
-    state.env.references[label] = { title, href }
-  }
-
-  state.line = nextLine
-  return true
-}
diff --git a/packages/markdown-it-14.1.0/lib/rules_block/state_block.mjs b/packages/markdown-it-14.1.0/lib/rules_block/state_block.mjs
deleted file mode 100644
index 3c2a876..0000000
--- a/packages/markdown-it-14.1.0/lib/rules_block/state_block.mjs
+++ /dev/null
@@ -1,220 +0,0 @@
-// Parser state class
-
-import Token from '../token.mjs'
-import { isSpace } from '../common/utils.mjs'
-
-function StateBlock (src, md, env, tokens) {
-  this.src = src
-
-  // link to parser instance
-  this.md     = md
-
-  this.env = env
-
-  //
-  // Internal state vartiables
-  //
-
-  this.tokens = tokens
-
-  this.bMarks = []  // line begin offsets for fast jumps
-  this.eMarks = []  // line end offsets for fast jumps
-  this.tShift = []  // offsets of the first non-space characters (tabs not expanded)
-  this.sCount = []  // indents for each line (tabs expanded)
-
-  // An amount of virtual spaces (tabs expanded) between beginning
-  // of each line (bMarks) and real beginning of that line.
-  //
-  // It exists only as a hack because blockquotes override bMarks
-  // losing information in the process.
-  //
-  // It's used only when expanding tabs, you can think about it as
-  // an initial tab length, e.g. bsCount=21 applied to string `\t123`
-  // means first tab should be expanded to 4-21%4 === 3 spaces.
-  //
-  this.bsCount = []
-
-  // block parser variables
-
-  // required block content indent (for example, if we are
-  // inside a list, it would be positioned after list marker)
-  this.blkIndent  = 0
-  this.line       = 0 // line index in src
-  this.lineMax    = 0 // lines count
-  this.tight      = false  // loose/tight mode for lists
-  this.ddIndent   = -1 // indent of the current dd block (-1 if there isn't any)
-  this.listIndent = -1 // indent of the current list block (-1 if there isn't any)
-
-  // can be 'blockquote', 'list', 'root', 'paragraph' or 'reference'
-  // used in lists to determine if they interrupt a paragraph
-  this.parentType = 'root'
-
-  this.level = 0
-
-  // Create caches
-  // Generate markers.
-  const s = this.src
-
-  for (let start = 0, pos = 0, indent = 0, offset = 0, len = s.length, indent_found = false; pos < len; pos++) {
-    const ch = s.charCodeAt(pos)
-
-    if (!indent_found) {
-      if (isSpace(ch)) {
-        indent++
-
-        if (ch === 0x09) {
-          offset += 4 - offset % 4
-        } else {
-          offset++
-        }
-        continue
-      } else {
-        indent_found = true
-      }
-    }
-
-    if (ch === 0x0A || pos === len - 1) {
-      if (ch !== 0x0A) { pos++ }
-      this.bMarks.push(start)
-      this.eMarks.push(pos)
-      this.tShift.push(indent)
-      this.sCount.push(offset)
-      this.bsCount.push(0)
-
-      indent_found = false
-      indent = 0
-      offset = 0
-      start = pos + 1
-    }
-  }
-
-  // Push fake entry to simplify cache bounds checks
-  this.bMarks.push(s.length)
-  this.eMarks.push(s.length)
-  this.tShift.push(0)
-  this.sCount.push(0)
-  this.bsCount.push(0)
-
-  this.lineMax = this.bMarks.length - 1 // don't count last fake line
-}
-
-// Push new token to "stream".
-//
-StateBlock.prototype.push = function (type, tag, nesting) {
-  const token = new Token(type, tag, nesting)
-  token.block = true
-
-  if (nesting < 0) this.level-- // closing tag
-  token.level = this.level
-  if (nesting > 0) this.level++ // opening tag
-
-  this.tokens.push(token)
-  return token
-}
-
-StateBlock.prototype.isEmpty = function isEmpty (line) {
-  return this.bMarks[line] + this.tShift[line] >= this.eMarks[line]
-}
-
-StateBlock.prototype.skipEmptyLines = function skipEmptyLines (from) {
-  for (let max = this.lineMax; from < max; from++) {
-    if (this.bMarks[from] + this.tShift[from] < this.eMarks[from]) {
-      break
-    }
-  }
-  return from
-}
-
-// Skip spaces from given position.
-StateBlock.prototype.skipSpaces = function skipSpaces (pos) {
-  for (let max = this.src.length; pos < max; pos++) {
-    const ch = this.src.charCodeAt(pos)
-    if (!isSpace(ch)) { break }
-  }
-  return pos
-}
-
-// Skip spaces from given position in reverse.
-StateBlock.prototype.skipSpacesBack = function skipSpacesBack (pos, min) {
-  if (pos <= min) { return pos }
-
-  while (pos > min) {
-    if (!isSpace(this.src.charCodeAt(--pos))) { return pos + 1 }
-  }
-  return pos
-}
-
-// Skip char codes from given position
-StateBlock.prototype.skipChars = function skipChars (pos, code) {
-  for (let max = this.src.length; pos < max; pos++) {
-    if (this.src.charCodeAt(pos) !== code) { break }
-  }
-  return pos
-}
-
-// Skip char codes reverse from given position - 1
-StateBlock.prototype.skipCharsBack = function skipCharsBack (pos, code, min) {
-  if (pos <= min) { return pos }
-
-  while (pos > min) {
-    if (code !== this.src.charCodeAt(--pos)) { return pos + 1 }
-  }
-  return pos
-}
-
-// cut lines range from source.
-StateBlock.prototype.getLines = function getLines (begin, end, indent, keepLastLF) {
-  if (begin >= end) {
-    return ''
-  }
-
-  const queue = new Array(end - begin)
-
-  for (let i = 0, line = begin; line < end; line++, i++) {
-    let lineIndent = 0
-    const lineStart = this.bMarks[line]
-    let first = lineStart
-    let last
-
-    if (line + 1 < end || keepLastLF) {
-      // No need for bounds check because we have fake entry on tail.
-      last = this.eMarks[line] + 1
-    } else {
-      last = this.eMarks[line]
-    }
-
-    while (first < last && lineIndent < indent) {
-      const ch = this.src.charCodeAt(first)
-
-      if (isSpace(ch)) {
-        if (ch === 0x09) {
-          lineIndent += 4 - (lineIndent + this.bsCount[line]) % 4
-        } else {
-          lineIndent++
-        }
-      } else if (first - lineStart < this.tShift[line]) {
-        // patched tShift masked characters to look like spaces (blockquotes, list markers)
-        lineIndent++
-      } else {
-        break
-      }
-
-      first++
-    }
-
-    if (lineIndent > indent) {
-      // partially expanding tabs in code blocks, e.g '\t\tfoobar'
-      // with indent=2 becomes '  \tfoobar'
-      queue[i] = new Array(lineIndent - indent + 1).join(' ') + this.src.slice(first, last)
-    } else {
-      queue[i] = this.src.slice(first, last)
-    }
-  }
-
-  return queue.join('')
-}
-
-// re-export Token class to use in block rules
-StateBlock.prototype.Token = Token
-
-export default StateBlock
diff --git a/packages/markdown-it-14.1.0/lib/rules_block/table.mjs b/packages/markdown-it-14.1.0/lib/rules_block/table.mjs
deleted file mode 100644
index be0ba0a..0000000
--- a/packages/markdown-it-14.1.0/lib/rules_block/table.mjs
+++ /dev/null
@@ -1,228 +0,0 @@
-// GFM table, https://github.github.com/gfm/#tables-extension-
-
-import { isSpace } from '../common/utils.mjs'
-
-// Limit the amount of empty autocompleted cells in a table,
-// see https://github.com/markdown-it/markdown-it/issues/1000,
-//
-// Both pulldown-cmark and commonmark-hs limit the number of cells this way to ~200k.
-// We set it to 65k, which can expand user input by a factor of x370
-// (256x256 square is 1.8kB expanded into 650kB).
-const MAX_AUTOCOMPLETED_CELLS = 0x10000
-
-function getLine (state, line) {
-  const pos = state.bMarks[line] + state.tShift[line]
-  const max = state.eMarks[line]
-
-  return state.src.slice(pos, max)
-}
-
-function escapedSplit (str) {
-  const result = []
-  const max = str.length
-
-  let pos = 0
-  let ch = str.charCodeAt(pos)
-  let isEscaped = false
-  let lastPos = 0
-  let current = ''
-
-  while (pos < max) {
-    if (ch === 0x7c/* | */) {
-      if (!isEscaped) {
-        // pipe separating cells, '|'
-        result.push(current + str.substring(lastPos, pos))
-        current = ''
-        lastPos = pos + 1
-      } else {
-        // escaped pipe, '\|'
-        current += str.substring(lastPos, pos - 1)
-        lastPos = pos
-      }
-    }
-
-    isEscaped = (ch === 0x5c/* \ */)
-    pos++
-
-    ch = str.charCodeAt(pos)
-  }
-
-  result.push(current + str.substring(lastPos))
-
-  return result
-}
-
-export default function table (state, startLine, endLine, silent) {
-  // should have at least two lines
-  if (startLine + 2 > endLine) { return false }
-
-  let nextLine = startLine + 1
-
-  if (state.sCount[nextLine] < state.blkIndent) { return false }
-
-  // if it's indented more than 3 spaces, it should be a code block
-  if (state.sCount[nextLine] - state.blkIndent >= 4) { return false }
-
-  // first character of the second line should be '|', '-', ':',
-  // and no other characters are allowed but spaces;
-  // basically, this is the equivalent of /^[-:|][-:|\s]*$/ regexp
-
-  let pos = state.bMarks[nextLine] + state.tShift[nextLine]
-  if (pos >= state.eMarks[nextLine]) { return false }
-
-  const firstCh = state.src.charCodeAt(pos++)
-  if (firstCh !== 0x7C/* | */ && firstCh !== 0x2D/* - */ && firstCh !== 0x3A/* : */) { return false }
-
-  if (pos >= state.eMarks[nextLine]) { return false }
-
-  const secondCh = state.src.charCodeAt(pos++)
-  if (secondCh !== 0x7C/* | */ && secondCh !== 0x2D/* - */ && secondCh !== 0x3A/* : */ && !isSpace(secondCh)) {
-    return false
-  }
-
-  // if first character is '-', then second character must not be a space
-  // (due to parsing ambiguity with list)
-  if (firstCh === 0x2D/* - */ && isSpace(secondCh)) { return false }
-
-  while (pos < state.eMarks[nextLine]) {
-    const ch = state.src.charCodeAt(pos)
-
-    if (ch !== 0x7C/* | */ && ch !== 0x2D/* - */ && ch !== 0x3A/* : */ && !isSpace(ch)) { return false }
-
-    pos++
-  }
-
-  let lineText = getLine(state, startLine + 1)
-  let columns = lineText.split('|')
-  const aligns = []
-  for (let i = 0; i < columns.length; i++) {
-    const t = columns[i].trim()
-    if (!t) {
-      // allow empty columns before and after table, but not in between columns;
-      // e.g. allow ` |---| `, disallow ` ---||--- `
-      if (i === 0 || i === columns.length - 1) {
-        continue
-      } else {
-        return false
-      }
-    }
-
-    if (!/^:?-+:?$/.test(t)) { return false }
-    if (t.charCodeAt(t.length - 1) === 0x3A/* : */) {
-      aligns.push(t.charCodeAt(0) === 0x3A/* : */ ? 'center' : 'right')
-    } else if (t.charCodeAt(0) === 0x3A/* : */) {
-      aligns.push('left')
-    } else {
-      aligns.push('')
-    }
-  }
-
-  lineText = getLine(state, startLine).trim()
-  if (lineText.indexOf('|') === -1) { return false }
-  if (state.sCount[startLine] - state.blkIndent >= 4) { return false }
-  columns = escapedSplit(lineText)
-  if (columns.length && columns[0] === '') columns.shift()
-  if (columns.length && columns[columns.length - 1] === '') columns.pop()
-
-  // header row will define an amount of columns in the entire table,
-  // and align row should be exactly the same (the rest of the rows can differ)
-  const columnCount = columns.length
-  if (columnCount === 0 || columnCount !== aligns.length) { return false }
-
-  if (silent) { return true }
-
-  const oldParentType = state.parentType
-  state.parentType = 'table'
-
-  // use 'blockquote' lists for termination because it's
-  // the most similar to tables
-  const terminatorRules = state.md.block.ruler.getRules('blockquote')
-
-  const token_to = state.push('table_open', 'table', 1)
-  const tableLines = [startLine, 0]
-  token_to.map = tableLines
-
-  const token_tho = state.push('thead_open', 'thead', 1)
-  token_tho.map = [startLine, startLine + 1]
-
-  const token_htro = state.push('tr_open', 'tr', 1)
-  token_htro.map = [startLine, startLine + 1]
-
-  for (let i = 0; i < columns.length; i++) {
-    const token_ho = state.push('th_open', 'th', 1)
-    if (aligns[i]) {
-      token_ho.attrs  = [['style', 'text-align:' + aligns[i]]]
-    }
-
-    const token_il = state.push('inline', '', 0)
-    token_il.content  = columns[i].trim()
-    token_il.children = []
-
-    state.push('th_close', 'th', -1)
-  }
-
-  state.push('tr_close', 'tr', -1)
-  state.push('thead_close', 'thead', -1)
-
-  let tbodyLines
-  let autocompletedCells = 0
-
-  for (nextLine = startLine + 2; nextLine < endLine; nextLine++) {
-    if (state.sCount[nextLine] < state.blkIndent) { break }
-
-    let terminate = false
-    for (let i = 0, l = terminatorRules.length; i < l; i++) {
-      if (terminatorRules[i](state, nextLine, endLine, true)) {
-        terminate = true
-        break
-      }
-    }
-
-    if (terminate) { break }
-    lineText = getLine(state, nextLine).trim()
-    if (!lineText) { break }
-    if (state.sCount[nextLine] - state.blkIndent >= 4) { break }
-    columns = escapedSplit(lineText)
-    if (columns.length && columns[0] === '') columns.shift()
-    if (columns.length && columns[columns.length - 1] === '') columns.pop()
-
-    // note: autocomplete count can be negative if user specifies more columns than header,
-    // but that does not affect intended use (which is limiting expansion)
-    autocompletedCells += columnCount - columns.length
-    if (autocompletedCells > MAX_AUTOCOMPLETED_CELLS) { break }
-
-    if (nextLine === startLine + 2) {
-      const token_tbo = state.push('tbody_open', 'tbody', 1)
-      token_tbo.map = tbodyLines = [startLine + 2, 0]
-    }
-
-    const token_tro = state.push('tr_open', 'tr', 1)
-    token_tro.map = [nextLine, nextLine + 1]
-
-    for (let i = 0; i < columnCount; i++) {
-      const token_tdo = state.push('td_open', 'td', 1)
-      if (aligns[i]) {
-        token_tdo.attrs  = [['style', 'text-align:' + aligns[i]]]
-      }
-
-      const token_il = state.push('inline', '', 0)
-      token_il.content  = columns[i] ? columns[i].trim() : ''
-      token_il.children = []
-
-      state.push('td_close', 'td', -1)
-    }
-    state.push('tr_close', 'tr', -1)
-  }
-
-  if (tbodyLines) {
-    state.push('tbody_close', 'tbody', -1)
-    tbodyLines[1] = nextLine
-  }
-
-  state.push('table_close', 'table', -1)
-  tableLines[1] = nextLine
-
-  state.parentType = oldParentType
-  state.line = nextLine
-  return true
-}
diff --git a/packages/markdown-it-14.1.0/lib/rules_core/block.mjs b/packages/markdown-it-14.1.0/lib/rules_core/block.mjs
deleted file mode 100644
index 526cb48..0000000
--- a/packages/markdown-it-14.1.0/lib/rules_core/block.mjs
+++ /dev/null
@@ -1,13 +0,0 @@
-export default function block (state) {
-  let token
-
-  if (state.inlineMode) {
-    token          = new state.Token('inline', '', 0)
-    token.content  = state.src
-    token.map      = [0, 1]
-    token.children = []
-    state.tokens.push(token)
-  } else {
-    state.md.block.parse(state.src, state.md, state.env, state.tokens)
-  }
-}
diff --git a/packages/markdown-it-14.1.0/lib/rules_core/inline.mjs b/packages/markdown-it-14.1.0/lib/rules_core/inline.mjs
deleted file mode 100644
index efd6c07..0000000
--- a/packages/markdown-it-14.1.0/lib/rules_core/inline.mjs
+++ /dev/null
@@ -1,11 +0,0 @@
-export default function inline (state) {
-  const tokens = state.tokens
-
-  // Parse inlines
-  for (let i = 0, l = tokens.length; i < l; i++) {
-    const tok = tokens[i]
-    if (tok.type === 'inline') {
-      state.md.inline.parse(tok.content, state.md, state.env, tok.children)
-    }
-  }
-}
diff --git a/packages/markdown-it-14.1.0/lib/rules_core/linkify.mjs b/packages/markdown-it-14.1.0/lib/rules_core/linkify.mjs
deleted file mode 100644
index a225280..0000000
--- a/packages/markdown-it-14.1.0/lib/rules_core/linkify.mjs
+++ /dev/null
@@ -1,134 +0,0 @@
-// Replace link-like texts with link nodes.
-//
-// Currently restricted by `md.validateLink()` to http/https/ftp
-//
-
-import { arrayReplaceAt } from '../common/utils.mjs'
-
-function isLinkOpen (str) {
-  return /^<a[>\s]/i.test(str)
-}
-function isLinkClose (str) {
-  return /^<\/a\s*>/i.test(str)
-}
-
-export default function linkify (state) {
-  const blockTokens = state.tokens
-
-  if (!state.md.options.linkify) { return }
-
-  for (let j = 0, l = blockTokens.length; j < l; j++) {
-    if (blockTokens[j].type !== 'inline' ||
-        !state.md.linkify.pretest(blockTokens[j].content)) {
-      continue
-    }
-
-    let tokens = blockTokens[j].children
-
-    let htmlLinkLevel = 0
-
-    // We scan from the end, to keep position when new tags added.
-    // Use reversed logic in links start/end match
-    for (let i = tokens.length - 1; i >= 0; i--) {
-      const currentToken = tokens[i]
-
-      // Skip content of markdown links
-      if (currentToken.type === 'link_close') {
-        i--
-        while (tokens[i].level !== currentToken.level && tokens[i].type !== 'link_open') {
-          i--
-        }
-        continue
-      }
-
-      // Skip content of html tag links
-      if (currentToken.type === 'html_inline') {
-        if (isLinkOpen(currentToken.content) && htmlLinkLevel > 0) {
-          htmlLinkLevel--
-        }
-        if (isLinkClose(currentToken.content)) {
-          htmlLinkLevel++
-        }
-      }
-      if (htmlLinkLevel > 0) { continue }
-
-      if (currentToken.type === 'text' && state.md.linkify.test(currentToken.content)) {
-        const text = currentToken.content
-        let links = state.md.linkify.match(text)
-
-        // Now split string to nodes
-        const nodes = []
-        let level = currentToken.level
-        let lastPos = 0
-
-        // forbid escape sequence at the start of the string,
-        // this avoids http\://example.com/ from being linkified as
-        // http:<a href="//example.com/">//example.com/</a>
-        if (links.length > 0 &&
-            links[0].index === 0 &&
-            i > 0 &&
-            tokens[i - 1].type === 'text_special') {
-          links = links.slice(1)
-        }
-
-        for (let ln = 0; ln < links.length; ln++) {
-          const url = links[ln].url
-          const fullUrl = state.md.normalizeLink(url)
-          if (!state.md.validateLink(fullUrl)) { continue }
-
-          let urlText = links[ln].text
-
-          // Linkifier might send raw hostnames like "example.com", where url
-          // starts with domain name. So we prepend http:// in those cases,
-          // and remove it afterwards.
-          //
-          if (!links[ln].schema) {
-            urlText = state.md.normalizeLinkText('http://' + urlText).replace(/^http:\/\//, '')
-          } else if (links[ln].schema === 'mailto:' && !/^mailto:/i.test(urlText)) {
-            urlText = state.md.normalizeLinkText('mailto:' + urlText).replace(/^mailto:/, '')
-          } else {
-            urlText = state.md.normalizeLinkText(urlText)
-          }
-
-          const pos = links[ln].index
-
-          if (pos > lastPos) {
-            const token   = new state.Token('text', '', 0)
-            token.content = text.slice(lastPos, pos)
-            token.level   = level
-            nodes.push(token)
-          }
-
-          const token_o   = new state.Token('link_open', 'a', 1)
-          token_o.attrs   = [['href', fullUrl]]
-          token_o.level   = level++
-          token_o.markup  = 'linkify'
-          token_o.info    = 'auto'
-          nodes.push(token_o)
-
-          const token_t   = new state.Token('text', '', 0)
-          token_t.content = urlText
-          token_t.level   = level
-          nodes.push(token_t)
-
-          const token_c   = new state.Token('link_close', 'a', -1)
-          token_c.level   = --level
-          token_c.markup  = 'linkify'
-          token_c.info    = 'auto'
-          nodes.push(token_c)
-
-          lastPos = links[ln].lastIndex
-        }
-        if (lastPos < text.length) {
-          const token   = new state.Token('text', '', 0)
-          token.content = text.slice(lastPos)
-          token.level   = level
-          nodes.push(token)
-        }
-
-        // replace current node
-        blockTokens[j].children = tokens = arrayReplaceAt(tokens, i, nodes)
-      }
-    }
-  }
-}
diff --git a/packages/markdown-it-14.1.0/lib/rules_core/normalize.mjs b/packages/markdown-it-14.1.0/lib/rules_core/normalize.mjs
deleted file mode 100644
index dfb67ef..0000000
--- a/packages/markdown-it-14.1.0/lib/rules_core/normalize.mjs
+++ /dev/null
@@ -1,17 +0,0 @@
-// Normalize input string
-
-// https://spec.commonmark.org/0.29/#line-ending
-const NEWLINES_RE  = /\r\n?|\n/g
-const NULL_RE      = /\0/g
-
-export default function normalize (state) {
-  let str
-
-  // Normalize newlines
-  str = state.src.replace(NEWLINES_RE, '\n')
-
-  // Replace NULL characters
-  str = str.replace(NULL_RE, '\uFFFD')
-
-  state.src = str
-}
diff --git a/packages/markdown-it-14.1.0/lib/rules_core/replacements.mjs b/packages/markdown-it-14.1.0/lib/rules_core/replacements.mjs
deleted file mode 100644
index b18ecd9..0000000
--- a/packages/markdown-it-14.1.0/lib/rules_core/replacements.mjs
+++ /dev/null
@@ -1,101 +0,0 @@
-// Simple typographic replacements
-//
-// (c) (C) → ©
-// (tm) (TM) → ™
-// (r) (R) → ®
-// +- → ±
-// ... → … (also ?.... → ?.., !.... → !..)
-// ???????? → ???, !!!!! → !!!, `,,` → `,`
-// -- → &ndash;, --- → &mdash;
-//
-
-// TODO:
-// - fractionals 1/2, 1/4, 3/4 -> ½, ¼, ¾
-// - multiplications 2 x 4 -> 2 × 4
-
-const RARE_RE = /\+-|\.\.|\?\?\?\?|!!!!|,,|--/
-
-// Workaround for phantomjs - need regex without /g flag,
-// or root check will fail every second time
-const SCOPED_ABBR_TEST_RE = /\((c|tm|r)\)/i
-
-const SCOPED_ABBR_RE = /\((c|tm|r)\)/ig
-const SCOPED_ABBR = {
-  c: '©',
-  r: '®',
-  tm: '™'
-}
-
-function replaceFn (match, name) {
-  return SCOPED_ABBR[name.toLowerCase()]
-}
-
-function replace_scoped (inlineTokens) {
-  let inside_autolink = 0
-
-  for (let i = inlineTokens.length - 1; i >= 0; i--) {
-    const token = inlineTokens[i]
-
-    if (token.type === 'text' && !inside_autolink) {
-      token.content = token.content.replace(SCOPED_ABBR_RE, replaceFn)
-    }
-
-    if (token.type === 'link_open' && token.info === 'auto') {
-      inside_autolink--
-    }
-
-    if (token.type === 'link_close' && token.info === 'auto') {
-      inside_autolink++
-    }
-  }
-}
-
-function replace_rare (inlineTokens) {
-  let inside_autolink = 0
-
-  for (let i = inlineTokens.length - 1; i >= 0; i--) {
-    const token = inlineTokens[i]
-
-    if (token.type === 'text' && !inside_autolink) {
-      if (RARE_RE.test(token.content)) {
-        token.content = token.content
-          .replace(/\+-/g, '±')
-          // .., ..., ....... -> …
-          // but ?..... & !..... -> ?.. & !..
-          .replace(/\.{2,}/g, '…').replace(/([?!])…/g, '$1..')
-          .replace(/([?!]){4,}/g, '$1$1$1').replace(/,{2,}/g, ',')
-          // em-dash
-          .replace(/(^|[^-])---(?=[^-]|$)/mg, '$1\u2014')
-          // en-dash
-          .replace(/(^|\s)--(?=\s|$)/mg, '$1\u2013')
-          .replace(/(^|[^-\s])--(?=[^-\s]|$)/mg, '$1\u2013')
-      }
-    }
-
-    if (token.type === 'link_open' && token.info === 'auto') {
-      inside_autolink--
-    }
-
-    if (token.type === 'link_close' && token.info === 'auto') {
-      inside_autolink++
-    }
-  }
-}
-
-export default function replace (state) {
-  let blkIdx
-
-  if (!state.md.options.typographer) { return }
-
-  for (blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {
-    if (state.tokens[blkIdx].type !== 'inline') { continue }
-
-    if (SCOPED_ABBR_TEST_RE.test(state.tokens[blkIdx].content)) {
-      replace_scoped(state.tokens[blkIdx].children)
-    }
-
-    if (RARE_RE.test(state.tokens[blkIdx].content)) {
-      replace_rare(state.tokens[blkIdx].children)
-    }
-  }
-}
diff --git a/packages/markdown-it-14.1.0/lib/rules_core/smartquotes.mjs b/packages/markdown-it-14.1.0/lib/rules_core/smartquotes.mjs
deleted file mode 100644
index 3b990ed..0000000
--- a/packages/markdown-it-14.1.0/lib/rules_core/smartquotes.mjs
+++ /dev/null
@@ -1,193 +0,0 @@
-// Convert straight quotation marks to typographic ones
-//
-
-import { isWhiteSpace, isPunctChar, isMdAsciiPunct } from '../common/utils.mjs'
-
-const QUOTE_TEST_RE = /['"]/
-const QUOTE_RE = /['"]/g
-const APOSTROPHE = '\u2019' /* ’ */
-
-function replaceAt (str, index, ch) {
-  return str.slice(0, index) + ch + str.slice(index + 1)
-}
-
-function process_inlines (tokens, state) {
-  let j
-
-  const stack = []
-
-  for (let i = 0; i < tokens.length; i++) {
-    const token = tokens[i]
-
-    const thisLevel = tokens[i].level
-
-    for (j = stack.length - 1; j >= 0; j--) {
-      if (stack[j].level <= thisLevel) { break }
-    }
-    stack.length = j + 1
-
-    if (token.type !== 'text') { continue }
-
-    let text = token.content
-    let pos = 0
-    let max = text.length
-
-    /* eslint no-labels:0,block-scoped-var:0 */
-    OUTER:
-    while (pos < max) {
-      QUOTE_RE.lastIndex = pos
-      const t = QUOTE_RE.exec(text)
-      if (!t) { break }
-
-      let canOpen = true
-      let canClose = true
-      pos = t.index + 1
-      const isSingle = (t[0] === "'")
-
-      // Find previous character,
-      // default to space if it's the beginning of the line
-      //
-      let lastChar = 0x20
-
-      if (t.index - 1 >= 0) {
-        lastChar = text.charCodeAt(t.index - 1)
-      } else {
-        for (j = i - 1; j >= 0; j--) {
-          if (tokens[j].type === 'softbreak' || tokens[j].type === 'hardbreak') break // lastChar defaults to 0x20
-          if (!tokens[j].content) continue // should skip all tokens except 'text', 'html_inline' or 'code_inline'
-
-          lastChar = tokens[j].content.charCodeAt(tokens[j].content.length - 1)
-          break
-        }
-      }
-
-      // Find next character,
-      // default to space if it's the end of the line
-      //
-      let nextChar = 0x20
-
-      if (pos < max) {
-        nextChar = text.charCodeAt(pos)
-      } else {
-        for (j = i + 1; j < tokens.length; j++) {
-          if (tokens[j].type === 'softbreak' || tokens[j].type === 'hardbreak') break // nextChar defaults to 0x20
-          if (!tokens[j].content) continue // should skip all tokens except 'text', 'html_inline' or 'code_inline'
-
-          nextChar = tokens[j].content.charCodeAt(0)
-          break
-        }
-      }
-
-      const isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(String.fromCharCode(lastChar))
-      const isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar))
-
-      const isLastWhiteSpace = isWhiteSpace(lastChar)
-      const isNextWhiteSpace = isWhiteSpace(nextChar)
-
-      if (isNextWhiteSpace) {
-        canOpen = false
-      } else if (isNextPunctChar) {
-        if (!(isLastWhiteSpace || isLastPunctChar)) {
-          canOpen = false
-        }
-      }
-
-      if (isLastWhiteSpace) {
-        canClose = false
-      } else if (isLastPunctChar) {
-        if (!(isNextWhiteSpace || isNextPunctChar)) {
-          canClose = false
-        }
-      }
-
-      if (nextChar === 0x22 /* " */ && t[0] === '"') {
-        if (lastChar >= 0x30 /* 0 */ && lastChar <= 0x39 /* 9 */) {
-          // special case: 1"" - count first quote as an inch
-          canClose = canOpen = false
-        }
-      }
-
-      if (canOpen && canClose) {
-        // Replace quotes in the middle of punctuation sequence, but not
-        // in the middle of the words, i.e.:
-        //
-        // 1. foo " bar " baz - not replaced
-        // 2. foo-"-bar-"-baz - replaced
-        // 3. foo"bar"baz     - not replaced
-        //
-        canOpen = isLastPunctChar
-        canClose = isNextPunctChar
-      }
-
-      if (!canOpen && !canClose) {
-        // middle of word
-        if (isSingle) {
-          token.content = replaceAt(token.content, t.index, APOSTROPHE)
-        }
-        continue
-      }
-
-      if (canClose) {
-        // this could be a closing quote, rewind the stack to get a match
-        for (j = stack.length - 1; j >= 0; j--) {
-          let item = stack[j]
-          if (stack[j].level < thisLevel) { break }
-          if (item.single === isSingle && stack[j].level === thisLevel) {
-            item = stack[j]
-
-            let openQuote
-            let closeQuote
-            if (isSingle) {
-              openQuote = state.md.options.quotes[2]
-              closeQuote = state.md.options.quotes[3]
-            } else {
-              openQuote = state.md.options.quotes[0]
-              closeQuote = state.md.options.quotes[1]
-            }
-
-            // replace token.content *before* tokens[item.token].content,
-            // because, if they are pointing at the same token, replaceAt
-            // could mess up indices when quote length != 1
-            token.content = replaceAt(token.content, t.index, closeQuote)
-            tokens[item.token].content = replaceAt(
-              tokens[item.token].content, item.pos, openQuote)
-
-            pos += closeQuote.length - 1
-            if (item.token === i) { pos += openQuote.length - 1 }
-
-            text = token.content
-            max = text.length
-
-            stack.length = j
-            continue OUTER
-          }
-        }
-      }
-
-      if (canOpen) {
-        stack.push({
-          token: i,
-          pos: t.index,
-          single: isSingle,
-          level: thisLevel
-        })
-      } else if (canClose && isSingle) {
-        token.content = replaceAt(token.content, t.index, APOSTROPHE)
-      }
-    }
-  }
-}
-
-export default function smartquotes (state) {
-  /* eslint max-depth:0 */
-  if (!state.md.options.typographer) { return }
-
-  for (let blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {
-    if (state.tokens[blkIdx].type !== 'inline' ||
-        !QUOTE_TEST_RE.test(state.tokens[blkIdx].content)) {
-      continue
-    }
-
-    process_inlines(state.tokens[blkIdx].children, state)
-  }
-}
diff --git a/packages/markdown-it-14.1.0/lib/rules_core/state_core.mjs b/packages/markdown-it-14.1.0/lib/rules_core/state_core.mjs
deleted file mode 100644
index a96c8fb..0000000
--- a/packages/markdown-it-14.1.0/lib/rules_core/state_core.mjs
+++ /dev/null
@@ -1,17 +0,0 @@
-// Core state object
-//
-
-import Token from '../token.mjs'
-
-function StateCore (src, md, env) {
-  this.src = src
-  this.env = env
-  this.tokens = []
-  this.inlineMode = false
-  this.md = md // link to parser instance
-}
-
-// re-export Token class to use in core rules
-StateCore.prototype.Token = Token
-
-export default StateCore
diff --git a/packages/markdown-it-14.1.0/lib/rules_core/text_join.mjs b/packages/markdown-it-14.1.0/lib/rules_core/text_join.mjs
deleted file mode 100644
index ee8f872..0000000
--- a/packages/markdown-it-14.1.0/lib/rules_core/text_join.mjs
+++ /dev/null
@@ -1,43 +0,0 @@
-// Join raw text tokens with the rest of the text
-//
-// This is set as a separate rule to provide an opportunity for plugins
-// to run text replacements after text join, but before escape join.
-//
-// For example, `\:)` shouldn't be replaced with an emoji.
-//
-
-export default function text_join (state) {
-  let curr, last
-  const blockTokens = state.tokens
-  const l = blockTokens.length
-
-  for (let j = 0; j < l; j++) {
-    if (blockTokens[j].type !== 'inline') continue
-
-    const tokens = blockTokens[j].children
-    const max = tokens.length
-
-    for (curr = 0; curr < max; curr++) {
-      if (tokens[curr].type === 'text_special') {
-        tokens[curr].type = 'text'
-      }
-    }
-
-    for (curr = last = 0; curr < max; curr++) {
-      if (tokens[curr].type === 'text' &&
-          curr + 1 < max &&
-          tokens[curr + 1].type === 'text') {
-        // collapse two adjacent text nodes
-        tokens[curr + 1].content = tokens[curr].content + tokens[curr + 1].content
-      } else {
-        if (curr !== last) { tokens[last] = tokens[curr] }
-
-        last++
-      }
-    }
-
-    if (curr !== last) {
-      tokens.length = last
-    }
-  }
-}
diff --git a/packages/markdown-it-14.1.0/lib/rules_inline/autolink.mjs b/packages/markdown-it-14.1.0/lib/rules_inline/autolink.mjs
deleted file mode 100644
index e71e66f..0000000
--- a/packages/markdown-it-14.1.0/lib/rules_inline/autolink.mjs
+++ /dev/null
@@ -1,72 +0,0 @@
-// Process autolinks '<protocol:...>'
-
-/* eslint max-len:0 */
-const EMAIL_RE    = /^([a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)$/
-/* eslint-disable-next-line no-control-regex */
-const AUTOLINK_RE = /^([a-zA-Z][a-zA-Z0-9+.-]{1,31}):([^<>\x00-\x20]*)$/
-
-export default function autolink (state, silent) {
-  let pos = state.pos
-
-  if (state.src.charCodeAt(pos) !== 0x3C/* < */) { return false }
-
-  const start = state.pos
-  const max = state.posMax
-
-  for (;;) {
-    if (++pos >= max) return false
-
-    const ch = state.src.charCodeAt(pos)
-
-    if (ch === 0x3C /* < */) return false
-    if (ch === 0x3E /* > */) break
-  }
-
-  const url = state.src.slice(start + 1, pos)
-
-  if (AUTOLINK_RE.test(url)) {
-    const fullUrl = state.md.normalizeLink(url)
-    if (!state.md.validateLink(fullUrl)) { return false }
-
-    if (!silent) {
-      const token_o   = state.push('link_open', 'a', 1)
-      token_o.attrs   = [['href', fullUrl]]
-      token_o.markup  = 'autolink'
-      token_o.info    = 'auto'
-
-      const token_t   = state.push('text', '', 0)
-      token_t.content = state.md.normalizeLinkText(url)
-
-      const token_c   = state.push('link_close', 'a', -1)
-      token_c.markup  = 'autolink'
-      token_c.info    = 'auto'
-    }
-
-    state.pos += url.length + 2
-    return true
-  }
-
-  if (EMAIL_RE.test(url)) {
-    const fullUrl = state.md.normalizeLink('mailto:' + url)
-    if (!state.md.validateLink(fullUrl)) { return false }
-
-    if (!silent) {
-      const token_o   = state.push('link_open', 'a', 1)
-      token_o.attrs   = [['href', fullUrl]]
-      token_o.markup  = 'autolink'
-      token_o.info    = 'auto'
-
-      const token_t   = state.push('text', '', 0)
-      token_t.content = state.md.normalizeLinkText(url)
-
-      const token_c   = state.push('link_close', 'a', -1)
-      token_c.markup  = 'autolink'
-      token_c.info    = 'auto'
-    }
-
-    state.pos += url.length + 2
-    return true
-  }
-
-  return false
-}
diff --git a/packages/markdown-it-14.1.0/lib/rules_inline/backticks.mjs b/packages/markdown-it-14.1.0/lib/rules_inline/backticks.mjs
deleted file mode 100644
index 5b926d0..0000000
--- a/packages/markdown-it-14.1.0/lib/rules_inline/backticks.mjs
+++ /dev/null
@@ -1,60 +0,0 @@
-// Parse backticks
-
-export default function backtick (state, silent) {
-  let pos = state.pos
-  const ch = state.src.charCodeAt(pos)
-
-  if (ch !== 0x60/* ` */) { return false }
-
-  const start = pos
-  pos++
-  const max = state.posMax
-
-  // scan marker length
-  while (pos < max && state.src.charCodeAt(pos) === 0x60/* ` */) { pos++ }
-
-  const marker = state.src.slice(start, pos)
-  const openerLength = marker.length
-
-  if (state.backticksScanned && (state.backticks[openerLength] || 0) <= start) {
-    if (!silent) state.pending += marker
-    state.pos += openerLength
-    return true
-  }
-
-  let matchEnd = pos
-  let matchStart
-
-  // Nothing found in the cache, scan until the end of the line (or until marker is found)
-  while ((matchStart = state.src.indexOf('`', matchEnd)) !== -1) {
-    matchEnd = matchStart + 1
-
-    // scan marker length
-    while (matchEnd < max && state.src.charCodeAt(matchEnd) === 0x60/* ` */) { matchEnd++ }
-
-    const closerLength = matchEnd - matchStart
-
-    if (closerLength === openerLength) {
-      // Found matching closer length.
-      if (!silent) {
-        const token = state.push('code_inline', 'code', 0)
-        token.markup = marker
-        token.content = state.src.slice(pos, matchStart)
-          .replace(/\n/g, ' ')
-          .replace(/^ (.+) $/, '$1')
-      }
-      state.pos = matchEnd
-      return true
-    }
-
-    // Some different length found, put it in cache as upper limit of where closer can be found
-    state.backticks[closerLength] = matchStart
-  }
-
-  // Scanned through the end, didn't find anything
-  state.backticksScanned = true
-
-  if (!silent) state.pending += marker
-  state.pos += openerLength
-  return true
-}
diff --git a/packages/markdown-it-14.1.0/lib/rules_inline/balance_pairs.mjs b/packages/markdown-it-14.1.0/lib/rules_inline/balance_pairs.mjs
deleted file mode 100644
index 8638d21..0000000
--- a/packages/markdown-it-14.1.0/lib/rules_inline/balance_pairs.mjs
+++ /dev/null
@@ -1,124 +0,0 @@
-// For each opening emphasis-like marker find a matching closing one
-//
-
-function processDelimiters (delimiters) {
-  const openersBottom = {}
-  const max = delimiters.length
-
-  if (!max) return
-
-  // headerIdx is the first delimiter of the current (where closer is) delimiter run
-  let headerIdx = 0
-  let lastTokenIdx = -2 // needs any value lower than -1
-  const jumps = []
-
-  for (let closerIdx = 0; closerIdx < max; closerIdx++) {
-    const closer = delimiters[closerIdx]
-
-    jumps.push(0)
-
-    // markers belong to same delimiter run if:
-    //  - they have adjacent tokens
-    //  - AND markers are the same
-    //
-    if (delimiters[headerIdx].marker !== closer.marker || lastTokenIdx !== closer.token - 1) {
-      headerIdx = closerIdx
-    }
-
-    lastTokenIdx = closer.token
-
-    // Length is only used for emphasis-specific "rule of 3",
-    // if it's not defined (in strikethrough or 3rd party plugins),
-    // we can default it to 0 to disable those checks.
-    //
-    closer.length = closer.length || 0
-
-    if (!closer.close) continue
-
-    // Previously calculated lower bounds (previous fails)
-    // for each marker, each delimiter length modulo 3,
-    // and for whether this closer can be an opener;
-    // https://github.com/commonmark/cmark/commit/34250e12ccebdc6372b8b49c44fab57c72443460
-    /* eslint-disable-next-line no-prototype-builtins */
-    if (!openersBottom.hasOwnProperty(closer.marker)) {
-      openersBottom[closer.marker] = [-1, -1, -1, -1, -1, -1]
-    }
-
-    const minOpenerIdx = openersBottom[closer.marker][(closer.open ? 3 : 0) + (closer.length % 3)]
-
-    let openerIdx = headerIdx - jumps[headerIdx] - 1
-
-    let newMinOpenerIdx = openerIdx
-
-    for (; openerIdx > minOpenerIdx; openerIdx -= jumps[openerIdx] + 1) {
-      const opener = delimiters[openerIdx]
-
-      if (opener.marker !== closer.marker) continue
-
-      if (opener.open && opener.end < 0) {
-        let isOddMatch = false
-
-        // from spec:
-        //
-        // If one of the delimiters can both open and close emphasis, then the
-        // sum of the lengths of the delimiter runs containing the opening and
-        // closing delimiters must not be a multiple of 3 unless both lengths
-        // are multiples of 3.
-        //
-        if (opener.close || closer.open) {
-          if ((opener.length + closer.length) % 3 === 0) {
-            if (opener.length % 3 !== 0 || closer.length % 3 !== 0) {
-              isOddMatch = true
-            }
-          }
-        }
-
-        if (!isOddMatch) {
-          // If previous delimiter cannot be an opener, we can safely skip
-          // the entire sequence in future checks. This is required to make
-          // sure algorithm has linear complexity (see *_*_*_*_*_... case).
-          //
-          const lastJump = openerIdx > 0 && !delimiters[openerIdx - 1].open
-            ? jumps[openerIdx - 1] + 1
-            : 0
-
-          jumps[closerIdx] = closerIdx - openerIdx + lastJump
-          jumps[openerIdx] = lastJump
-
-          closer.open  = false
-          opener.end   = closerIdx
-          opener.close = false
-          newMinOpenerIdx = -1
-          // treat next token as start of run,
-          // it optimizes skips in **<...>**a**<...>** pathological case
-          lastTokenIdx = -2
-          break
-        }
-      }
-    }
-
-    if (newMinOpenerIdx !== -1) {
-      // If match for this delimiter run failed, we want to set lower bound for
-      // future lookups. This is required to make sure algorithm has linear
-      // complexity.
-      //
-      // See details here:
-      // https://github.com/commonmark/cmark/issues/178#issuecomment-270417442
-      //
-      openersBottom[closer.marker][(closer.open ? 3 : 0) + ((closer.length || 0) % 3)] = newMinOpenerIdx
-    }
-  }
-}
-
-export default function link_pairs (state) {
-  const tokens_meta = state.tokens_meta
-  const max = state.tokens_meta.length
-
-  processDelimiters(state.delimiters)
-
-  for (let curr = 0; curr < max; curr++) {
-    if (tokens_meta[curr] && tokens_meta[curr].delimiters) {
-      processDelimiters(tokens_meta[curr].delimiters)
-    }
-  }
-}
diff --git a/packages/markdown-it-14.1.0/lib/rules_inline/emphasis.mjs b/packages/markdown-it-14.1.0/lib/rules_inline/emphasis.mjs
deleted file mode 100644
index 4e3b273..0000000
--- a/packages/markdown-it-14.1.0/lib/rules_inline/emphasis.mjs
+++ /dev/null
@@ -1,123 +0,0 @@
-// Process *this* and _that_
-//
-
-// Insert each marker as a separate text token, and add it to delimiter list
-//
-function emphasis_tokenize (state, silent) {
-  const start = state.pos
-  const marker = state.src.charCodeAt(start)
-
-  if (silent) { return false }
-
-  if (marker !== 0x5F /* _ */ && marker !== 0x2A /* * */) { return false }
-
-  const scanned = state.scanDelims(state.pos, marker === 0x2A)
-
-  for (let i = 0; i < scanned.length; i++) {
-    const token = state.push('text', '', 0)
-    token.content = String.fromCharCode(marker)
-
-    state.delimiters.push({
-      // Char code of the starting marker (number).
-      //
-      marker,
-
-      // Total length of these series of delimiters.
-      //
-      length: scanned.length,
-
-      // A position of the token this delimiter corresponds to.
-      //
-      token: state.tokens.length - 1,
-
-      // If this delimiter is matched as a valid opener, `end` will be
-      // equal to its position, otherwise it's `-1`.
-      //
-      end: -1,
-
-      // Boolean flags that determine if this delimiter could open or close
-      // an emphasis.
-      //
-      open: scanned.can_open,
-      close: scanned.can_close
-    })
-  }
-
-  state.pos += scanned.length
-
-  return true
-}
-
-function postProcess (state, delimiters) {
-  const max = delimiters.length
-
-  for (let i = max - 1; i >= 0; i--) {
-    const startDelim = delimiters[i]
-
-    if (startDelim.marker !== 0x5F/* _ */ && startDelim.marker !== 0x2A/* * */) {
-      continue
-    }
-
-    // Process only opening markers
-    if (startDelim.end === -1) {
-      continue
-    }
-
-    const endDelim = delimiters[startDelim.end]
-
-    // If the previous delimiter has the same marker and is adjacent to this one,
-    // merge those into one strong delimiter.
-    //
-    // `<em><em>whatever</em></em>` -> `<strong>whatever</strong>`
-    //
-    const isStrong = i > 0 &&
-               delimiters[i - 1].end === startDelim.end + 1 &&
-               // check that first two markers match and adjacent
-               delimiters[i - 1].marker === startDelim.marker &&
-               delimiters[i - 1].token === startDelim.token - 1 &&
-               // check that last two markers are adjacent (we can safely assume they match)
-               delimiters[startDelim.end + 1].token === endDelim.token + 1
-
-    const ch = String.fromCharCode(startDelim.marker)
-
-    const token_o   = state.tokens[startDelim.token]
-    token_o.type    = isStrong ? 'strong_open' : 'em_open'
-    token_o.tag     = isStrong ? 'strong' : 'em'
-    token_o.nesting = 1
-    token_o.markup  = isStrong ? ch + ch : ch
-    token_o.content = ''
-
-    const token_c   = state.tokens[endDelim.token]
-    token_c.type    = isStrong ? 'strong_close' : 'em_close'
-    token_c.tag     = isStrong ? 'strong' : 'em'
-    token_c.nesting = -1
-    token_c.markup  = isStrong ? ch + ch : ch
-    token_c.content = ''
-
-    if (isStrong) {
-      state.tokens[delimiters[i - 1].token].content = ''
-      state.tokens[delimiters[startDelim.end + 1].token].content = ''
-      i--
-    }
-  }
-}
-
-// Walk through delimiter list and replace text tokens with tags
-//
-function emphasis_post_process (state) {
-  const tokens_meta = state.tokens_meta
-  const max = state.tokens_meta.length
-
-  postProcess(state, state.delimiters)
-
-  for (let curr = 0; curr < max; curr++) {
-    if (tokens_meta[curr] && tokens_meta[curr].delimiters) {
-      postProcess(state, tokens_meta[curr].delimiters)
-    }
-  }
-}
-
-export default {
-  tokenize: emphasis_tokenize,
-  postProcess: emphasis_post_process
-}
diff --git a/packages/markdown-it-14.1.0/lib/rules_inline/entity.mjs b/packages/markdown-it-14.1.0/lib/rules_inline/entity.mjs
deleted file mode 100644
index e65191d..0000000
--- a/packages/markdown-it-14.1.0/lib/rules_inline/entity.mjs
+++ /dev/null
@@ -1,51 +0,0 @@
-// Process html entity - &#123;, &#xAF;, &quot;, ...
-
-import { decodeHTML } from 'entities'
-import { isValidEntityCode, fromCodePoint } from '../common/utils.mjs'
-
-const DIGITAL_RE = /^&#((?:x[a-f0-9]{1,6}|[0-9]{1,7}));/i
-const NAMED_RE   = /^&([a-z][a-z0-9]{1,31});/i
-
-export default function entity (state, silent) {
-  const pos = state.pos
-  const max = state.posMax
-
-  if (state.src.charCodeAt(pos) !== 0x26/* & */) return false
-
-  if (pos + 1 >= max) return false
-
-  const ch = state.src.charCodeAt(pos + 1)
-
-  if (ch === 0x23 /* # */) {
-    const match = state.src.slice(pos).match(DIGITAL_RE)
-    if (match) {
-      if (!silent) {
-        const code = match[1][0].toLowerCase() === 'x' ? parseInt(match[1].slice(1), 16) : parseInt(match[1], 10)
-
-        const token   = state.push('text_special', '', 0)
-        token.content = isValidEntityCode(code) ? fromCodePoint(code) : fromCodePoint(0xFFFD)
-        token.markup  = match[0]
-        token.info    = 'entity'
-      }
-      state.pos += match[0].length
-      return true
-    }
-  } else {
-    const match = state.src.slice(pos).match(NAMED_RE)
-    if (match) {
-      const decoded = decodeHTML(match[0])
-      if (decoded !== match[0]) {
-        if (!silent) {
-          const token   = state.push('text_special', '', 0)
-          token.content = decoded
-          token.markup  = match[0]
-          token.info    = 'entity'
-        }
-        state.pos += match[0].length
-        return true
-      }
-    }
-  }
-
-  return false
-}
diff --git a/packages/markdown-it-14.1.0/lib/rules_inline/escape.mjs b/packages/markdown-it-14.1.0/lib/rules_inline/escape.mjs
deleted file mode 100644
index aa3728e..0000000
--- a/packages/markdown-it-14.1.0/lib/rules_inline/escape.mjs
+++ /dev/null
@@ -1,69 +0,0 @@
-// Process escaped chars and hardbreaks
-
-import { isSpace } from '../common/utils.mjs'
-
-const ESCAPED = []
-
-for (let i = 0; i < 256; i++) { ESCAPED.push(0) }
-
-'\\!"#$%&\'()*+,./:;<=>?@[]^_`{|}~-'
-  .split('').forEach(function (ch) { ESCAPED[ch.charCodeAt(0)] = 1 })
-
-export default function escape (state, silent) {
-  let pos = state.pos
-  const max = state.posMax
-
-  if (state.src.charCodeAt(pos) !== 0x5C/* \ */) return false
-  pos++
-
-  // '\' at the end of the inline block
-  if (pos >= max) return false
-
-  let ch1 = state.src.charCodeAt(pos)
-
-  if (ch1 === 0x0A) {
-    if (!silent) {
-      state.push('hardbreak', 'br', 0)
-    }
-
-    pos++
-    // skip leading whitespaces from next line
-    while (pos < max) {
-      ch1 = state.src.charCodeAt(pos)
-      if (!isSpace(ch1)) break
-      pos++
-    }
-
-    state.pos = pos
-    return true
-  }
-
-  let escapedStr = state.src[pos]
-
-  if (ch1 >= 0xD800 && ch1 <= 0xDBFF && pos + 1 < max) {
-    const ch2 = state.src.charCodeAt(pos + 1)
-
-    if (ch2 >= 0xDC00 && ch2 <= 0xDFFF) {
-      escapedStr += state.src[pos + 1]
-      pos++
-    }
-  }
-
-  const origStr = '\\' + escapedStr
-
-  if (!silent) {
-    const token = state.push('text_special', '', 0)
-
-    if (ch1 < 256 && ESCAPED[ch1] !== 0) {
-      token.content = escapedStr
-    } else {
-      token.content = origStr
-    }
-
-    token.markup = origStr
-    token.info   = 'escape'
-  }
-
-  state.pos = pos + 1
-  return true
-}
diff --git a/packages/markdown-it-14.1.0/lib/rules_inline/fragments_join.mjs b/packages/markdown-it-14.1.0/lib/rules_inline/fragments_join.mjs
deleted file mode 100644
index e89ef9e..0000000
--- a/packages/markdown-it-14.1.0/lib/rules_inline/fragments_join.mjs
+++ /dev/null
@@ -1,38 +0,0 @@
-// Clean up tokens after emphasis and strikethrough postprocessing:
-// merge adjacent text nodes into one and re-calculate all token levels
-//
-// This is necessary because initially emphasis delimiter markers (*, _, ~)
-// are treated as their own separate text tokens. Then emphasis rule either
-// leaves them as text (needed to merge with adjacent text) or turns them
-// into opening/closing tags (which messes up levels inside).
-//
-
-export default function fragments_join (state) {
-  let curr, last
-  let level = 0
-  const tokens = state.tokens
-  const max = state.tokens.length
-
-  for (curr = last = 0; curr < max; curr++) {
-    // re-calculate levels after emphasis/strikethrough turns some text nodes
-    // into opening/closing tags
-    if (tokens[curr].nesting < 0) level-- // closing tag
-    tokens[curr].level = level
-    if (tokens[curr].nesting > 0) level++ // opening tag
-
-    if (tokens[curr].type === 'text' &&
-        curr + 1 < max &&
-        tokens[curr + 1].type === 'text') {
-      // collapse two adjacent text nodes
-      tokens[curr + 1].content = tokens[curr].content + tokens[curr + 1].content
-    } else {
-      if (curr !== last) { tokens[last] = tokens[curr] }
-
-      last++
-    }
-  }
-
-  if (curr !== last) {
-    tokens.length = last
-  }
-}
diff --git a/packages/markdown-it-14.1.0/lib/rules_inline/html_inline.mjs b/packages/markdown-it-14.1.0/lib/rules_inline/html_inline.mjs
deleted file mode 100644
index 256efad..0000000
--- a/packages/markdown-it-14.1.0/lib/rules_inline/html_inline.mjs
+++ /dev/null
@@ -1,50 +0,0 @@
-// Process html tags
-
-import { HTML_TAG_RE } from '../common/html_re.mjs'
-
-function isLinkOpen (str) {
-  return /^<a[>\s]/i.test(str)
-}
-function isLinkClose (str) {
-  return /^<\/a\s*>/i.test(str)
-}
-
-function isLetter (ch) {
-  /* eslint no-bitwise:0 */
-  const lc = ch | 0x20 // to lower case
-  return (lc >= 0x61/* a */) && (lc <= 0x7a/* z */)
-}
-
-export default function html_inline (state, silent) {
-  if (!state.md.options.html) { return false }
-
-  // Check start
-  const max = state.posMax
-  const pos = state.pos
-  if (state.src.charCodeAt(pos) !== 0x3C/* < */ ||
-      pos + 2 >= max) {
-    return false
-  }
-
-  // Quick fail on second char
-  const ch = state.src.charCodeAt(pos + 1)
-  if (ch !== 0x21/* ! */ &&
-      ch !== 0x3F/* ? */ &&
-      ch !== 0x2F/* / */ &&
-      !isLetter(ch)) {
-    return false
-  }
-
-  const match = state.src.slice(pos).match(HTML_TAG_RE)
-  if (!match) { return false }
-
-  if (!silent) {
-    const token = state.push('html_inline', '', 0)
-    token.content = match[0]
-
-    if (isLinkOpen(token.content))  state.linkLevel++
-    if (isLinkClose(token.content)) state.linkLevel--
-  }
-  state.pos += match[0].length
-  return true
-}
diff --git a/packages/markdown-it-14.1.0/lib/rules_inline/image.mjs b/packages/markdown-it-14.1.0/lib/rules_inline/image.mjs
deleted file mode 100644
index 32cbb31..0000000
--- a/packages/markdown-it-14.1.0/lib/rules_inline/image.mjs
+++ /dev/null
@@ -1,138 +0,0 @@
-// Process ![image](<src> "title")
-
-import { normalizeReference, isSpace } from '../common/utils.mjs'
-
-export default function image (state, silent) {
-  let code, content, label, pos, ref, res, title, start
-  let href = ''
-  const oldPos = state.pos
-  const max = state.posMax
-
-  if (state.src.charCodeAt(state.pos) !== 0x21/* ! */) { return false }
-  if (state.src.charCodeAt(state.pos + 1) !== 0x5B/* [ */) { return false }
-
-  const labelStart = state.pos + 2
-  const labelEnd = state.md.helpers.parseLinkLabel(state, state.pos + 1, false)
-
-  // parser failed to find ']', so it's not a valid link
-  if (labelEnd < 0) { return false }
-
-  pos = labelEnd + 1
-  if (pos < max && state.src.charCodeAt(pos) === 0x28/* ( */) {
-    //
-    // Inline link
-    //
-
-    // [link](  <href>  "title"  )
-    //        ^^ skipping these spaces
-    pos++
-    for (; pos < max; pos++) {
-      code = state.src.charCodeAt(pos)
-      if (!isSpace(code) && code !== 0x0A) { break }
-    }
-    if (pos >= max) { return false }
-
-    // [link](  <href>  "title"  )
-    //          ^^^^^^ parsing link destination
-    start = pos
-    res = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax)
-    if (res.ok) {
-      href = state.md.normalizeLink(res.str)
-      if (state.md.validateLink(href)) {
-        pos = res.pos
-      } else {
-        href = ''
-      }
-    }
-
-    // [link](  <href>  "title"  )
-    //                ^^ skipping these spaces
-    start = pos
-    for (; pos < max; pos++) {
-      code = state.src.charCodeAt(pos)
-      if (!isSpace(code) && code !== 0x0A) { break }
-    }
-
-    // [link](  <href>  "title"  )
-    //                  ^^^^^^^ parsing link title
-    res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax)
-    if (pos < max && start !== pos && res.ok) {
-      title = res.str
-      pos = res.pos
-
-      // [link](  <href>  "title"  )
-      //                         ^^ skipping these spaces
-      for (; pos < max; pos++) {
-        code = state.src.charCodeAt(pos)
-        if (!isSpace(code) && code !== 0x0A) { break }
-      }
-    } else {
-      title = ''
-    }
-
-    if (pos >= max || state.src.charCodeAt(pos) !== 0x29/* ) */) {
-      state.pos = oldPos
-      return false
-    }
-    pos++
-  } else {
-    //
-    // Link reference
-    //
-    if (typeof state.env.references === 'undefined') { return false }
-
-    if (pos < max && state.src.charCodeAt(pos) === 0x5B/* [ */) {
-      start = pos + 1
-      pos = state.md.helpers.parseLinkLabel(state, pos)
-      if (pos >= 0) {
-        label = state.src.slice(start, pos++)
-      } else {
-        pos = labelEnd + 1
-      }
-    } else {
-      pos = labelEnd + 1
-    }
-
-    // covers label === '' and label === undefined
-    // (collapsed reference link and shortcut reference link respectively)
-    if (!label) { label = state.src.slice(labelStart, labelEnd) }
-
-    ref = state.env.references[normalizeReference(label)]
-    if (!ref) {
-      state.pos = oldPos
-      return false
-    }
-    href = ref.href
-    title = ref.title
-  }
-
-  //
-  // We found the end of the link, and know for a fact it's a valid link;
-  // so all that's left to do is to call tokenizer.
-  //
-  if (!silent) {
-    content = state.src.slice(labelStart, labelEnd)
-
-    const tokens = []
-    state.md.inline.parse(
-      content,
-      state.md,
-      state.env,
-      tokens
-    )
-
-    const token = state.push('image', 'img', 0)
-    const attrs = [['src', href], ['alt', '']]
-    token.attrs = attrs
-    token.children = tokens
-    token.content = content
-
-    if (title) {
-      attrs.push(['title', title])
-    }
-  }
-
-  state.pos = pos
-  state.posMax = max
-  return true
-}
diff --git a/packages/markdown-it-14.1.0/lib/rules_inline/link.mjs b/packages/markdown-it-14.1.0/lib/rules_inline/link.mjs
deleted file mode 100644
index b145173..0000000
--- a/packages/markdown-it-14.1.0/lib/rules_inline/link.mjs
+++ /dev/null
@@ -1,139 +0,0 @@
-// Process [link](<to> "stuff")
-
-import { normalizeReference, isSpace } from '../common/utils.mjs'
-
-export default function link (state, silent) {
-  let code, label, res, ref
-  let href = ''
-  let title = ''
-  let start = state.pos
-  let parseReference = true
-
-  if (state.src.charCodeAt(state.pos) !== 0x5B/* [ */) { return false }
-
-  const oldPos = state.pos
-  const max = state.posMax
-  const labelStart = state.pos + 1
-  const labelEnd = state.md.helpers.parseLinkLabel(state, state.pos, true)
-
-  // parser failed to find ']', so it's not a valid link
-  if (labelEnd < 0) { return false }
-
-  let pos = labelEnd + 1
-  if (pos < max && state.src.charCodeAt(pos) === 0x28/* ( */) {
-    //
-    // Inline link
-    //
-
-    // might have found a valid shortcut link, disable reference parsing
-    parseReference = false
-
-    // [link](  <href>  "title"  )
-    //        ^^ skipping these spaces
-    pos++
-    for (; pos < max; pos++) {
-      code = state.src.charCodeAt(pos)
-      if (!isSpace(code) && code !== 0x0A) { break }
-    }
-    if (pos >= max) { return false }
-
-    // [link](  <href>  "title"  )
-    //          ^^^^^^ parsing link destination
-    start = pos
-    res = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax)
-    if (res.ok) {
-      href = state.md.normalizeLink(res.str)
-      if (state.md.validateLink(href)) {
-        pos = res.pos
-      } else {
-        href = ''
-      }
-
-      // [link](  <href>  "title"  )
-      //                ^^ skipping these spaces
-      start = pos
-      for (; pos < max; pos++) {
-        code = state.src.charCodeAt(pos)
-        if (!isSpace(code) && code !== 0x0A) { break }
-      }
-
-      // [link](  <href>  "title"  )
-      //                  ^^^^^^^ parsing link title
-      res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax)
-      if (pos < max && start !== pos && res.ok) {
-        title = res.str
-        pos = res.pos
-
-        // [link](  <href>  "title"  )
-        //                         ^^ skipping these spaces
-        for (; pos < max; pos++) {
-          code = state.src.charCodeAt(pos)
-          if (!isSpace(code) && code !== 0x0A) { break }
-        }
-      }
-    }
-
-    if (pos >= max || state.src.charCodeAt(pos) !== 0x29/* ) */) {
-      // parsing a valid shortcut link failed, fallback to reference
-      parseReference = true
-    }
-    pos++
-  }
-
-  if (parseReference) {
-    //
-    // Link reference
-    //
-    if (typeof state.env.references === 'undefined') { return false }
-
-    if (pos < max && state.src.charCodeAt(pos) === 0x5B/* [ */) {
-      start = pos + 1
-      pos = state.md.helpers.parseLinkLabel(state, pos)
-      if (pos >= 0) {
-        label = state.src.slice(start, pos++)
-      } else {
-        pos = labelEnd + 1
-      }
-    } else {
-      pos = labelEnd + 1
-    }
-
-    // covers label === '' and label === undefined
-    // (collapsed reference link and shortcut reference link respectively)
-    if (!label) { label = state.src.slice(labelStart, labelEnd) }
-
-    ref = state.env.references[normalizeReference(label)]
-    if (!ref) {
-      state.pos = oldPos
-      return false
-    }
-    href = ref.href
-    title = ref.title
-  }
-
-  //
-  // We found the end of the link, and know for a fact it's a valid link;
-  // so all that's left to do is to call tokenizer.
-  //
-  if (!silent) {
-    state.pos = labelStart
-    state.posMax = labelEnd
-
-    const token_o = state.push('link_open', 'a', 1)
-    const attrs = [['href', href]]
-    token_o.attrs  = attrs
-    if (title) {
-      attrs.push(['title', title])
-    }
-
-    state.linkLevel++
-    state.md.inline.tokenize(state)
-    state.linkLevel--
-
-    state.push('link_close', 'a', -1)
-  }
-
-  state.pos = pos
-  state.posMax = max
-  return true
-}
diff --git a/packages/markdown-it-14.1.0/lib/rules_inline/linkify.mjs b/packages/markdown-it-14.1.0/lib/rules_inline/linkify.mjs
deleted file mode 100644
index fdc817a..0000000
--- a/packages/markdown-it-14.1.0/lib/rules_inline/linkify.mjs
+++ /dev/null
@@ -1,56 +0,0 @@
-// Process links like https://example.org/
-
-// RFC3986: scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
-const SCHEME_RE = /(?:^|[^a-z0-9.+-])([a-z][a-z0-9.+-]*)$/i
-
-export default function linkify (state, silent) {
-  if (!state.md.options.linkify) return false
-  if (state.linkLevel > 0) return false
-
-  const pos = state.pos
-  const max = state.posMax
-
-  if (pos + 3 > max) return false
-  if (state.src.charCodeAt(pos) !== 0x3A/* : */) return false
-  if (state.src.charCodeAt(pos + 1) !== 0x2F/* / */) return false
-  if (state.src.charCodeAt(pos + 2) !== 0x2F/* / */) return false
-
-  const match = state.pending.match(SCHEME_RE)
-  if (!match) return false
-
-  const proto = match[1]
-
-  const link = state.md.linkify.matchAtStart(state.src.slice(pos - proto.length))
-  if (!link) return false
-
-  let url = link.url
-
-  // invalid link, but still detected by linkify somehow;
-  // need to check to prevent infinite loop below
-  if (url.length <= proto.length) return false
-
-  // disallow '*' at the end of the link (conflicts with emphasis)
-  url = url.replace(/\*+$/, '')
-
-  const fullUrl = state.md.normalizeLink(url)
-  if (!state.md.validateLink(fullUrl)) return false
-
-  if (!silent) {
-    state.pending = state.pending.slice(0, -proto.length)
-
-    const token_o = state.push('link_open', 'a', 1)
-    token_o.attrs = [['href', fullUrl]]
-    token_o.markup = 'linkify'
-    token_o.info = 'auto'
-
-    const token_t = state.push('text', '', 0)
-    token_t.content = state.md.normalizeLinkText(url)
-
-    const token_c = state.push('link_close', 'a', -1)
-    token_c.markup = 'linkify'
-    token_c.info = 'auto'
-  }
-
-  state.pos += url.length - proto.length
-  return true
-}
diff --git a/packages/markdown-it-14.1.0/lib/rules_inline/newline.mjs b/packages/markdown-it-14.1.0/lib/rules_inline/newline.mjs
deleted file mode 100644
index 2c0e3ae..0000000
--- a/packages/markdown-it-14.1.0/lib/rules_inline/newline.mjs
+++ /dev/null
@@ -1,42 +0,0 @@
-// Proceess '\n'
-
-import { isSpace } from '../common/utils.mjs'
-
-export default function newline (state, silent) {
-  let pos = state.pos
-
-  if (state.src.charCodeAt(pos) !== 0x0A/* \n */) { return false }
-
-  const pmax = state.pending.length - 1
-  const max = state.posMax
-
-  // '  \n' -> hardbreak
-  // Lookup in pending chars is bad practice! Don't copy to other rules!
-  // Pending string is stored in concat mode, indexed lookups will cause
-  // convertion to flat mode.
-  if (!silent) {
-    if (pmax >= 0 && state.pending.charCodeAt(pmax) === 0x20) {
-      if (pmax >= 1 && state.pending.charCodeAt(pmax - 1) === 0x20) {
-        // Find whitespaces tail of pending chars.
-        let ws = pmax - 1
-        while (ws >= 1 && state.pending.charCodeAt(ws - 1) === 0x20) ws--
-
-        state.pending = state.pending.slice(0, ws)
-        state.push('hardbreak', 'br', 0)
-      } else {
-        state.pending = state.pending.slice(0, -1)
-        state.push('softbreak', 'br', 0)
-      }
-    } else {
-      state.push('softbreak', 'br', 0)
-    }
-  }
-
-  pos++
-
-  // skip heading spaces for next line
-  while (pos < max && isSpace(state.src.charCodeAt(pos))) { pos++ }
-
-  state.pos = pos
-  return true
-}
diff --git a/packages/markdown-it-14.1.0/lib/rules_inline/state_inline.mjs b/packages/markdown-it-14.1.0/lib/rules_inline/state_inline.mjs
deleted file mode 100644
index 80cb3c5..0000000
--- a/packages/markdown-it-14.1.0/lib/rules_inline/state_inline.mjs
+++ /dev/null
@@ -1,123 +0,0 @@
-// Inline parser state
-
-import Token from '../token.mjs'
-import { isWhiteSpace, isPunctChar, isMdAsciiPunct } from '../common/utils.mjs'
-
-function StateInline (src, md, env, outTokens) {
-  this.src = src
-  this.env = env
-  this.md = md
-  this.tokens = outTokens
-  this.tokens_meta = Array(outTokens.length)
-
-  this.pos = 0
-  this.posMax = this.src.length
-  this.level = 0
-  this.pending = ''
-  this.pendingLevel = 0
-
-  // Stores { start: end } pairs. Useful for backtrack
-  // optimization of pairs parse (emphasis, strikes).
-  this.cache = {}
-
-  // List of emphasis-like delimiters for current tag
-  this.delimiters = []
-
-  // Stack of delimiter lists for upper level tags
-  this._prev_delimiters = []
-
-  // backtick length => last seen position
-  this.backticks = {}
-  this.backticksScanned = false
-
-  // Counter used to disable inline linkify-it execution
-  // inside <a> and markdown links
-  this.linkLevel = 0
-}
-
-// Flush pending text
-//
-StateInline.prototype.pushPending = function () {
-  const token = new Token('text', '', 0)
-  token.content = this.pending
-  token.level = this.pendingLevel
-  this.tokens.push(token)
-  this.pending = ''
-  return token
-}
-
-// Push new token to "stream".
-// If pending text exists - flush it as text token
-//
-StateInline.prototype.push = function (type, tag, nesting) {
-  if (this.pending) {
-    this.pushPending()
-  }
-
-  const token = new Token(type, tag, nesting)
-  let token_meta = null
-
-  if (nesting < 0) {
-    // closing tag
-    this.level--
-    this.delimiters = this._prev_delimiters.pop()
-  }
-
-  token.level = this.level
-
-  if (nesting > 0) {
-    // opening tag
-    this.level++
-    this._prev_delimiters.push(this.delimiters)
-    this.delimiters = []
-    token_meta = { delimiters: this.delimiters }
-  }
-
-  this.pendingLevel = this.level
-  this.tokens.push(token)
-  this.tokens_meta.push(token_meta)
-  return token
-}
-
-// Scan a sequence of emphasis-like markers, and determine whether
-// it can start an emphasis sequence or end an emphasis sequence.
-//
-//  - start - position to scan from (it should point at a valid marker);
-//  - canSplitWord - determine if these markers can be found inside a word
-//
-StateInline.prototype.scanDelims = function (start, canSplitWord) {
-  const max = this.posMax
-  const marker = this.src.charCodeAt(start)
-
-  // treat beginning of the line as a whitespace
-  const lastChar = start > 0 ? this.src.charCodeAt(start - 1) : 0x20
-
-  let pos = start
-  while (pos < max && this.src.charCodeAt(pos) === marker) { pos++ }
-
-  const count = pos - start
-
-  // treat end of the line as a whitespace
-  const nextChar = pos < max ? this.src.charCodeAt(pos) : 0x20
-
-  const isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(String.fromCharCode(lastChar))
-  const isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar))
-
-  const isLastWhiteSpace = isWhiteSpace(lastChar)
-  const isNextWhiteSpace = isWhiteSpace(nextChar)
-
-  const left_flanking =
-    !isNextWhiteSpace && (!isNextPunctChar || isLastWhiteSpace || isLastPunctChar)
-  const right_flanking =
-    !isLastWhiteSpace && (!isLastPunctChar || isNextWhiteSpace || isNextPunctChar)
-
-  const can_open  = left_flanking  && (canSplitWord || !right_flanking || isLastPunctChar)
-  const can_close = right_flanking && (canSplitWord || !left_flanking  || isNextPunctChar)
-
-  return { can_open, can_close, length: count }
-}
-
-// re-export Token class to use in block rules
-StateInline.prototype.Token = Token
-
-export default StateInline
diff --git a/packages/markdown-it-14.1.0/lib/rules_inline/strikethrough.mjs b/packages/markdown-it-14.1.0/lib/rules_inline/strikethrough.mjs
deleted file mode 100644
index 45f3c1b..0000000
--- a/packages/markdown-it-14.1.0/lib/rules_inline/strikethrough.mjs
+++ /dev/null
@@ -1,127 +0,0 @@
-// ~~strike through~~
-//
-
-// Insert each marker as a separate text token, and add it to delimiter list
-//
-function strikethrough_tokenize (state, silent) {
-  const start = state.pos
-  const marker = state.src.charCodeAt(start)
-
-  if (silent) { return false }
-
-  if (marker !== 0x7E/* ~ */) { return false }
-
-  const scanned = state.scanDelims(state.pos, true)
-  let len = scanned.length
-  const ch = String.fromCharCode(marker)
-
-  if (len < 2) { return false }
-
-  let token
-
-  if (len % 2) {
-    token         = state.push('text', '', 0)
-    token.content = ch
-    len--
-  }
-
-  for (let i = 0; i < len; i += 2) {
-    token         = state.push('text', '', 0)
-    token.content = ch + ch
-
-    state.delimiters.push({
-      marker,
-      length: 0,     // disable "rule of 3" length checks meant for emphasis
-      token: state.tokens.length - 1,
-      end: -1,
-      open: scanned.can_open,
-      close: scanned.can_close
-    })
-  }
-
-  state.pos += scanned.length
-
-  return true
-}
-
-function postProcess (state, delimiters) {
-  let token
-  const loneMarkers = []
-  const max = delimiters.length
-
-  for (let i = 0; i < max; i++) {
-    const startDelim = delimiters[i]
-
-    if (startDelim.marker !== 0x7E/* ~ */) {
-      continue
-    }
-
-    if (startDelim.end === -1) {
-      continue
-    }
-
-    const endDelim = delimiters[startDelim.end]
-
-    token         = state.tokens[startDelim.token]
-    token.type    = 's_open'
-    token.tag     = 's'
-    token.nesting = 1
-    token.markup  = '~~'
-    token.content = ''
-
-    token         = state.tokens[endDelim.token]
-    token.type    = 's_close'
-    token.tag     = 's'
-    token.nesting = -1
-    token.markup  = '~~'
-    token.content = ''
-
-    if (state.tokens[endDelim.token - 1].type === 'text' &&
-        state.tokens[endDelim.token - 1].content === '~') {
-      loneMarkers.push(endDelim.token - 1)
-    }
-  }
-
-  // If a marker sequence has an odd number of characters, it's splitted
-  // like this: `~~~~~` -> `~` + `~~` + `~~`, leaving one marker at the
-  // start of the sequence.
-  //
-  // So, we have to move all those markers after subsequent s_close tags.
-  //
-  while (loneMarkers.length) {
-    const i = loneMarkers.pop()
-    let j = i + 1
-
-    while (j < state.tokens.length && state.tokens[j].type === 's_close') {
-      j++
-    }
-
-    j--
-
-    if (i !== j) {
-      token = state.tokens[j]
-      state.tokens[j] = state.tokens[i]
-      state.tokens[i] = token
-    }
-  }
-}
-
-// Walk through delimiter list and replace text tokens with tags
-//
-function strikethrough_postProcess (state) {
-  const tokens_meta = state.tokens_meta
-  const max = state.tokens_meta.length
-
-  postProcess(state, state.delimiters)
-
-  for (let curr = 0; curr < max; curr++) {
-    if (tokens_meta[curr] && tokens_meta[curr].delimiters) {
-      postProcess(state, tokens_meta[curr].delimiters)
-    }
-  }
-}
-
-export default {
-  tokenize: strikethrough_tokenize,
-  postProcess: strikethrough_postProcess
-}
diff --git a/packages/markdown-it-14.1.0/lib/rules_inline/text.mjs b/packages/markdown-it-14.1.0/lib/rules_inline/text.mjs
deleted file mode 100644
index 9be4227..0000000
--- a/packages/markdown-it-14.1.0/lib/rules_inline/text.mjs
+++ /dev/null
@@ -1,86 +0,0 @@
-// Skip text characters for text token, place those to pending buffer
-// and increment current pos
-
-// Rule to skip pure text
-// '{}$%@~+=:' reserved for extentions
-
-// !, ", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, @, [, \, ], ^, _, `, {, |, }, or ~
-
-// !!!! Don't confuse with "Markdown ASCII Punctuation" chars
-// http://spec.commonmark.org/0.15/#ascii-punctuation-character
-function isTerminatorChar (ch) {
-  switch (ch) {
-    case 0x0A/* \n */:
-    case 0x21/* ! */:
-    case 0x23/* # */:
-    case 0x24/* $ */:
-    case 0x25/* % */:
-    case 0x26/* & */:
-    case 0x2A/* * */:
-    case 0x2B/* + */:
-    case 0x2D/* - */:
-    case 0x3A/* : */:
-    case 0x3C/* < */:
-    case 0x3D/* = */:
-    case 0x3E/* > */:
-    case 0x40/* @ */:
-    case 0x5B/* [ */:
-    case 0x5C/* \ */:
-    case 0x5D/* ] */:
-    case 0x5E/* ^ */:
-    case 0x5F/* _ */:
-    case 0x60/* ` */:
-    case 0x7B/* { */:
-    case 0x7D/* } */:
-    case 0x7E/* ~ */:
-      return true
-    default:
-      return false
-  }
-}
-
-export default function text (state, silent) {
-  let pos = state.pos
-
-  while (pos < state.posMax && !isTerminatorChar(state.src.charCodeAt(pos))) {
-    pos++
-  }
-
-  if (pos === state.pos) { return false }
-
-  if (!silent) { state.pending += state.src.slice(state.pos, pos) }
-
-  state.pos = pos
-
-  return true
-}
-
-// Alternative implementation, for memory.
-//
-// It costs 10% of performance, but allows extend terminators list, if place it
-// to `ParserInline` property. Probably, will switch to it sometime, such
-// flexibility required.
-
-/*
-var TERMINATOR_RE = /[\n!#$%&*+\-:<=>@[\\\]^_`{}~]/;
-
-module.exports = function text(state, silent) {
-  var pos = state.pos,
-      idx = state.src.slice(pos).search(TERMINATOR_RE);
-
-  // first char is terminator -> empty text
-  if (idx === 0) { return false; }
-
-  // no terminator -> text till end of string
-  if (idx < 0) {
-    if (!silent) { state.pending += state.src.slice(pos); }
-    state.pos = state.src.length;
-    return true;
-  }
-
-  if (!silent) { state.pending += state.src.slice(pos, pos + idx); }
-
-  state.pos += idx;
-
-  return true;
-}; */
diff --git a/packages/markdown-it-14.1.0/lib/token.mjs b/packages/markdown-it-14.1.0/lib/token.mjs
deleted file mode 100644
index 706ae1d..0000000
--- a/packages/markdown-it-14.1.0/lib/token.mjs
+++ /dev/null
@@ -1,191 +0,0 @@
-// Token class
-
-/**
- * class Token
- **/
-
-/**
- * new Token(type, tag, nesting)
- *
- * Create new token and fill passed properties.
- **/
-function Token (type, tag, nesting) {
-  /**
-   * Token#type -> String
-   *
-   * Type of the token (string, e.g. "paragraph_open")
-   **/
-  this.type     = type
-
-  /**
-   * Token#tag -> String
-   *
-   * html tag name, e.g. "p"
-   **/
-  this.tag      = tag
-
-  /**
-   * Token#attrs -> Array
-   *
-   * Html attributes. Format: `[ [ name1, value1 ], [ name2, value2 ] ]`
-   **/
-  this.attrs    = null
-
-  /**
-   * Token#map -> Array
-   *
-   * Source map info. Format: `[ line_begin, line_end ]`
-   **/
-  this.map      = null
-
-  /**
-   * Token#nesting -> Number
-   *
-   * Level change (number in {-1, 0, 1} set), where:
-   *
-   * -  `1` means the tag is opening
-   * -  `0` means the tag is self-closing
-   * - `-1` means the tag is closing
-   **/
-  this.nesting  = nesting
-
-  /**
-   * Token#level -> Number
-   *
-   * nesting level, the same as `state.level`
-   **/
-  this.level    = 0
-
-  /**
-   * Token#children -> Array
-   *
-   * An array of child nodes (inline and img tokens)
-   **/
-  this.children = null
-
-  /**
-   * Token#content -> String
-   *
-   * In a case of self-closing tag (code, html, fence, etc.),
-   * it has contents of this tag.
-   **/
-  this.content  = ''
-
-  /**
-   * Token#markup -> String
-   *
-   * '*' or '_' for emphasis, fence string for fence, etc.
-   **/
-  this.markup   = ''
-
-  /**
-   * Token#info -> String
-   *
-   * Additional information:
-   *
-   * - Info string for "fence" tokens
-   * - The value "auto" for autolink "link_open" and "link_close" tokens
-   * - The string value of the item marker for ordered-list "list_item_open" tokens
-   **/
-  this.info     = ''
-
-  /**
-   * Token#meta -> Object
-   *
-   * A place for plugins to store an arbitrary data
-   **/
-  this.meta     = null
-
-  /**
-   * Token#block -> Boolean
-   *
-   * True for block-level tokens, false for inline tokens.
-   * Used in renderer to calculate line breaks
-   **/
-  this.block    = false
-
-  /**
-   * Token#hidden -> Boolean
-   *
-   * If it's true, ignore this element when rendering. Used for tight lists
-   * to hide paragraphs.
-   **/
-  this.hidden   = false
-}
-
-/**
- * Token.attrIndex(name) -> Number
- *
- * Search attribute index by name.
- **/
-Token.prototype.attrIndex = function attrIndex (name) {
-  if (!this.attrs) { return -1 }
-
-  const attrs = this.attrs
-
-  for (let i = 0, len = attrs.length; i < len; i++) {
-    if (attrs[i][0] === name) { return i }
-  }
-  return -1
-}
-
-/**
- * Token.attrPush(attrData)
- *
- * Add `[ name, value ]` attribute to list. Init attrs if necessary
- **/
-Token.prototype.attrPush = function attrPush (attrData) {
-  if (this.attrs) {
-    this.attrs.push(attrData)
-  } else {
-    this.attrs = [attrData]
-  }
-}
-
-/**
- * Token.attrSet(name, value)
- *
- * Set `name` attribute to `value`. Override old value if exists.
- **/
-Token.prototype.attrSet = function attrSet (name, value) {
-  const idx = this.attrIndex(name)
-  const attrData = [name, value]
-
-  if (idx < 0) {
-    this.attrPush(attrData)
-  } else {
-    this.attrs[idx] = attrData
-  }
-}
-
-/**
- * Token.attrGet(name)
- *
- * Get the value of attribute `name`, or null if it does not exist.
- **/
-Token.prototype.attrGet = function attrGet (name) {
-  const idx = this.attrIndex(name)
-  let value = null
-  if (idx >= 0) {
-    value = this.attrs[idx][1]
-  }
-  return value
-}
-
-/**
- * Token.attrJoin(name, value)
- *
- * Join value to existing attribute via space. Or create new attribute if not
- * exists. Useful to operate with token classes.
- **/
-Token.prototype.attrJoin = function attrJoin (name, value) {
-  const idx = this.attrIndex(name)
-
-  if (idx < 0) {
-    this.attrPush([name, value])
-  } else {
-    this.attrs[idx][1] = this.attrs[idx][1] + ' ' + value
-  }
-}
-
-export default Token