@openclaw/matrix 2026.7.2-beta.5 → 2026.7.33

package/node_modules/markdown-it/node_modules/argparse/LICENSE

@@ -0,0 +1,47 @@
+PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+
+1. This LICENSE AGREEMENT is between the Python Software Foundation
+("PSF"), and the Individual or Organization ("Licensee") accessing and
+otherwise using this software ("Python") in source or binary form and
+its associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, PSF hereby
+grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
+analyze, test, perform and/or display publicly, prepare derivative works,
+distribute, and otherwise use Python alone or in any derivative version,
+provided, however, that PSF's License Agreement and PSF's notice of copyright,
+i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019 Python Software Foundation;
+All Rights Reserved" are retained in Python alone or in any derivative version
+prepared by Licensee.
+
+3. In the event Licensee prepares a derivative work that is based on
+or incorporates Python or any part thereof, and wants to make
+the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to Python.
+
+4. PSF is making Python available to Licensee on an "AS IS"
+basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,
+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. Nothing in this License Agreement shall be deemed to create any
+relationship of agency, partnership, or joint venture between PSF and
+Licensee.  This License Agreement does not grant permission to use PSF
+trademarks or trade name in a trademark sense to endorse or promote
+products or services of Licensee, or any third party.
+
+8. By copying, installing or otherwise using Python, Licensee
+agrees to be bound by the terms and conditions of this License
+Agreement.

package/node_modules/markdown-it/node_modules/argparse/README.md

