@openclaw/matrix 2026.8.1-beta.2 → 2026.8.1

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

@@ -1,10 +1,10 @@
 argparse
 ========
 
-[![Build Status](https://secure.travis-ci.org/nodeca/argparse.svg?branch=master)](http://travis-ci.org/nodeca/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.9/library/argparse.html#sub-commands) support. Port of python's [argparse](http://docs.python.org/dev/library/argparse.html) (version [3.9.0](https://github.com/python/cpython/blob/v3.9.0rc1/Lib/argparse.py)).
+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.**
 
@@ -14,56 +14,68 @@ CLI arguments parser for node.js, with [sub-commands](https://docs.python.org/3.
   - Use string-typed names: `.add_argument('-b', { type: 'int', help: 'help' })`.
 - `%r` format specifier uses `require('util').inspect()`.
 
-More details in [doc](./doc).
+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
 -------
 
-`test.js` file:
+Following code is a JS program that takes a list of integers and produces either the sum or the max:
 
-```javascript
-#!/usr/bin/env node
-'use strict';
+```js
+const { ArgumentParser } = require('argparse')
 
-const { ArgumentParser } = require('argparse');
-const { version } = require('./package.json');
+const parser = new ArgumentParser({ description: 'Process some integers.' })
 
-const parser = new ArgumentParser({
-  description: 'Argparse example'
-});
+let sum = ints => ints.reduce((a, b) => a + b)
+let max = ints => ints.reduce((a, b) => a > b ? a : b)
 
-parser.add_argument('-v', '--version', { action: 'version', version });
-parser.add_argument('-f', '--foo', { help: 'foo bar' });
-parser.add_argument('-b', '--bar', { help: 'bar foo' });
-parser.add_argument('--baz', { help: 'baz bar' });
+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)' });
 
-console.dir(parser.parse_args());
+let args = parser.parse_args()
+console.log(args.accumulate(args.integers))
 ```
 
-Display help:
+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:
 
 ```
-$ ./test.js -h
-usage: test.js [-h] [-v] [-f FOO] [-b BAR] [--baz BAZ]
+$ node prog.js -h
+usage: prog.js [-h] [--sum] N [N ...]
 
-Argparse example
+Process some integers.
 
-optional arguments:
-  -h, --help         show this help message and exit
-  -v, --version      show program's version number and exit
-  -f FOO, --foo FOO  foo bar
-  -b BAR, --bar BAR  bar foo
-  --baz BAZ          baz bar
+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
 ```
 
-Parse arguments:
+If invalid arguments are passed in, it will issue an error:
 
 ```
-$ ./test.js -f=3 --bar=4 --baz 5
-{ foo: '3', bar: '4', baz: '5' }
+$ 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
 --------
@@ -71,14 +83,7 @@ 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.9/library/argparse.html).
-2. [Original tutorial](https://docs.python.org/3.9/howto/argparse.html).
-3. [Difference with python](./doc).
-
-
-argparse for enterprise
------------------------
-
-Available as part of the Tidelift Subscription
-
-The maintainers of argparse and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. [Learn more.](https://tidelift.com/subscription/pkg/npm-argparse?utm_source=npm-argparse&utm_medium=referral&utm_campaign=enterprise&utm_term=repo)
+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...'