@openclaw/matrix 2026.8.1-beta.3 → 2026.8.2

package/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/node_modules/markdown-it/lib/rules_inline/state_inline.mjs

@@ -1,154 +0,0 @@
-// Inline parser state
-
-import Token from '../token.mjs'
-import { isWhiteSpace, isPunctCharCode, 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)
-
-  // Astral characters below are combined manually, because .codePointAt()
-  // does not guarantee numeric type output. And we don't wish JIT cache issues.
-  // The broken surrogate pairs are evaluated as U+FFFD to prevent possible
-  // crashes.
-
-  let lastChar
-  if (start === 0) {
-    // treat beginning of the line as a whitespace
-    lastChar = 0x20
-  } else if (start === 1) {
-    lastChar = this.src.charCodeAt(0)
-    if ((lastChar & 0xF800) === 0xD800) { lastChar = 0xFFFD }
-  } else {
-    lastChar = this.src.charCodeAt(start - 1)
-    if ((lastChar & 0xFC00) === 0xDC00) {
-      // low surrogate => add high one, replace broken pair with U+FFFD
-      const highSurr = this.src.charCodeAt(start - 2)
-      lastChar = (highSurr & 0xFC00) === 0xD800
-        ? 0x10000 + ((highSurr - 0xD800) << 10) + (lastChar - 0xDC00)
-        : 0xFFFD
-    } else if ((lastChar & 0xFC00) === 0xD800) {
-      lastChar = 0xFFFD
-    }
-  }
-
-  let pos = start
-  while (pos < max && this.src.charCodeAt(pos) === marker) { pos++ }
-
-  const count = pos - start
-
-  // treat end of the line as a whitespace
-  let nextChar = pos < max ? this.src.charCodeAt(pos) : 0x20
-  if ((nextChar & 0xFC00) === 0xD800) {
-    // high surrogate => add low one, replace broken pair with U+FFFD
-    const lowSurr = this.src.charCodeAt(pos + 1)
-    nextChar = (lowSurr & 0xFC00) === 0xDC00
-      ? 0x10000 + ((nextChar - 0xD800) << 10) + (lowSurr - 0xDC00)
-      : 0xFFFD
-  } else if ((nextChar & 0xFC00) === 0xDC00) {
-    nextChar = 0xFFFD
-  }
-
-  const isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctCharCode(lastChar)
-  const isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctCharCode(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/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/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/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