@alexlit/lint-kit 110.0.0 → 110.2.0

package/packages/config-markdownlint/node_modules/markdown-it/lib/rules_block/blockquote.mjs

@@ -0,0 +1,209 @@
+// 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
+}

package/packages/config-markdownlint/node_modules/markdown-it/lib/rules_block/code.mjs

@@ -0,0 +1,30 @@
+// 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
+}

package/packages/config-markdownlint/node_modules/markdown-it/lib/rules_block/fence.mjs

@@ -0,0 +1,94 @@
+// 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
+}

package/packages/config-markdownlint/node_modules/markdown-it/lib/rules_block/heading.mjs

@@ -0,0 +1,51 @@
+// 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
+}

package/packages/config-markdownlint/node_modules/markdown-it/lib/rules_block/hr.mjs

@@ -0,0 +1,40 @@
+// 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
+}

package/packages/config-markdownlint/node_modules/markdown-it/lib/rules_block/html_block.mjs

@@ -0,0 +1,69 @@
+// 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
+}

package/packages/config-markdownlint/node_modules/markdown-it/lib/rules_block/lheading.mjs

@@ -0,0 +1,82 @@
+// 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
+}