@openclaw/matrix 2026.8.1-beta.3 → 2026.8.2

package/node_modules/markdown-it/lib/rules_block/blockquote.mjs

@@ -1,209 +0,0 @@
-// 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/node_modules/markdown-it/lib/rules_block/code.mjs

@@ -1,30 +0,0 @@
-// 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/node_modules/markdown-it/lib/rules_block/fence.mjs

@@ -1,94 +0,0 @@
-// 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/node_modules/markdown-it/lib/rules_block/heading.mjs

@@ -1,51 +0,0 @@
-// heading (#, ##, ...)
-
-import { isSpace, asciiTrim } 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 = asciiTrim(state.src.slice(pos, max))
-  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/node_modules/markdown-it/lib/rules_block/hr.mjs

@@ -1,40 +0,0 @@
-// 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/node_modules/markdown-it/lib/rules_block/html_block.mjs

@@ -1,80 +0,0 @@
-// 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
-
-  // Block types 6 and 7 (the only ones whose end condition is a blank line)
-  // have `/^$/` as their closing regexp. For all other types (1-5, e.g.
-  // `<!--` comments), a blank line is regular content and must not terminate
-  // the block - it ends only when its closing sequence is found.
-  const endsOnBlankLine = HTML_SEQUENCES[i][1].test('')
-
-  // 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) {
-        // An outdented blank line shouldn't end a block that doesn't end on a
-        // blank line (e.g. a `<!--` comment inside a list item). Such blocks
-        // must continue until their closing sequence regardless of indent.
-        if (endsOnBlankLine || !state.isEmpty(nextLine)) { 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/node_modules/markdown-it/lib/rules_block/lheading.mjs

@@ -1,85 +0,0 @@
-// lheading (---, ===)
-
-import { asciiTrim } from '../common/utils.mjs'
-
-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
-    state.parentType = oldParentType
-    return false
-  }
-
-  const content = asciiTrim(state.getLines(startLine, nextLine, state.blkIndent, false))
-
-  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
-}