@alexlit/lint-kit 112.3.2 → 112.3.4

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

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

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

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

package/packages/config-markdownlint/node_modules/markdown-it/lib/rules_core/block.mjs

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

package/packages/config-markdownlint/node_modules/markdown-it/lib/rules_core/inline.mjs

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

package/packages/config-markdownlint/node_modules/markdown-it/lib/rules_core/linkify.mjs

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

package/packages/config-markdownlint/node_modules/markdown-it/lib/rules_core/normalize.mjs

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