@openclaw/matrix 2026.8.1-beta.3 → 2026.8.2

package/node_modules/markdown-it/index.mjs

@@ -1 +0,0 @@
-export { default } from './lib/index.mjs'

package/node_modules/markdown-it/lib/common/html_blocks.mjs

@@ -1,67 +0,0 @@
-// List of valid html blocks names, according to commonmark spec
-// https://spec.commonmark.org/0.30/#html-blocks
-
-export default [
-  'address',
-  'article',
-  'aside',
-  'base',
-  'basefont',
-  'blockquote',
-  'body',
-  'caption',
-  'center',
-  'col',
-  'colgroup',
-  'dd',
-  'details',
-  'dialog',
-  'dir',
-  'div',
-  'dl',
-  'dt',
-  'fieldset',
-  'figcaption',
-  'figure',
-  'footer',
-  'form',
-  'frame',
-  'frameset',
-  'h1',
-  'h2',
-  'h3',
-  'h4',
-  'h5',
-  'h6',
-  'head',
-  'header',
-  'hr',
-  'html',
-  'iframe',
-  'legend',
-  'li',
-  'link',
-  'main',
-  'menu',
-  'menuitem',
-  'nav',
-  'noframes',
-  'ol',
-  'optgroup',
-  'option',
-  'p',
-  'param',
-  'search',
-  'section',
-  'summary',
-  'table',
-  'tbody',
-  'td',
-  'tfoot',
-  'th',
-  'thead',
-  'title',
-  'tr',
-  'track',
-  'ul'
-]

package/node_modules/markdown-it/lib/common/html_re.mjs

@@ -1,25 +0,0 @@
-// Regexps to match html elements
-
-const attr_name = '[a-zA-Z_:][a-zA-Z0-9:._-]*'
-
-const unquoted = '[^"\'=<>`\\x00-\\x20]+'
-const single_quoted = "'[^']*'"
-const double_quoted = '"[^"]*"'
-
-const attr_value = '(?:' + unquoted + '|' + single_quoted + '|' + double_quoted + ')'
-
-const attribute = '(?:\\s+' + attr_name + '(?:\\s*=\\s*' + attr_value + ')?)'
-
-const open_tag = '<[A-Za-z][A-Za-z0-9\\-]*' + attribute + '*\\s*\\/?>'
-
-const close_tag = '<\\/[A-Za-z][A-Za-z0-9\\-]*\\s*>'
-const comment = '<!---?>|<!--(?:[^-]|-[^-]|--[^>])*-->'
-const processing = '<[?][\\s\\S]*?[?]>'
-const declaration = '<![A-Za-z][^>]*>'
-const cdata = '<!\\[CDATA\\[[\\s\\S]*?\\]\\]>'
-
-const HTML_TAG_RE = new RegExp('^(?:' + open_tag + '|' + close_tag + '|' + comment +
-                        '|' + processing + '|' + declaration + '|' + cdata + ')')
-const HTML_OPEN_CLOSE_TAG_RE = new RegExp('^(?:' + open_tag + '|' + close_tag + ')')
-
-export { HTML_TAG_RE, HTML_OPEN_CLOSE_TAG_RE }

package/node_modules/markdown-it/lib/common/utils.mjs

