quite a big commit

12 files changed, 0 insertions, 1612 deletions

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
-}