@@ -0,0 +1,89 @@
+argparse
+========
+
+[![CI](https://github.com/nodeca/argparse/actions/workflows/ci.yml/badge.svg)](https://github.com/nodeca/argparse/actions/workflows/ci.yml)
+[![NPM version](https://img.shields.io/npm/v/argparse.svg)](https://www.npmjs.org/package/argparse)
+
+CLI arguments parser for node.js, with [sub-commands](https://docs.python.org/3.14/library/argparse.html#sub-commands) support. Port of python's [argparse](https://docs.python.org/3.14/library/argparse.html) (version [3.14.6](https://github.com/python/cpython/blob/v3.14.6/Lib/argparse.py)).
+
+**Difference with original.**
+
+- JS has no keyword arguments support.
+  -  Pass options instead: `new ArgumentParser({ description: 'example', add_help: true })`.
+- JS has no python's types `int`, `float`, ...
+  - Use string-typed names: `.add_argument('-b', { type: 'int', help: 'help' })`.
+- `%r` format specifier uses `require('util').inspect()`.
+
+See the complete list of [differences from Python](./doc/port_difference.md).
+Users upgrading from v2 should read the [migration guide](./doc/migrate_v2_to_v3.md).
+
+
+Example
+-------
+
+Following code is a JS program that takes a list of integers and produces either the sum or the max:
+
+```js
+const { ArgumentParser } = require('argparse')
+
+const parser = new ArgumentParser({ description: 'Process some integers.' })
+
+let sum = ints => ints.reduce((a, b) => a + b)
+let max = ints => ints.reduce((a, b) => a > b ? a : b)
+
+parser.add_argument('integers', { metavar: 'N', type: 'int', nargs: '+',
+                                  help: 'an integer for the accumulator' })
+parser.add_argument('--sum',    { dest: 'accumulate', action: 'store_const',
+                                  const: sum, default: max,
+                                  help: 'sum the integers (default: find the max)' });
+
+let args = parser.parse_args()
+console.log(args.accumulate(args.integers))
+```
+
+Assuming the JS code above is saved into a file called prog.js, it can be run at the command line and provides useful help messages:
+
+```
+$ node prog.js -h
+usage: prog.js [-h] [--sum] N [N ...]
+
+Process some integers.
+
+positional arguments:
+  N           an integer for the accumulator
+
+options:
+  -h, --help  show this help message and exit
+  --sum       sum the integers (default: find the max)
+```
+
+When run with the appropriate arguments, it prints either the sum or the max of the command-line integers:
+
+```
+$ node prog.js 1 2 3 4
+4
+$ node prog.js 1 2 3 4 --sum
+10
+```
+
+If invalid arguments are passed in, it will issue an error:
+
+```
+$ node prog.js a b c
+usage: prog.js [-h] [--sum] N [N ...]
+prog.js: error: argument N: invalid 'int' value: 'a'
+```
+
+This is an example ported from Python. You can find detailed explanation [here](https://docs.python.org/3.14/library/argparse.html).
+
+
+API docs
+--------
+
+Since this is a port with minimal divergence, there's no separate documentation.
+Use original one instead, with notes about difference.
+
+1. [Original doc](https://docs.python.org/3.14/library/argparse.html).
+2. [Original tutorial](https://docs.python.org/3.14/howto/argparse.html).
+3. [Differences from Python](./doc/port_difference.md).
+4. [Migration from v2 to v3](./doc/migrate_v2_to_v3.md).

package/node_modules/markdown-it/node_modules/argparse/lib/_colorize.js

@@ -0,0 +1,72 @@
+'use strict'
+
+const ANSIColors = {
+    RESET: '\x1b[0m',
+    BOLD_BLUE: '\x1b[1;34m',
+    BOLD_CYAN: '\x1b[1;36m',
+    BOLD_GREEN: '\x1b[1;32m',
+    BOLD_MAGENTA: '\x1b[1;35m',
+    BOLD_YELLOW: '\x1b[1;33m',
+    CYAN: '\x1b[36m',
+    GREEN: '\x1b[32m',
+    MAGENTA: '\x1b[35m',
+    YELLOW: '\x1b[33m'
+}
+
+const argparse = {
+    usage: ANSIColors.BOLD_BLUE,
+    prog: ANSIColors.BOLD_MAGENTA,
+    prog_extra: ANSIColors.MAGENTA,
+    heading: ANSIColors.BOLD_BLUE,
+    summary_long_option: ANSIColors.CYAN,
+    summary_short_option: ANSIColors.GREEN,
+    summary_label: ANSIColors.YELLOW,
+    summary_action: ANSIColors.GREEN,
+    long_option: ANSIColors.BOLD_CYAN,
+    short_option: ANSIColors.BOLD_GREEN,
+    label: ANSIColors.BOLD_YELLOW,
+    action: ANSIColors.BOLD_GREEN,
+    reset: ANSIColors.RESET
+}
+
+const default_theme = { argparse }
+const argparse_no_color = {}
+for (const name of Object.keys(argparse)) argparse_no_color[name] = ''
+const theme_no_color = { argparse: argparse_no_color }
+
+function decolor (text) {
+    for (const code of Object.values(ANSIColors)) {
+        text = text.split(code).join('')
+    }
+    return text
+}
+
+function can_colorize (file = undefined) {
+    const getenv = name => {
+        try {
+            return process.env[name]
+        } catch (err) {
+            return undefined
+        }
+    }
+
+    if (getenv('PYTHON_COLORS') === '0') return false
+    if (getenv('PYTHON_COLORS') === '1') return true
+    if (getenv('NO_COLOR')) return false
+    if (getenv('FORCE_COLOR')) return true
+    if (getenv('TERM') === 'dumb') return false
+
+    if (file === undefined) file = process.stdout
+    if (!file) return false
+    if (typeof file.hasColors === 'function') return file.hasColors()
+    return file.isTTY === true
+}
+
+function get_theme ({ tty_file, force_color = false, force_no_color = false } = {}) {
+    if (force_color || (!force_no_color && can_colorize(tty_file))) {
+        return default_theme
+    }
+    return theme_no_color
+}
+
+module.exports = { can_colorize, decolor, get_theme }

package/node_modules/markdown-it/node_modules/argparse/lib/argparse.d.ts

@@ -0,0 +1,292 @@
+export type Nargs = number | '?' | '*' | '+' | 'A...' | '...' | '==SUPPRESS=='
+
+export type ArgumentType =
+  | string
+  | ((value: string) => unknown)
+  | (new (value: string) => unknown)
+
+export interface ArgumentOptions {
+  action?: string | ActionClass
+  option_strings?: string[]
+  dest?: string
+  nargs?: Nargs
+  const?: unknown
+  default?: unknown
+  type?: ArgumentType
+  choices?: string | readonly unknown[] | object
+  required?: boolean
+  help?: string
+  metavar?: string | string[]
+  version?: string
+  deprecated?: boolean
+}
+
+export interface ActionConstructorOptions extends ArgumentOptions {
+  option_strings: string[]
+  dest: string
+}
+
+export interface Action {
+  option_strings: string[]
+  dest: string
+  nargs?: Nargs
+  const?: unknown
+  default?: unknown
+  type?: ArgumentType
+  choices?: string | readonly unknown[] | object
+  required: boolean
+  help?: string
+  metavar?: string | string[]
+  deprecated: boolean
+
+  (parser: ArgumentParser, namespace: Namespace, values: unknown, option_string?: string): void
+  call(parser: ArgumentParser, namespace: Namespace, values: unknown, option_string?: string): void
+  format_usage(): string
+}
+
+export interface ActionClass {
+  new (options: ActionConstructorOptions): Action
+  readonly prototype: Action
+}
+
+export interface ActionConstructor extends ActionClass {
+  (options: ActionConstructorOptions): Action
+}
+
+export const Action: ActionConstructor
+
+export interface BooleanOptionalAction extends Action {}
+
+export interface BooleanOptionalActionConstructor {
+  new (options: ActionConstructorOptions): BooleanOptionalAction
+  (options: ActionConstructorOptions): BooleanOptionalAction
+  readonly prototype: BooleanOptionalAction
+}
+
+export const BooleanOptionalAction: BooleanOptionalActionConstructor
+
+export interface ArgumentError extends Error {
+  str(): string
+}
+
+export interface ArgumentErrorConstructor {
+  new (argument: Action | undefined, message: string): ArgumentError
+  (argument: Action | undefined, message: string): ArgumentError
+  readonly prototype: ArgumentError
+}
+
+export const ArgumentError: ArgumentErrorConstructor
+
+export interface ArgumentTypeError extends Error {}
+
+export interface ArgumentTypeErrorConstructor {
+  new (message: string): ArgumentTypeError
+  (message: string): ArgumentTypeError
+  readonly prototype: ArgumentTypeError
+}
+
+export const ArgumentTypeError: ArgumentTypeErrorConstructor
+
+export interface HelpFormatterOptions {
+  prog: string
+  indent_increment?: number
+  max_help_position?: number
+  width?: number
+  color?: boolean
+}
+
+export interface HelpFormatter {}
+
+export interface HelpFormatterClass {
+  new (options: HelpFormatterOptions): HelpFormatter
+  readonly prototype: HelpFormatter
+}
+
+export interface HelpFormatterConstructor extends HelpFormatterClass {
+  (options: HelpFormatterOptions): HelpFormatter
+}
+
+export type HelpFormatterFactory =
+  | HelpFormatterClass
+  | ((options: HelpFormatterOptions) => HelpFormatter)
+
+export const HelpFormatter: HelpFormatterConstructor
+
+export interface RawDescriptionHelpFormatter extends HelpFormatter {}
+export const RawDescriptionHelpFormatter: HelpFormatterConstructor
+
+export interface RawTextHelpFormatter extends RawDescriptionHelpFormatter {}
+export const RawTextHelpFormatter: HelpFormatterConstructor
+
+export interface ArgumentDefaultsHelpFormatter extends HelpFormatter {}
+export const ArgumentDefaultsHelpFormatter: HelpFormatterConstructor
+
+export interface MetavarTypeHelpFormatter extends HelpFormatter {}
+export const MetavarTypeHelpFormatter: HelpFormatterConstructor
+
+export interface FileTypeOptions {
+  flags?: string
+  encoding?: string
+  mode?: number
+  autoClose?: boolean
+  emitClose?: boolean
+  start?: number
+  end?: number
+  highWaterMark?: number
+  fs?: object
+}
+
+export interface FileTypeResult {
+  path?: string
+  close?: () => void
+  [key: string]: unknown
+}
+
+export interface FileType {
+  (value: string): FileTypeResult
+  call(value: string): FileTypeResult
+}
+
+export interface FileTypeConstructor {
+  new (options?: FileTypeOptions): FileType
+  new (flags?: string, encoding?: string, mode?: number): FileType
+  (options?: FileTypeOptions): FileType
+  (flags?: string, encoding?: string, mode?: number): FileType
+  readonly prototype: FileType
+}
+
+export const FileType: FileTypeConstructor
+
+export interface Namespace {
+  [key: string]: any
+}
+
+export interface NamespaceConstructor {
+  new (options?: object): Namespace
+  (options?: object): Namespace
+  readonly prototype: Namespace
+}
+
+export const Namespace: NamespaceConstructor
+
+export interface ArgumentGroupOptions {
+  title?: string
+  description?: string
+  prefix_chars?: string
+  argument_default?: unknown
+  conflict_handler?: string
+}
+
+export interface MutuallyExclusiveGroupOptions {
+  required?: boolean
+}
+
+export interface ActionsContainer {
+  register(registry_name: string, value: unknown, object: unknown): void
+
+  set_defaults(options: object): void
+  get_default(dest: string): unknown
+
+  add_argument(name: string, ...names: string[]): Action
+  add_argument(name: string, ...namesAndOptions: [...string[], ArgumentOptions]): Action
+}
+
+export interface MutuallyExclusiveGroup extends ActionsContainer {}
+
+export interface ArgumentGroup extends ActionsContainer {
+  add_mutually_exclusive_group(options?: MutuallyExclusiveGroupOptions): MutuallyExclusiveGroup
+}
+
+export interface ArgumentParserOptions {
+  prog?: string
+  usage?: string
+  description?: string
+  epilog?: string
+  parents?: ArgumentParser[]
+  formatter_class?: HelpFormatterFactory
+  prefix_chars?: string
+  fromfile_prefix_chars?: string
+  argument_default?: unknown
+  conflict_handler?: string
+  add_help?: boolean
+  allow_abbrev?: boolean
+  exit_on_error?: boolean
+  suggest_on_error?: boolean
+  color?: boolean
+}
+
+export interface SubparserOptions {
+  title?: string
+  description?: string
+  prog?: string
+  parser_class?: ArgumentParserClass
+  action?: string | ActionClass
+  dest?: string
+  required?: boolean
+  help?: string
+  metavar?: string
+}
+
+export interface SubArgumentParserOptions extends ArgumentParserOptions {
+  aliases?: string[]
+  help?: string
+  deprecated?: boolean
+}
+
+export interface SubparsersAction extends Action {
+  add_parser(name: string, options?: SubArgumentParserOptions): ArgumentParser
+}
+
+export interface Writable {
+  write(message: string): unknown
+}
+
+export interface ArgumentParser extends ArgumentGroup {
+  prog: string
+  usage?: string
+  description?: string
+  epilog?: string
+  formatter_class: HelpFormatterFactory
+  fromfile_prefix_chars?: string
+  add_help: boolean
+  allow_abbrev: boolean
+  exit_on_error: boolean
+  suggest_on_error: boolean
+  color: boolean
+
+  add_argument_group(options?: ArgumentGroupOptions): ArgumentGroup
+  add_argument_group(title?: string, description?: string): ArgumentGroup
+  add_mutually_exclusive_group(options?: MutuallyExclusiveGroupOptions): MutuallyExclusiveGroup
+  add_subparsers(options?: SubparserOptions): SubparsersAction
+
+  parse_args<T extends object = Namespace>(args?: string[], namespace?: T): T
+  parse_known_args<T extends object = Namespace>(args?: string[], namespace?: T): [T, string[]]
+  parse_intermixed_args<T extends object = Namespace>(args?: string[], namespace?: T): T
+  parse_known_intermixed_args<T extends object = Namespace>(args?: string[], namespace?: T): [T, string[]]
+
+  convert_arg_line_to_args(arg_line: string): string[]
+  format_usage(): string
+  format_help(): string
+  print_usage(file?: Writable): void
+  print_help(file?: Writable): void
+  exit(status?: number, message?: string): void
+  error(message: string): void
+}
+
+export interface ArgumentParserClass {
+  new (options?: ArgumentParserOptions): ArgumentParser
+  readonly prototype: ArgumentParser
+}
+
+export interface ArgumentParserConstructor extends ArgumentParserClass {
+  (options?: ArgumentParserOptions): ArgumentParser
+}
+
+export const ArgumentParser: ArgumentParserConstructor
+
+export const SUPPRESS: '==SUPPRESS=='
+export const OPTIONAL: '?'
+export const ZERO_OR_MORE: '*'
+export const ONE_OR_MORE: '+'
+export const REMAINDER: '...'
+export const PARSER: 'A...'