@depup/markdown-it 14.1.1-depup.1

package/lib/rules_inline/newline.mjs

@@ -0,0 +1,42 @@
+// 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/lib/rules_inline/state_inline.mjs

@@ -0,0 +1,123 @@
+// 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/lib/rules_inline/strikethrough.mjs

@@ -0,0 +1,127 @@
+// ~~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/lib/rules_inline/text.mjs

@@ -0,0 +1,86 @@
+// 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/lib/token.mjs

@@ -0,0 +1,191 @@
+// 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/package.json

@@ -0,0 +1,109 @@
+{
+  "name": "@depup/markdown-it",
+  "version": "14.1.1-depup.1",
+  "description": "[DepUp] Markdown-it - modern pluggable markdown parser.",
+  "keywords": [
+    "depup",
+    "dependency-bumped",
+    "updated-deps",
+    "markdown-it",
+    "markdown",
+    "parser",
+    "commonmark",
+    "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"
+  },
+  "files": [
+    "index.mjs",
+    "lib/",
+    "dist/",
+    "changes.json",
+    "README.md"
+  ],
+  "dependencies": {
+    "argparse": "^2.0.1",
+    "entities": "^8.0.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
+  },
+  "depup": {
+    "changes": {
+      "entities": {
+        "from": "^4.4.0",
+        "to": "^8.0.0"
+      }
+    },
+    "depsUpdated": 1,
+    "originalPackage": "markdown-it",
+    "originalVersion": "14.1.1",
+    "processedAt": "2026-03-17T12:29:00.719Z",
+    "smokeTest": "passed"
+  }
+}