@@ -1,324 +0,0 @@
-// Utilities
-//
-
-import * as mdurl from 'mdurl'
-import * as ucmicro from 'uc.micro'
-import { decodeHTML } from 'entities'
-
-function _class (obj) { return Object.prototype.toString.call(obj) }
-
-function isString (obj) { return _class(obj) === '[object String]' }
-
-const _hasOwnProperty = Object.prototype.hasOwnProperty
-
-function has (object, key) {
-  return _hasOwnProperty.call(object, key)
-}
-
-// Merge objects
-//
-function assign (obj /* from1, from2, from3, ... */) {
-  const sources = Array.prototype.slice.call(arguments, 1)
-
-  sources.forEach(function (source) {
-    if (!source) { return }
-
-    if (typeof source !== 'object') {
-      throw new TypeError(source + 'must be object')
-    }
-
-    Object.keys(source).forEach(function (key) {
-      obj[key] = source[key]
-    })
-  })
-
-  return obj
-}
-
-// Remove element from array and put another array at those position.
-// Useful for some operations with tokens
-function arrayReplaceAt (src, pos, newElements) {
-  return [].concat(src.slice(0, pos), newElements, src.slice(pos + 1))
-}
-
-function isValidEntityCode (c) {
-  // broken sequence
-  if (c >= 0xD800 && c <= 0xDFFF) { return false }
-  // never used
-  if (c >= 0xFDD0 && c <= 0xFDEF) { return false }
-  if ((c & 0xFFFF) === 0xFFFF || (c & 0xFFFF) === 0xFFFE) { return false }
-  // control codes
-  if (c >= 0x00 && c <= 0x08) { return false }
-  if (c === 0x0B) { return false }
-  if (c >= 0x0E && c <= 0x1F) { return false }
-  if (c >= 0x7F && c <= 0x9F) { return false }
-  // out of range
-  if (c > 0x10FFFF) { return false }
-  return true
-}
-
-function fromCodePoint (c) {
-  /* eslint no-bitwise:0 */
-  if (c > 0xffff) {
-    c -= 0x10000
-    const surrogate1 = 0xd800 + (c >> 10)
-    const surrogate2 = 0xdc00 + (c & 0x3ff)
-
-    return String.fromCharCode(surrogate1, surrogate2)
-  }
-  return String.fromCharCode(c)
-}
-
-const UNESCAPE_MD_RE = /\\([!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~])/g
-const ENTITY_RE = /&([a-z#][a-z0-9]{1,31});/gi
-const UNESCAPE_ALL_RE = new RegExp(UNESCAPE_MD_RE.source + '|' + ENTITY_RE.source, 'gi')
-
-const DIGITAL_ENTITY_TEST_RE = /^#((?:x[a-f0-9]{1,8}|[0-9]{1,8}))$/i
-
-function replaceEntityPattern (match, name) {
-  if (name.charCodeAt(0) === 0x23/* # */ && DIGITAL_ENTITY_TEST_RE.test(name)) {
-    const code = name[1].toLowerCase() === 'x'
-      ? parseInt(name.slice(2), 16)
-      : parseInt(name.slice(1), 10)
-
-    if (isValidEntityCode(code)) {
-      return fromCodePoint(code)
-    }
-
-    return match
-  }
-
-  const decoded = decodeHTML(match)
-  if (decoded !== match) {
-    return decoded
-  }
-
-  return match
-}
-
-function unescapeMd (str) {
-  if (str.indexOf('\\') < 0) { return str }
-  return str.replace(UNESCAPE_MD_RE, '$1')
-}
-
-function unescapeAll (str) {
-  if (str.indexOf('\\') < 0 && str.indexOf('&') < 0) { return str }
-
-  return str.replace(UNESCAPE_ALL_RE, function (match, escaped, entity) {
-    if (escaped) { return escaped }
-    return replaceEntityPattern(match, entity)
-  })
-}
-
-const HTML_ESCAPE_TEST_RE = /[&<>"]/
-const HTML_ESCAPE_REPLACE_RE = /[&<>"]/g
-const HTML_REPLACEMENTS = {
-  '&': '&amp;',
-  '<': '&lt;',
-  '>': '&gt;',
-  '"': '&quot;'
-}
-
-function replaceUnsafeChar (ch) {
-  return HTML_REPLACEMENTS[ch]
-}
-
-function escapeHtml (str) {
-  if (HTML_ESCAPE_TEST_RE.test(str)) {
-    return str.replace(HTML_ESCAPE_REPLACE_RE, replaceUnsafeChar)
-  }
-  return str
-}
-
-const REGEXP_ESCAPE_RE = /[.?*+^$[\]\\(){}|-]/g
-
-function escapeRE (str) {
-  return str.replace(REGEXP_ESCAPE_RE, '\\$&')
-}
-
-function isSpace (code) {
-  switch (code) {
-    case 0x09:
-    case 0x20:
-      return true
-  }
-  return false
-}
-
-// Zs (unicode class) || [\t\f\v\r\n]
-function isWhiteSpace (code) {
-  if (code >= 0x2000 && code <= 0x200A) { return true }
-  switch (code) {
-    case 0x09: // \t
-    case 0x0A: // \n
-    case 0x0B: // \v
-    case 0x0C: // \f
-    case 0x0D: // \r
-    case 0x20:
-    case 0xA0:
-    case 0x1680:
-    case 0x202F:
-    case 0x205F:
-    case 0x3000:
-      return true
-  }
-  return false
-}
-
-// Currently without astral characters support.
-function isPunctChar (ch) {
-  return ucmicro.P.test(ch) || ucmicro.S.test(ch)
-}
-
-function isPunctCharCode (code) {
-  return isPunctChar(fromCodePoint(code))
-}
-
-// Markdown ASCII punctuation characters.
-//
-// !, ", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, @, [, \, ], ^, _, `, {, |, }, or ~
-// http://spec.commonmark.org/0.15/#ascii-punctuation-character
-//
-// Don't confuse with unicode punctuation !!! It lacks some chars in ascii range.
-//
-function isMdAsciiPunct (ch) {
-  switch (ch) {
-    case 0x21/* ! */:
-    case 0x22/* " */:
-    case 0x23/* # */:
-    case 0x24/* $ */:
-    case 0x25/* % */:
-    case 0x26/* & */:
-    case 0x27/* ' */:
-    case 0x28/* ( */:
-    case 0x29/* ) */:
-    case 0x2A/* * */:
-    case 0x2B/* + */:
-    case 0x2C/* , */:
-    case 0x2D/* - */:
-    case 0x2E/* . */:
-    case 0x2F/* / */:
-    case 0x3A/* : */:
-    case 0x3B/* ; */:
-    case 0x3C/* < */:
-    case 0x3D/* = */:
-    case 0x3E/* > */:
-    case 0x3F/* ? */:
-    case 0x40/* @ */:
-    case 0x5B/* [ */:
-    case 0x5C/* \ */:
-    case 0x5D/* ] */:
-    case 0x5E/* ^ */:
-    case 0x5F/* _ */:
-    case 0x60/* ` */:
-    case 0x7B/* { */:
-    case 0x7C/* | */:
-    case 0x7D/* } */:
-    case 0x7E/* ~ */:
-      return true
-    default:
-      return false
-  }
-}
-
-// Hepler to unify [reference labels].
-//
-function normalizeReference (str) {
-  // Trim and collapse whitespace
-  //
-  str = str.trim().replace(/\s+/g, ' ')
-
-  // In node v10 'ẞ'.toLowerCase() === 'Ṿ', which is presumed to be a bug
-  // fixed in v12 (couldn't find any details).
-  //
-  // So treat this one as a special case
-  // (remove this when node v10 is no longer supported).
-  //
-  if ('ẞ'.toLowerCase() === 'Ṿ') {
-    /* c8 ignore next 2 */
-    str = str.replace(/ẞ/g, 'ß')
-  }
-
-  // .toLowerCase().toUpperCase() should get rid of all differences
-  // between letter variants.
-  //
-  // Simple .toLowerCase() doesn't normalize 125 code points correctly,
-  // and .toUpperCase doesn't normalize 6 of them (list of exceptions:
-  // İ, ϴ, ẞ, Ω, K, Å - those are already uppercased, but have differently
-  // uppercased versions).
-  //
-  // Here's an example showing how it happens. Lets take greek letter omega:
-  // uppercase U+0398 (Θ), U+03f4 (ϴ) and lowercase U+03b8 (θ), U+03d1 (ϑ)
-  //
-  // Unicode entries:
-  // 0398;GREEK CAPITAL LETTER THETA;Lu;0;L;;;;;N;;;;03B8;
-  // 03B8;GREEK SMALL LETTER THETA;Ll;0;L;;;;;N;;;0398;;0398
-  // 03D1;GREEK THETA SYMBOL;Ll;0;L;<compat> 03B8;;;;N;GREEK SMALL LETTER SCRIPT THETA;;0398;;0398
-  // 03F4;GREEK CAPITAL THETA SYMBOL;Lu;0;L;<compat> 0398;;;;N;;;;03B8;
-  //
-  // Case-insensitive comparison should treat all of them as equivalent.
-  //
-  // But .toLowerCase() doesn't change ϑ (it's already lowercase),
-  // and .toUpperCase() doesn't change ϴ (already uppercase).
-  //
-  // Applying first lower then upper case normalizes any character:
-  // '\u0398\u03f4\u03b8\u03d1'.toLowerCase().toUpperCase() === '\u0398\u0398\u0398\u0398'
-  //
-  // Note: this is equivalent to unicode case folding; unicode normalization
-  // is a different step that is not required here.
-  //
-  // Final result should be uppercased, because it's later stored in an object
-  // (this avoid a conflict with Object.prototype members,
-  // most notably, `__proto__`)
-  //
-  return str.toLowerCase().toUpperCase()
-}
-
-function isAsciiTrimmable (c) {
-  return c === 0x20 || c === 0x09 || c === 0x0a || c === 0x0d
-}
-
-// "Light" .trim() for blocks (headers, paragraphs), where unicode spaces
-// should be preserved.
-function asciiTrim (str) {
-  let start = 0
-  for (; start < str.length; start++) {
-    if (!isAsciiTrimmable(str.charCodeAt(start))) {
-      break
-    }
-  }
-  let end = str.length - 1
-  for (; end >= start; end--) {
-    if (!isAsciiTrimmable(str.charCodeAt(end))) {
-      break
-    }
-  }
-  return str.slice(start, end + 1)
-}
-
-// Re-export libraries commonly used in both markdown-it and its plugins,
-// so plugins won't have to depend on them explicitly, which reduces their
-// bundled size (e.g. a browser build).
-//
-const lib = { mdurl, ucmicro }
-
-export {
-  lib,
-  assign,
-  isString,
-  has,
-  unescapeMd,
-  unescapeAll,
-  isValidEntityCode,
-  fromCodePoint,
-  escapeHtml,
-  arrayReplaceAt,
-  isSpace,
-  isWhiteSpace,
-  isMdAsciiPunct,
-  isPunctChar,
-  isPunctCharCode,
-  escapeRE,
-  normalizeReference,
-  asciiTrim
-}

package/node_modules/markdown-it/lib/helpers/index.mjs

@@ -1,11 +0,0 @@
-// Just a shortcut for bulk export
-
-import parseLinkLabel from './parse_link_label.mjs'
-import parseLinkDestination from './parse_link_destination.mjs'
-import parseLinkTitle from './parse_link_title.mjs'
-
-export {
-  parseLinkLabel,
-  parseLinkDestination,
-  parseLinkTitle
-}

package/node_modules/markdown-it/lib/helpers/parse_link_destination.mjs

@@ -1,77 +0,0 @@
-// Parse link destination
-//
-
-import { unescapeAll } from '../common/utils.mjs'
-
-export default function parseLinkDestination (str, start, max) {
-  let code
-  let pos = start
-
-  const result = {
-    ok: false,
-    pos: 0,
-    str: ''
-  }
-
-  if (str.charCodeAt(pos) === 0x3C /* < */) {
-    pos++
-    while (pos < max) {
-      code = str.charCodeAt(pos)
-      if (code === 0x0A /* \n */) { return result }
-      if (code === 0x3C /* < */) { return result }
-      if (code === 0x3E /* > */) {
-        result.pos = pos + 1
-        result.str = unescapeAll(str.slice(start + 1, pos))
-        result.ok = true
-        return result
-      }
-      if (code === 0x5C /* \ */ && pos + 1 < max) {
-        pos += 2
-        continue
-      }
-
-      pos++
-    }
-
-    // no closing '>'
-    return result
-  }
-
-  // this should be ... } else { ... branch
-
-  let level = 0
-  while (pos < max) {
-    code = str.charCodeAt(pos)
-
-    if (code === 0x20) { break }
-
-    // ascii control characters
-    if (code < 0x20 || code === 0x7F) { break }
-
-    if (code === 0x5C /* \ */ && pos + 1 < max) {
-      if (str.charCodeAt(pos + 1) === 0x20) { break }
-      pos += 2
-      continue
-    }
-
-    if (code === 0x28 /* ( */) {
-      level++
-      if (level > 32) { return result }
-    }
-
-    if (code === 0x29 /* ) */) {
-      if (level === 0) { break }
-      level--
-    }
-
-    pos++
-  }
-
-  if (start === pos) { return result }
-  if (level !== 0) { return result }
-
-  result.str = unescapeAll(str.slice(start, pos))
-  result.pos = pos
-  result.ok = true
-  return result
-}

package/node_modules/markdown-it/lib/helpers/parse_link_label.mjs

@@ -1,49 +0,0 @@
-// Parse link label
-//
-// this function assumes that first character ("[") already matches;
-// returns the end of the label
-//
-
-export default function parseLinkLabel (state, start, disableNested) {
-  let level, found, marker, prevPos
-
-  const max = state.posMax
-  const oldPos = state.pos
-
-  state.pos = start + 1
-  level = 1
-
-  while (state.pos < max) {
-    marker = state.src.charCodeAt(state.pos)
-    if (marker === 0x5D /* ] */) {
-      level--
-      if (level === 0) {
-        found = true
-        break
-      }
-    }
-
-    prevPos = state.pos
-    state.md.inline.skipToken(state)
-    if (marker === 0x5B /* [ */) {
-      if (prevPos === state.pos - 1) {
-        // increase level if we find text `[`, which is not a part of any token
-        level++
-      } else if (disableNested) {
-        state.pos = oldPos
-        return -1
-      }
-    }
-  }
-
-  let labelEnd = -1
-
-  if (found) {
-    labelEnd = state.pos
-  }
-
-  // restore old state
-  state.pos = oldPos
-
-  return labelEnd
-}

package/node_modules/markdown-it/lib/helpers/parse_link_title.mjs

@@ -1,66 +0,0 @@
-// Parse link title
-//
-
-import { unescapeAll } from '../common/utils.mjs'
-
-// Parse link title within `str` in [start, max] range,
-// or continue previous parsing if `prev_state` is defined (equal to result of last execution).
-//
-export default function parseLinkTitle (str, start, max, prev_state) {
-  let code
-  let pos = start
-
-  const state = {
-    // if `true`, this is a valid link title
-    ok: false,
-    // if `true`, this link can be continued on the next line
-    can_continue: false,
-    // if `ok`, it's the position of the first character after the closing marker
-    pos: 0,
-    // if `ok`, it's the unescaped title
-    str: '',
-    // expected closing marker character code
-    marker: 0
-  }
-
-  if (prev_state) {
-    // this is a continuation of a previous parseLinkTitle call on the next line,
-    // used in reference links only
-    state.str = prev_state.str
-    state.marker = prev_state.marker
-  } else {
-    if (pos >= max) { return state }
-
-    let marker = str.charCodeAt(pos)
-    if (marker !== 0x22 /* " */ && marker !== 0x27 /* ' */ && marker !== 0x28 /* ( */) { return state }
-
-    start++
-    pos++
-
-    // if opening marker is "(", switch it to closing marker ")"
-    if (marker === 0x28) { marker = 0x29 }
-
-    state.marker = marker
-  }
-
-  while (pos < max) {
-    code = str.charCodeAt(pos)
-    if (code === state.marker) {
-      state.pos = pos + 1
-      state.str += unescapeAll(str.slice(start, pos))
-      state.ok = true
-      return state
-    } else if (code === 0x28 /* ( */ && state.marker === 0x29 /* ) */) {
-      return state
-    } else if (code === 0x5C /* \ */ && pos + 1 < max) {
-      pos++
-    }
-
-    pos++
-  }
-
-  // no closing marker found, but this link title may continue on the next line (for references)
-  state.can_continue = true
-  state.str += unescapeAll(str.slice(start, pos))
-  return state
-}