@alexlit/lint-kit 112.3.2 → 112.3.4

package/packages/config-markdownlint/node_modules/markdown-it/lib/rules_inline/newline.mjs

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

package/packages/config-markdownlint/node_modules/markdown-it/lib/rules_inline/state_inline.mjs

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

package/packages/config-markdownlint/node_modules/markdown-it/lib/rules_inline/strikethrough.mjs

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

package/packages/config-markdownlint/node_modules/markdown-it/lib/rules_inline/text.mjs

@@ -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;
-}; */

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

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

package/packages/config-markdownlint/node_modules/markdown-it/package.json

@@ -1,92 +0,0 @@
-{
-  "name": "markdown-it",
-  "version": "14.1.0",
-  "description": "Markdown-it - modern pluggable markdown parser.",
-  "keywords": [
-    "markdown",
-    "parser",
-    "commonmark",
-    "markdown-it",
-    "markdown-it-plugin"
-  ],
-  "repository": "markdown-it/markdown-it",
-  "license": "MIT",
-  "main": "dist/index.cjs.js",
-  "module": "index.mjs",
-  "exports": {
-    ".": {
-      "import": "./index.mjs",
-      "require": "./dist/index.cjs.js"
-    },
-    "./*": {
-      "require": "./*",
-      "import": "./*"
-    }
-  },
-  "bin": {
-    "markdown-it": "bin/markdown-it.mjs"
-  },
-  "scripts": {
-    "lint": "eslint .",
-    "test": "npm run lint && CJS_ONLY=1 npm run build && c8 --exclude dist --exclude test -r text -r html -r lcov mocha && node support/specsplit.mjs",
-    "doc": "node support/build_doc.mjs",
-    "gh-doc": "npm run doc && gh-pages -d apidoc -f",
-    "demo": "npm run lint && node support/build_demo.mjs",
-    "gh-demo": "npm run demo && gh-pages -d demo -f -b master -r git@github.com:markdown-it/markdown-it.github.io.git",
-    "build": "rollup -c support/rollup.config.mjs",
-    "benchmark-deps": "npm install --prefix benchmark/extra/ -g marked@0.3.6 commonmark@0.26.0 markdown-it/markdown-it.git#2.2.1",
-    "specsplit": "support/specsplit.mjs good -o test/fixtures/commonmark/good.txt && support/specsplit.mjs bad -o test/fixtures/commonmark/bad.txt && support/specsplit.mjs",
-    "todo": "grep 'TODO' -n -r ./lib 2>/dev/null",
-    "prepublishOnly": "npm test && npm run build && npm run gh-demo && npm run gh-doc"
-  },
-  "files": [
-    "index.mjs",
-    "lib/",
-    "dist/"
-  ],
-  "dependencies": {
-    "argparse": "^2.0.1",
-    "entities": "^4.4.0",
-    "linkify-it": "^5.0.0",
-    "mdurl": "^2.0.0",
-    "punycode.js": "^2.3.1",
-    "uc.micro": "^2.1.0"
-  },
-  "devDependencies": {
-    "@rollup/plugin-babel": "^6.0.4",
-    "@rollup/plugin-commonjs": "^25.0.7",
-    "@rollup/plugin-node-resolve": "^15.2.3",
-    "@rollup/plugin-terser": "^0.4.4",
-    "ansi": "^0.3.0",
-    "benchmark": "~2.1.0",
-    "c8": "^8.0.1",
-    "chai": "^4.2.0",
-    "eslint": "^8.4.1",
-    "eslint-config-standard": "^17.1.0",
-    "express": "^4.14.0",
-    "gh-pages": "^6.1.0",
-    "highlight.js": "^11.9.0",
-    "jest-worker": "^29.7.0",
-    "markdown-it-abbr": "^2.0.0",
-    "markdown-it-container": "^4.0.0",
-    "markdown-it-deflist": "^3.0.0",
-    "markdown-it-emoji": "^3.0.0",
-    "markdown-it-footnote": "^4.0.0",
-    "markdown-it-for-inline": "^2.0.1",
-    "markdown-it-ins": "^4.0.0",
-    "markdown-it-mark": "^4.0.0",
-    "markdown-it-sub": "^2.0.0",
-    "markdown-it-sup": "^2.0.0",
-    "markdown-it-testgen": "^0.1.3",
-    "mocha": "^10.2.0",
-    "ndoc": "^6.0.0",
-    "needle": "^3.0.0",
-    "rollup": "^4.5.0",
-    "shelljs": "^0.8.4",
-    "supertest": "^6.0.1"
-  },
-  "mocha": {
-    "inline-diffs": true,
-    "timeout": 60000
-  }
-}