From 0172c07623afb7f5af52f5e5d974720f835a1403 Mon Sep 17 00:00:00 2001 From: Felix Rieseberg Date: Thu, 26 Jun 2025 08:38:59 -0700 Subject: [PATCH] :rocket: Hello World --- .eslintrc.json | 131 + .gitignore | 108 + .npmignore | 1 + .vscode/settings.json | 10 + CLI.md | 305 ++ LICENSE.md | 7 + MANIFEST.md | 608 +++ README.md | 118 + examples/chrome-applescript/manifest.json | 73 + examples/chrome-applescript/server/index.js | 784 ++++ examples/chrome-applescript/yarn.lock | 90 + examples/file-manager-python/manifest.json | 77 + examples/file-manager-python/pyproject.toml | 31 + examples/file-manager-python/requirements.txt | 2 + examples/file-manager-python/server/main.py | 112 + examples/hello-world-node/icon.png | Bin 0 -> 506108 bytes examples/hello-world-node/manifest.json | 106 + examples/hello-world-node/package.json | 11 + examples/hello-world-node/server/index.js | 70 + examples/hello-world-node/yarn.lock | 621 +++ jest.config.js | 23 + package.json | 77 + scripts/create-dev-version.js | 33 + src/browser.ts | 4 + src/cli.ts | 13 + src/cli/cli.ts | 314 ++ src/cli/init.ts | 928 ++++ src/cli/pack.ts | 222 + src/index.ts | 9 + src/node.ts | 9 + src/node/files.ts | 191 + src/node/sign.ts | 409 ++ src/node/validate.ts | 52 + src/schemas.ts | 101 + src/shared/config.ts | 217 + src/shared/log.ts | 33 + src/types.ts | 64 + test/cli.test.ts | 80 + test/config.test.ts | 483 ++ test/dxtignore.test.ts | 261 ++ test/init.test.ts | 363 ++ test/invalid-manifest.json | 13 + test/schemas.test.ts | 150 + test/sign.e2e.test.ts | 467 ++ test/valid-manifest.json | 19 + tsconfig.json | 36 + tsconfig.test.json | 9 + yarn.lock | 4051 +++++++++++++++++ 48 files changed, 11896 insertions(+) create mode 100644 .eslintrc.json create mode 100644 .gitignore create mode 100644 .npmignore create mode 100644 .vscode/settings.json create mode 100644 CLI.md create mode 100644 LICENSE.md create mode 100644 MANIFEST.md create mode 100644 README.md create mode 100644 examples/chrome-applescript/manifest.json create mode 100644 examples/chrome-applescript/server/index.js create mode 100644 examples/chrome-applescript/yarn.lock create mode 100644 examples/file-manager-python/manifest.json create mode 100644 examples/file-manager-python/pyproject.toml create mode 100644 examples/file-manager-python/requirements.txt create mode 100644 examples/file-manager-python/server/main.py create mode 100644 examples/hello-world-node/icon.png create mode 100644 examples/hello-world-node/manifest.json create mode 100644 examples/hello-world-node/package.json create mode 100644 examples/hello-world-node/server/index.js create mode 100644 examples/hello-world-node/yarn.lock create mode 100644 jest.config.js create mode 100644 package.json create mode 100755 scripts/create-dev-version.js create mode 100644 src/browser.ts create mode 100644 src/cli.ts create mode 100644 src/cli/cli.ts create mode 100644 src/cli/init.ts create mode 100644 src/cli/pack.ts create mode 100644 src/index.ts create mode 100644 src/node.ts create mode 100644 src/node/files.ts create mode 100644 src/node/sign.ts create mode 100644 src/node/validate.ts create mode 100644 src/schemas.ts create mode 100644 src/shared/config.ts create mode 100644 src/shared/log.ts create mode 100644 src/types.ts create mode 100644 test/cli.test.ts create mode 100644 test/config.test.ts create mode 100644 test/dxtignore.test.ts create mode 100644 test/init.test.ts create mode 100644 test/invalid-manifest.json create mode 100644 test/schemas.test.ts create mode 100755 test/sign.e2e.test.ts create mode 100644 test/valid-manifest.json create mode 100644 tsconfig.json create mode 100644 tsconfig.test.json create mode 100644 yarn.lock diff --git a/.eslintrc.json b/.eslintrc.json new file mode 100644 index 0000000..6df6b4c --- /dev/null +++ b/.eslintrc.json @@ -0,0 +1,131 @@ +{ + "env": { + "es6": true + }, + "extends": [ + "eslint:recommended", + "prettier", + "plugin:@typescript-eslint/eslint-recommended", + "plugin:@typescript-eslint/recommended", + "plugin:import/recommended", + "plugin:import/typescript" + ], + "plugins": ["@typescript-eslint", "import", "prettier", "simple-import-sort"], + "parser": "@typescript-eslint/parser", + "ignorePatterns": ["dist/*", "node_modules/*", "*.js"], + "parserOptions": { + "project": "./tsconfig.json" + }, + "settings": { + "import/resolver": { + // Enables eslint-import-resolver-typescript + "typescript": {} + } + }, + "rules": { + "prettier/prettier": "warn", + // Require all external imports to be declared as a dependency + "import/no-extraneous-dependencies": [ + "error", + { + "packageDir": "./" + } + ], + // Imports must not cause cyclical dependencies + "import/no-cycle": [ + "error", + { "allowUnsafeDynamicCyclicDependency": true } + ], + "import/no-named-as-default-member": "off", + // Imports must be ordered appropriately + "simple-import-sort/imports": [ + "error", + { + "groups": [ + // Side effect imports. + ["^\\u0000"], + // Node.js builtins prefixed with `node:`. + ["^node:"], + // Packages. + // Things that start with a letter (or digit or underscore), or `@` followed by a letter. + ["^@?\\w"], + // Absolute imports + ["^@/"], + // Relative imports. + // Anything that starts with a dot. + ["^\\."] + ] + } + ], + "simple-import-sort/exports": "error", + // Imports must be placed before non-import statements + "import/first": "error", + "import/newline-after-import": "error", + "import/no-duplicates": "error", + + // Require a space at the start of comments + "spaced-comment": [ + "error", + "always", + { + "markers": ["/"] + } + ], + + // Make sure switch-case doesn't accidentally fall-through https://eslint.org/docs/latest/rules/no-fallthrough + "no-fallthrough": "error", + + "@typescript-eslint/ban-ts-comment": "warn", + + "@typescript-eslint/consistent-type-imports": [ + "error", + { + "prefer": "type-imports" + } + ], + + // Disallow annotating types where the type can be easily inferred + "@typescript-eslint/no-inferrable-types": [ + "error", + { + "ignoreParameters": false, + "ignoreProperties": false + } + ], + // Allow non-null assertions + "@typescript-eslint/no-non-null-assertion": "off", + // Disallow using 'any' explicitly in annotations + "@typescript-eslint/no-explicit-any": "error", + // Require promise outcomes to be properly handled + "@typescript-eslint/no-floating-promises": "error", + // Turn off base eslint rule in favor of typescript-eslint version + // to avoid getting eslint errors on type signatures + "no-unused-vars": "off", + // Disallow unused variables and imports + "@typescript-eslint/no-unused-vars": [ + "warn", + { + "args": "after-used", + "argsIgnorePattern": "^_", + "varsIgnorePattern": "^_", + "ignoreRestSiblings": true, + "vars": "all", + "args": "after-used", + "destructuredArrayIgnorePattern": "^_" + } + ], + + // Disallow empty functions + // If a function is intentionally empty, adding a comment line + // inside the function body is enough to pass this rule + "@typescript-eslint/no-empty-function": "error" + }, + "overrides": [ + { + "files": ["test/**/*.ts"], + "parserOptions": { + "project": "./tsconfig.test.json" + } + } + ] +} diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..c1ab374 --- /dev/null +++ b/.gitignore @@ -0,0 +1,108 @@ +# Logs +logs +*.log +npm-debug.log* +yarn-debug.log* +yarn-error.log* +lerna-debug.log* + +# Diagnostic reports (https://nodejs.org/api/report.html) +report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json + +# Runtime data +pids +*.pid +*.seed +*.pid.lock +.DS_Store + +# Directory for instrumented libs generated by jscoverage/JSCover +lib-cov + +# Coverage directory used by tools like istanbul +coverage +*.lcov + +# nyc test coverage +.nyc_output + +# node-waf configuration +.lock-wscript + +# Compiled binary addons (https://nodejs.org/api/addons.html) +build/ + +# Dependency directories +node_modules/ +jspm_packages/ + +# TypeScript v1 declaration files +typings/ + +# TypeScript cache +*.tsbuildinfo + +# Optional npm cache directory +.npm + +# Optional eslint cache +.eslintcache + +# Optional REPL history +.node_repl_history + +# Output of 'npm pack' +*.tgz + +# Yarn Integrity file +.yarn-integrity + +# dotenv environment variables file +.env +.env.test + +# parcel-bundler cache (https://parceljs.org/) +.cache + +# next.js build output +.next + +# nuxt.js build output +.nuxt + +# vuepress build output +.vuepress/dist + +# Serverless directories +.serverless/ + +# FuseBox cache +.fusebox/ + +# DynamoDB Local files +.dynamodb/ + +# Webpack +.webpack/ + +# Claude files +.claude.json +.claude/ + +# Vite +.vite/ + +# Electron-Forge +out/ +_out/ + +# Sentry auth token +.env.sentry-build-plugin + +# Dynamically-generated resources +dist +self-signed-cert.pem +self-signed-key.pem +*.dxt +invalid-json.json +**/server/lib/** \ No newline at end of file diff --git a/.npmignore b/.npmignore new file mode 100644 index 0000000..6044c33 --- /dev/null +++ b/.npmignore @@ -0,0 +1 @@ +!MANIFEST.md \ No newline at end of file diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..42a20bc --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,10 @@ +{ + "editor.formatOnSave": true, + "editor.codeActionsOnSave": { + "source.fixAll.eslint": "explicit" + }, + "eslint.validate": ["typescript"], + "[typescript]": { + "editor.defaultFormatter": "esbenp.prettier-vscode" + } +} diff --git a/CLI.md b/CLI.md new file mode 100644 index 0000000..bc21b8d --- /dev/null +++ b/CLI.md @@ -0,0 +1,305 @@ +# DXT CLI Documentation + +The DXT CLI provides tools for building Desktop Extensions. + +## Installation + +```bash +npm install -g @anthropic-ai/dxt +``` + +``` +Usage: dxt [options] [command] + +Tools for building Desktop Extensions + +Options: + -V, --version output the version number + -h, --help display help for command + +Commands: + init [directory] Create a new DXT extension manifest + validate Validate a DXT manifest file + pack [output] Pack a directory into a DXT extension + sign [options] Sign a DXT extension file + verify Verify the signature of a DXT extension file + info Display information about a DXT extension file + unsign Remove signature from a DXT extension file + help [command] display help for command +``` + +## Commands + +### `dxt init [directory]` + +Creates a new DXT extension manifest interactively. + +```bash +# Initialize in current directory +dxt init + +# Initialize in a specific directory +dxt init my-extension/ +``` + +The command will prompt you for: + +- Extension name (defaults from package.json or folder name) +- Author name (defaults from package.json) +- Extension ID (auto-generated from author and extension name) +- Display name +- Version (defaults from package.json or 1.0.0) +- Description +- Author email and URL (optional) +- Server type (Node.js, Python, or Binary) +- Entry point (with sensible defaults per server type) +- Tools configuration +- Keywords, license, and repository information + +After creating the manifest, it provides helpful next steps based on your server type. + +### `dxt validate ` + +Validates a DXT manifest file against the schema. You can provide either a direct path to a manifest.json file or a directory containing one. + +```bash +# Validate specific manifest file +dxt validate manifest.json + +# Validate manifest in directory +dxt validate ./my-extension +dxt validate . +``` + +### `dxt pack [output]` + +Packs a directory into a DXT extension file. + +```bash +# Pack current directory into extension.dxt +dxt pack . + +# Pack with custom output filename +dxt pack my-extension/ my-extension-v1.0.dxt +``` + +The command automatically: + +- Validates the manifest.json +- Excludes common development files (.git, node_modules/.cache, .DS_Store, etc.) +- Creates a compressed .dxt file (ZIP with maximum compression) + +### `dxt sign ` + +Signs a DXT extension file with a certificate. + +```bash +# Sign with default certificate paths +dxt sign my-extension.dxt + +# Sign with custom certificate and key +dxt sign my-extension.dxt --cert /path/to/cert.pem --key /path/to/key.pem + +# Sign with intermediate certificates +dxt sign my-extension.dxt --cert cert.pem --key key.pem --intermediate intermediate1.pem intermediate2.pem + +# Create and use a self-signed certificate +dxt sign my-extension.dxt --self-signed +``` + +Options: + +- `--cert, -c`: Path to certificate file (PEM format, default: cert.pem) +- `--key, -k`: Path to private key file (PEM format, default: key.pem) +- `--intermediate, -i`: Paths to intermediate certificate files +- `--self-signed`: Create a self-signed certificate if none exists + +### `dxt verify ` + +Verifies the signature of a signed DXT extension file. + +```bash +dxt verify my-extension.dxt +``` + +Output includes: + +- Signature validity status +- Certificate subject and issuer +- Certificate validity dates +- Certificate fingerprint +- Warning if self-signed + +### `dxt info ` + +Displays information about a DXT extension file. + +```bash +dxt info my-extension.dxt +``` + +Shows: + +- File size +- Signature status +- Certificate details (if signed) + +### `dxt unsign ` + +Removes the signature from a DXT extension file (for development/testing). + +```bash +dxt unsign my-extension.dxt +``` + +## Certificate Requirements + +For signing extensions, you need: + +1. **Certificate**: X.509 certificate in PEM format + + - Should have Code Signing extended key usage + - Can be self-signed (for development) or CA-issued (for production) + +2. **Private Key**: Corresponding private key in PEM format + + - Must match the certificate's public key + +3. **Intermediate Certificates** (optional): For CA-issued certificates + - Required for proper certificate chain validation + +## Example Workflows + +### Quick Start with Init + +```bash +# 1. Create a new extension directory +mkdir my-awesome-extension +cd my-awesome-extension + +# 2. Initialize the extension +dxt init + +# 3. Follow the prompts to configure your extension +# The tool will create a manifest.json with all necessary fields + +# 4. Create your server implementation based on the entry point you specified + +# 5. Pack the extension +dxt pack . + +# 6. (Optional) Sign the extension +dxt sign my-awesome-extension.dxt --self-signed +``` + +### Development Workflow + +```bash +# 1. Create your extension +mkdir my-extension +cd my-extension + +# 2. Initialize with dxt init or create manifest.json manually +dxt init + +# 3. Implement your server +# For Node.js: create server/index.js +# For Python: create server/main.py +# For Binary: add your executable + +# 4. Validate manifest +dxt validate manifest.json + +# 5. Pack extension +dxt pack . my-extension.dxt + +# 6. (Optional) Sign for testing +dxt sign my-extension.dxt --self-signed + +# 7. Verify signature +dxt verify my-extension.dxt + +# 8. Check extension info +dxt info my-extension.dxt +``` + +### Production Workflow + +```bash +# 1. Pack your extension +dxt pack my-extension/ + +# 2. Sign with production certificate +dxt sign my-extension.dxt \ + --cert production-cert.pem \ + --key production-key.pem \ + --intermediate intermediate-ca.pem root-ca.pem + +# 3. Verify before distribution +dxt verify my-extension.dxt +``` + +## Excluded Files + +When packing an extension, the following files/patterns are automatically excluded: + +- `.DS_Store`, `Thumbs.db` +- `.gitignore`, `.git/` +- `*.log`, `npm-debug.log*`, `yarn-debug.log*`, `yarn-error.log*` +- `.npm/`, `.npmrc`, `.yarnrc`, `.yarn/`, `.pnp.*` +- `node_modules/.cache/`, `node_modules/.bin/` +- `*.map` +- `.env.local`, `.env.*.local` +- `package-lock.json`, `yarn.lock` + +### Custom Exclusions with .dxtignore + +You can create a `.dxtignore` file in your extension directory to specify additional files and patterns to exclude during packing. This works similar to `.npmignore` or `.gitignore`: + +``` +# .dxtignore example +# Comments start with # +*.test.js +src/**/*.test.ts +coverage/ +*.log +.env* +temp/ +docs/ +``` + +The `.dxtignore` file supports: + +- **Exact matches**: `filename.txt` +- **Simple globs**: `*.log`, `temp/*` +- **Directory paths**: `docs/`, `coverage/` +- **Comments**: Lines starting with `#` are ignored +- **Empty lines**: Blank lines are ignored + +When a `.dxtignore` file is found, the CLI will display the number of additional patterns being applied. These patterns are combined with the default exclusion list. + +## Technical Details + +### Signature Format + +DXT uses PKCS#7 (Cryptographic Message Syntax) for digital signatures: + +- Signatures are stored in DER-encoded PKCS#7 SignedData format +- The signature is appended to the DXT file with markers (`DXT_SIG_V1` and `DXT_SIG_END`) +- The entire DXT content (excluding the signature block) is signed +- Detached signature format - the original ZIP content remains unmodified + +### Signature Structure + +``` +[Original DXT ZIP content] +DXT_SIG_V1 +[Base64-encoded PKCS#7 signature] +DXT_SIG_END +``` + +This approach allows: + +- Backward compatibility (unsigned DXT files are valid ZIP files) +- Easy signature verification and removal +- Support for certificate chains with intermediate certificates diff --git a/LICENSE.md b/LICENSE.md new file mode 100644 index 0000000..8f30a63 --- /dev/null +++ b/LICENSE.md @@ -0,0 +1,7 @@ +Copyright 2025 Anthropic, PBC. + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/MANIFEST.md b/MANIFEST.md new file mode 100644 index 0000000..d1dab68 --- /dev/null +++ b/MANIFEST.md @@ -0,0 +1,608 @@ +# DXT Manifest.json Spec + +Current version: `0.1` +Last updated: 2025-06-17 + +## Manifest Schema + +The `manifest.json` file contains all extension metadata and configuration. Most fields are optional. + +A basic `manifest.json` with just the required fields looks like this: + +```json +{ + "dxt_version": "0.1", // DXT spec version this manifest conforms to + "name": "my-extension", // Machine-readable name (used for CLI, APIs) + "version": "1.0.0", // Semantic version of your extension + "description": "A simple MCP extension", // Brief description of what the extension does + "author": { + // Author information (required) + "name": "Extension Author" // Author's name (required field) + }, + "server": { + // Server configuration (required) + "type": "node", // Server type: "node", "python", or "binary" + "entry_point": "server/index.js", // Path to the main server file + "mcp_config": { + // MCP server configuration + "command": "node", // Command to run the server + "args": [ + // Arguments passed to the command + "${__dirname}/server/index.js" // ${__dirname} is replaced with the extension's directory + ] + } + } +} +``` + +```json +{ + "dxt_version": "0.1", + "name": "my-extension", + "version": "1.0.0", + "description": "A simple MCP extension", + "author": { + "name": "Extension Author" + }, + "server": { + "type": "node", + "entry_point": "server/index.js", + "mcp_config": { + "command": "node", + "args": ["${__dirname}/server/index.js"], + "env": { + "API_KEY": "${user_config.api_key}" + } + } + }, + "user_config": { + "api_key": { + "type": "string", + "title": "API Key", + "description": "Your API key for authentication", + "sensitive": true, + "required": true + } + } +} +``` + +A full `manifest.json` with most of the optional fields looks like this: + +```json +{ + "dxt_version": "0.1", + "name": "My MCP Extension", + "display_name": "My Awesome MCP Extension", + "version": "1.0.0", + "description": "A brief description of what this extension does", + "long_description": "A detailed description that can include multiple paragraphs explaining the extension's functionality, use cases, and features. It supports basic markdown.", + "author": { + "name": "Your Name", + "email": "yourname@example.com", + "url": "https://your-website.com" + }, + "repository": { + "type": "git", + "url": "https://github.com/your-username/my-mcp-extension" + }, + "homepage": "https://example.com/my-extension", + "documentation": "https://docs.example.com/my-extension", + "support": "https://github.com/your-username/my-extension/issues", + "icon": "icon.png", + "screenshots": [ + "assets/screenshots/screenshot1.png", + "assets/screenshots/screenshot2.png" + ], + "server": { + "type": "node", + "entry_point": "server/index.js", + "mcp_config": { + "command": "node", + "args": ["server/index.js"], + "env": { + "ALLOWED_DIRECTORIES": "${user_config.allowed_directories}" + } + } + }, + "tools": [ + { + "name": "search_files", + "description": "Search for files in a directory" + } + ], + "prompts": [ + { + "name": "poetry", + "description": "Have the LLM write poetry", + "arguments": ["topic"], + "text": "Write a creative poem about the following topic: ${arguments.topic}" + } + ], + "tools_generated": true, + "keywords": ["api", "automation", "productivity"], + "license": "MIT", + "compatibility": { + "claude_desktop": ">=1.0.0", + "platforms": ["darwin", "win32", "linux"], + "runtimes": { + "python": ">=3.8", + "node": ">=16.0.0" + } + }, + "user_config": { + "allowed_directories": { + "type": "directory", + "title": "Allowed Directories", + "description": "Directories the server can access", + "multiple": true, + "required": true, + "default": ["${HOME}/Desktop"] + }, + "api_key": { + "type": "string", + "title": "API Key", + "description": "Your API key for authentication", + "sensitive": true, + "required": false + }, + "max_file_size": { + "type": "number", + "title": "Maximum File Size (MB)", + "description": "Maximum file size to process", + "default": 10, + "min": 1, + "max": 100 + } + } +} +``` + +## Field Definitions + +### Required Fields + +- **dxt_version**: Specification version this extension conforms to +- **name**: Machine-readable name (used for CLI, APIs) +- **version**: Semantic version (semver) +- **description**: Brief description +- **author**: Author information object with name (required), email (optional), and url (optional) +- **server**: Server configuration object + +### Optional Fields + +- **icon**: Path to a png icon file, either relative in the package or a https:// url. +- **display_name**: Human-friendly name for UI display +- **long_description**: Detailed description for extension stores, markdown +- **repository**: Source code repository information (type and url) +- **homepage**: Extension homepage URL +- **documentation**: Documentation URL +- **support**: Support/issues URL +- **screenshots**: Array of screenshot paths +- **tools**: Array of tools the extension provides +- **tools_generated**: Boolean indicating the server generates additional tools at runtime (default: false) +- **prompts**: Array of prompts the extension provides +- **prompts_generated**: Boolean indicating the server generates additional prompts at runtime (default: false) +- **keywords**: Search keywords +- **license**: License identifier +- **compatibility**: Compatibility requirements (client app version, platforms, and runtime versions) +- **user_config**: User-configurable options for the extension (see User Configuration section) + +## Compatibility + +The `compatibility` object specifies all requirements for running the extension. All fields, including the `compatibility` field itself, are optional. If you specify nothing, clients implementing DXT are encouraged to run the extension on any system. + +```json +{ + "compatibility": { + "claude_desktop": ">=1.0.0", + "my_client": ">1.0.0", + "other_client": ">=2.0.0 <3.0.0", + "platforms": ["darwin", "win32", "linux"], + "runtimes": { + "python": ">=3.8", + "node": ">=16.0.0" + } + } +} +``` + +### Fields + +#### Client Version Constraints + +The compatibility object supports version constraints for any client application: + +- **claude_desktop**: Minimum Claude Desktop version required (uses semver) +- **my_client**: Version constraint for a custom client (uses semver) +- **Other client names**: You can add version constraints for any client application + +All client version constraints use semver syntax (e.g., `">=1.0.0"`, `">1.0.0 <2.0.0"`, `"^1.2.3"`). + +#### System Requirements + +- **platforms**: Array of supported platforms (`darwin`, `win32`, `linux`). These match Node.js `process.platform` and Python's `sys.platform` values. If omitted, all platforms are supported +- **runtimes**: Runtime version requirements + - Only specify the runtime(s) your extension actually uses + - For Python extensions: specify `python` version + - For Node.js extensions: specify `node` version + - Binary extensions don't need runtime specifications + +**Note**: Use `darwin` for macOS, `win32` for Windows, and `linux` for Linux systems + +### Examples + +**Python Extension:** + +```json +{ + "server": { + "type": "python", + "entry_point": "server/main.py" + }, + "compatibility": { + "claude_desktop": ">=0.10.0", + "platforms": ["darwin", "win32", "linux"], + "runtimes": { + "python": ">=3.8,<4.0" + } + } +} +``` + +**Node.js Extension that only supports macOS:** + +```json +{ + "server": { + "type": "node", + "entry_point": "server/index.js" + }, + "compatibility": { + "claude_desktop": ">=0.10.0", + "platforms": ["darwin"], + "runtimes": { + "node": ">=16.0.0" + } + } +} +``` + +**Binary Extension (no runtime needed):** + +```json +{ + "server": { + "type": "binary", + "entry_point": "server/my-tool" + }, + "compatibility": { + "claude_desktop": ">=0.10.0", + "platforms": ["darwin", "win32"] + } +} +``` + +## Server Configuration + +The `server` object defines how to run the MCP server: + +### Server Types + +1. **Python**: `server.type = "python"` + + - Requires `entry_point` to Python file + - All dependencies must be bundled in the DXT + - Can use `server/lib` for packages or `server/venv` for full virtual environment + - Python runtime version specified in `compatibility.runtimes.python` + +2. **Node.js**: `server.type = "node"` + + - Requires `entry_point` to JavaScript file + - All dependencies must be bundled in `node_modules` + - Node.js runtime version specified in `compatibility.runtimes.node` + - Typically includes `package.json` at extension root for dependency management + +3. **Binary**: `server.type = "binary"` + - Pre-compiled executable with all dependencies included + - Platform-specific binaries supported + - Completely self-contained (no runtime requirements) + +### MCP Configuration + +The `mcp_config` object in the server configuration defines how the implementing app should execute the MCP server. This replaces the manual JSON configuration users currently need to write. + +**Python Example:** + +```json +"mcp_config": { + "command": "python", + "args": ["server/main.py"], + "env": { + "PYTHONPATH": "server/lib" + } +} +``` + +**Node.js Example:** + +```json +"mcp_config": { + "command": "node", + "args": ["${__dirname}/server/index.js"], + "env": {} +} +``` + +**Binary Example (Cross-Platform):** + +```json +"mcp_config": { + "command": "server/my-server", + "args": ["--config", "server/config.json"], + "env": {} +} +``` + +_Note: For binaries, apps will automatically append `.exe` on Windows_ + +**Platform-Specific Configurations:** +For cases where different platforms need different configurations, use platform-specific overrides: + +```json +"mcp_config": { + "command": "server/my-server", + "args": ["--config", "server/config.json"], + "env": {}, + "platform_overrides": { + "win32": { + "command": "server/my-server.exe", + "args": ["--config", "server/config-windows.json"] + }, + "darwin": { + "env": { + "DYLD_LIBRARY_PATH": "server/lib" + } + } + } +} +``` + +When installing the extension, apps will automatically generate the appropriate MCP server configuration and add it to the user's settings, eliminating the need for manual JSON editing. + +**Variable Substitution:** +The implementing desktop app will substitute variables in the `mcp_config` to make extensions more portable: + +- **`${__dirname}`**: This variable is replaced with the absolute path to the extension's directory. This is useful for referencing files within the extension package. +- **`${HOME}`**: User's home directory +- **`${DESKTOP}`**: User's desktop directory +- **`${DOCUMENTS}`**: User's documents directory +- **`${DOWNLOADS}`**: User's downloads directory +- **`${pathSeparator}`** or **`${/}`**: Path separator for the current platform + +Example: + +```json +"mcp_config": { + "command": "python", + "args": ["${__dirname}/server/main.py"], + "env": { + "CONFIG_PATH": "${__dirname}/config/settings.json" + } +} +``` + +This ensures that paths work correctly regardless of where the extension is installed on the user's system. + +- **`${user_config}`**: Your extension can specify user-configured values that the implementing app will collect from users. Read on to learn more about user configuration. + +## User Configuration + +The `user_config` field allows extension developers to specify configuration options that can be presented to end users through the implementing app's user interface. These configurations are collected from users and passed to the MCP server at runtime. + +### Configuration Schema + +Each configuration option is defined as a key-value pair where the key is the configuration name and the value is an object with these properties: + +- **type**: The data type of the configuration + - `"string"`: Text input + - `"number"`: Numeric input + - `"boolean"`: Checkbox/toggle + - `"directory"`: Directory picker + - `"file"`: File picker +- **title**: Display name shown in the UI +- **description**: Help text explaining the configuration option +- **required**: Whether this field must be provided (default: false) +- **default**: Default value (supports variable substitution) +- **multiple**: For directory/file types, allow multiple selections (default: false) +- **sensitive**: For string types, mask input and store securely (default: false) +- **min/max**: For number types, validation constraints + +### Variable Substitution in User Configuration + +User configuration values support variable substitution in `mcp_config`: + +- **`${user_config.KEY}`**: Replaced with the user-provided value for configuration KEY +- Arrays (from multiple selections) are expanded as separate arguments +- Environment variables are ideal for sensitive data +- Command arguments work well for paths and non-sensitive options + +Available variables for default values: + +- **`${HOME}`**: User's home directory +- **`${DESKTOP}`**: User's desktop directory +- **`${DOCUMENTS}`**: User's documents directory + +### Examples + +**Filesystem Extension with Directory Configuration:** + +```json +{ + "user_config": { + "allowed_directories": { + "type": "directory", + "title": "Allowed Directories", + "description": "Select directories the filesystem server can access", + "multiple": true, + "required": true, + "default": ["${HOME}/Desktop", "${HOME}/Documents"] + } + }, + "server": { + "mcp_config": { + "command": "node", + "args": [ + "${__dirname}/server/index.js", + "${user_config.allowed_directories}" + ] + } + } +} +``` + +**API Integration with Authentication:** + +```json +{ + "user_config": { + "api_key": { + "type": "string", + "title": "API Key", + "description": "Your API key for authentication", + "sensitive": true, + "required": true + }, + "base_url": { + "type": "string", + "title": "API Base URL", + "description": "The base URL for API requests", + "default": "https://api.example.com", + "required": false + } + }, + "server": { + "mcp_config": { + "command": "node", + "args": ["server/index.js"], + "env": { + "API_KEY": "${user_config.api_key}", + "BASE_URL": "${user_config.base_url}" + } + } + } +} +``` + +**Database Connection Configuration:** + +```json +{ + "user_config": { + "database_path": { + "type": "file", + "title": "Database File", + "description": "Path to your SQLite database file", + "required": true + }, + "read_only": { + "type": "boolean", + "title": "Read Only Mode", + "description": "Open database in read-only mode", + "default": true + }, + "timeout": { + "type": "number", + "title": "Query Timeout (seconds)", + "description": "Maximum time for query execution", + "default": 30, + "min": 1, + "max": 300 + } + }, + "server": { + "mcp_config": { + "command": "python", + "args": [ + "server/main.py", + "--database", + "${user_config.database_path}", + "--timeout", + "${user_config.timeout}" + ], + "env": { + "READ_ONLY": "${user_config.read_only}" + } + } + } +} +``` + +### Implementation Notes + +- **Array Expansion**: When a configuration with `multiple: true` is used in `args`, each value is expanded as a separate argument. For example, if the user selects directories `/home/user/docs` and `/home/user/projects`, the args `["${user_config.allowed_directories}"]` becomes `["/home/user/docs", "/home/user/projects"]`. + +## Tools and Prompts + +These fields describe the tools and prompts your MCP server provides. For servers that generate capabilities dynamically at runtime, you can use the `_generated` flags to indicate this. + +Note: Resources are not included in the manifest because MCP resources are inherently dynamic - they represent URIs to data that the server discovers at runtime based on configuration, filesystem state, database connections, etc. + +### Static Declaration + +For servers with a fixed set of capabilities, list them in arrays. + +#### Prompt Structure + +Each prompt in the `prompts` array must include: + +- **name**: The identifier for the prompt +- **description** (optional): Explanation of what the prompt does +- **arguments** (optional): Array of argument names that can be used in the prompt text +- **text**: The actual prompt text that uses template variables like `${arguments.topic}` or `${arguments.aspect}` as placeholders for MCP Client-supplied arguments. If your argument is named `language`, you'd add `${arguments.language} where you expect it to show up in the prompt. + +Example: + +```json +{ + "tools": [ + { "name": "search_files", "description": "Search for files" }, + { "name": "read_file", "description": "Read file contents" } + ], + "prompts": [ + { + "name": "explain_code", + "description": "Explain how code works", + "arguments": ["code", "language"], + "text": "Please explain the following ${arguments.language} code in detail:\n\n${arguments.code}" + } + ] +} +``` + +Implementing apps may choose to validate prompts at run-time against the declaration of your prompts in the manifest. + +### Dynamic Generation + +For servers that generate capabilities based on context, configuration, or runtime discovery, use the `_generated` flags: + +```json +{ + "tools": [{ "name": "search", "description": "Search functionality" }], + "tools_generated": true, + "prompts_generated": true +} +``` + +This indicates that: + +- The server provides at least the `search` tool (and possibly more) +- Additional tools are generated at runtime +- Prompts are generated at runtime + +The `_generated` fields: + +- **tools_generated**: Server generates additional tools beyond those listed (default: false) +- **prompts_generated**: Server generates additional prompts beyond those listed (default: false) + +This helps implementing apps understand that querying the server at runtime will reveal more capabilities than what's declared in the manifest. diff --git a/README.md b/README.md new file mode 100644 index 0000000..e08dee5 --- /dev/null +++ b/README.md @@ -0,0 +1,118 @@ +# Desktop Extensions (DXT) + +Desktop Extensions (`.dxt`) are zip archives containing a local MCP server and a `manifest.json` that describes the server and its capabilities. The format is spiritually similar to Chrome extensions (`.crx`) or VS Code extensions (`.vsix`), enabling end users to install local MCP servers with a single click. + +This repository provides three components: The extension specification in [MANIFEST.md](MANIFEST.md), a CLI tool for creating extensions (see [CLI.md](CLI.md)), and the code used by Claude for macOS and Windows to load and verify DXT extensions ([src/index.ts](src/index.ts)). + +- For developers of local MCP servers, we aim to make distribution and installation of said servers convenient +- For developers of apps supporting local MCP servers, we aim to make it easy to add support for DXT extensions + +Claude for macOS and Windows uses the code in this repository to enable single-click installation of local MCP servers, including a number of end user-friendly features - such as automatic updates, easy configuration of MCP servers and the variables and parameters they need, and a curated directory. We are committed to the open ecosystem around MCP servers and believe that its ability to be universally adopted by multiple applications and services has benefits developers aiming to connect AI tools to other apps and services. Consequently, we’re open-sourcing the Desktop Extension specification, toolchain, and the schemas and key functions used by Claude for macOS and Windows to implement its own support of Desktop Extensions. It is our hope that the `dxt` format doesn’t just make local MCP servers more portable for Claude, but other AI desktop applications, too. + +# For Extension Developers + +At the core, DXT are simple zip files containing your entire MCP server and a `manifest.json`. Consequently, turning a local MCP server into an extension is straightforward: You just have to put all your required files in a folder, create a `manifest.json`, and then create an archive. + +To make this process easier, this package offers a CLI that helps you with the creation of both the `manifest.json` and the final `.dxt` file. To install it, run: + +```sh +npm install -g @anthropic-ai/dxt +``` + +1. In a folder containing your local MCP server, run `dxt init`. This command will guide you through the creation of a `manifest.json`. +2. Run `dxt pack` to create a `dxt` file. +3. Now, any app implementing support for DXT can run your local MCP server. As an example, open the file with Claude for macOS and Windows to show an installation dialog. + +You can find the full spec for the `manifest.json` and all its mandatory and optional fields in [MANIFEST.md](MANIFEST.md). Examples for extensions can be found in [examples](./examples/). + +## Prompt Template for AI Tools + +AI tools like Claude Code are particularly good at creating desktop extensions when informed about the spec. When prompting an AI coding tool to build an extension, briefly explain what your extension aims to do - then add the following context to your instructions. + +> I want to build this as a Desktop Extension, abbreviated as "DXT". Please follow these steps: +> +> 1. **Read the specifications thoroughly:** +> - https://github.com/anthropics/dxt/blob/main/README.md - DXT architecture overview, capabilities, and integration +> patterns +> - https://github.com/anthropics/dxt/blob/main/MANIFEST.md - Complete extension manifest structure and field definitions +> - https://github.com/anthropics/dxt/tree/main/examples - Reference implementations including a "Hello World" example +> 2. **Create a proper extension structure:** +> - Generate a valid manifest.json following the MANIFEST.md spec +> - Implement an MCP server using @modelcontextprotocol/sdk with proper tool definitions +> - Include proper error handling, security measures, and timeout management +> 3. **Follow best development practices:** +> - Implement proper MCP protocol communication via stdio transport +> - Structure tools with clear schemas, validation, and consistent JSON responses +> - Make use of the fact that this extension will be running locally +> - Add appropriate logging and debugging capabilities +> - Include proper documentation and setup instructions +> 4. **Test considerations:** +> - Validate that all tool calls return properly structured responses +> - Verify manifest loads correctly and host integration works +> +> Generate complete, production-ready code that can be immediately tested. Focus on defensive programming, clear error messages, and following the exact DXT specifications to ensure compatibility with the ecosystem. + +## Directory Structures + +### Minimal Extension + +A `manifest.json` is the only required file. + +### Example: Node.js Extension + +``` +extension.dxt (ZIP file) +├── manifest.json # Required: Extension metadata and configuration +├── server/ # Server files +│ └── index.js # Main entry point +├── node_modules/ # Bundled dependencies +├── package.json # Optional: NPM package definition +├── icon.png # Optional: Extension icon +└── assets/ # Optional: Additional assets +``` + +### Example: Python Extension + +``` +extension.dxt (ZIP file) +├── manifest.json # Required: Extension metadata and configuration +├── server/ # Server files +│ ├── main.py # Main entry point +│ └── utils.py # Additional modules +├── lib/ # Bundled Python packages +├── requirements.txt # Optional: Python dependencies list +└── icon.png # Optional: Extension icon +``` + +### Example: Binary Extension + +``` +extension.dxt (ZIP file) +├── manifest.json # Required: Extension metadata and configuration +├── server/ # Server files +│ ├── my-server # Unix executable +│ ├── my-server.exe # Windows executable +└── icon.png # Optional: Extension icon +``` + +### Bundling Dependencies + +**Python Extensions:** + +- Bundle all required packages in `server/lib/` directory +- OR bundle a complete virtual environment in `server/venv/` +- Use tools like `pip-tools`, `poetry`, or `pipenv` to create reproducible bundles +- Set `PYTHONPATH` to include bundled packages via `mcp_config.env` + +**Node.js Extensions:** + +- Run `npm install --production` to create `node_modules` +- Bundle the entire `node_modules` directory with your extension +- Use `npm ci` or `yarn install --frozen-lockfile` for reproducible builds +- Server entry point specified in manifest.json's `server.entry_point` + +**Binary Extensions:** + +- Static linking preferred for maximum compatibility +- Include all required shared libraries if dynamic linking used +- Test on clean systems without development tools diff --git a/examples/chrome-applescript/manifest.json b/examples/chrome-applescript/manifest.json new file mode 100644 index 0000000..aebeafe --- /dev/null +++ b/examples/chrome-applescript/manifest.json @@ -0,0 +1,73 @@ +{ + "dxt_version": "0.1", + "name": "chrome-applescript", + "display_name": "Control Chrome with AppleScript", + "version": "0.1.0", + "description": "Control Google Chrome browser tabs, windows, and navigation", + "long_description": "This extension allows you to control Google Chrome browser tabs, windows, and navigation through Chrome's official AppleScript API. You can open URLs, manage tabs, execute JavaScript, and retrieve page content.\n\nThis extension is meant to be a demonstration of Desktop Extensions.\n\nThis extension is not affiliated with Google or Chrome.", + "author": { + "name": "Anthropic", + "email": "support@anthropic.com", + "url": "https://github.com/anthropics" + }, + "scripts": { + "start": "node server/index.js", + "build": "npx @anthropic-ai/dxt pack" + }, + "server": { + "type": "node", + "entry_point": "server/index.js", + "mcp_config": { + "command": "node", + "args": ["${__dirname}/server/index.js"], + "env": {} + } + }, + "tools": [ + { + "name": "open_url", + "description": "Open a URL in Chrome, either in a new tab or current tab." + }, + { + "name": "get_current_tab", + "description": "Get information about the current active tab." + }, + { + "name": "list_tabs", + "description": "List all open tabs in Chrome." + }, + { + "name": "close_tab", + "description": "Close a specific tab." + }, + { + "name": "switch_to_tab", + "description": "Switch to a specific tab." + }, + { + "name": "reload_tab", + "description": "Reload a tab." + }, + { + "name": "go_back", + "description": "Navigate back in browser history." + }, + { + "name": "go_forward", + "description": "Navigate forward in browser history." + }, + { + "name": "execute_javascript", + "description": "Execute JavaScript in the current tab." + }, + { + "name": "get_page_content", + "description": "Get the text content of the current page." + } + ], + "compatibility": { + "platforms": ["darwin"] + }, + "keywords": ["chrome", "browser", "remote"], + "license": "MIT" +} diff --git a/examples/chrome-applescript/server/index.js b/examples/chrome-applescript/server/index.js new file mode 100644 index 0000000..dd96bdd --- /dev/null +++ b/examples/chrome-applescript/server/index.js @@ -0,0 +1,784 @@ +#!/usr/bin/env node + +import { Server } from "@modelcontextprotocol/sdk/server/index.js"; +import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"; +import { + CallToolRequestSchema, + ListToolsRequestSchema, +} from "@modelcontextprotocol/sdk/types.js"; +import { execFile } from "child_process"; +import { promisify } from "util"; + +const execFileAsync = promisify(execFile); + +// Constants +const APPLESCRIPT_TIMEOUT = 10000; // 10 seconds +const MAX_RETRIES = 3; +const RETRY_DELAY = 1000; // 1 second + +class ChromeControlServer { + constructor() { + this.server = new Server( + { + name: "chrome-applescript", + version: "0.1.0", + }, + { + capabilities: { + tools: {}, + }, + }, + ); + + this.setupHandlers(); + } + + // Helper methods + escapeForAppleScript(str) { + if (typeof str !== "string") return str; + // Basic AppleScript string escaping + return str + .replace(/\\/g, "\\\\") // Escape backslashes first + .replace(/"/g, '\\"') // Then escape double quotes + .replace(/\n/g, "\\n") // Escape newlines + .replace(/\r/g, "\\r"); // Escape carriage returns + } + + async checkChromeAvailable() { + try { + const script = 'tell application "Google Chrome" to return "available"'; + const result = await this.executeAppleScript(script); + return result === "available"; + } catch (error) { + return false; + } + } + + async executeAppleScript(script, retries = MAX_RETRIES) { + for (let attempt = 0; attempt <= retries; attempt++) { + try { + const { stdout, stderr } = await execFileAsync( + "osascript", + ["-e", script], + { + timeout: APPLESCRIPT_TIMEOUT, + maxBuffer: 1024 * 1024, // 1MB buffer + }, + ); + if (stderr) { + console.error("AppleScript stderr:", stderr); + } + return stdout.trim(); + } catch (error) { + if (attempt === retries) { + console.error("AppleScript execution error after retries:", error); + throw new Error(`AppleScript error: ${error.message}`); + } + // Retry with exponential backoff + await new Promise((resolve) => + setTimeout(resolve, RETRY_DELAY * Math.pow(2, attempt)), + ); + } + } + } + + async findTabById(tabId) { + const script = ` + tell application "Google Chrome" + repeat with w in windows + repeat with t in tabs of w + if (id of t as string) is "${tabId}" then + return {w, t, true} + end if + end repeat + end repeat + return {null, null, false} + end tell + `; + return this.executeAppleScript(script); + } + + async executeTabOperation( + tabId, + operation, + successMessage = "Operation completed", + ) { + if (!tabId) { + // No tab ID, execute on active tab + return this.executeAppleScript(operation.activeScript); + } + + const script = ` + tell application "Google Chrome" + repeat with w in windows + repeat with t in tabs of w + if (id of t as string) is "${tabId}" then + ${operation.tabScript} + return "${successMessage}" + end if + end repeat + end repeat + return "Tab not found" + end tell + `; + return this.executeAppleScript(script); + } + + setupHandlers() { + this.server.setRequestHandler(ListToolsRequestSchema, async () => ({ + tools: [ + { + name: "open_url", + description: "Open a URL in Chrome", + inputSchema: { + type: "object", + properties: { + url: { type: "string", description: "URL to open" }, + new_tab: { + type: "boolean", + description: "Open in a new tab", + default: true, + }, + }, + required: ["url"], + }, + }, + { + name: "get_current_tab", + description: "Get information about the current active tab", + inputSchema: { type: "object", properties: {} }, + }, + { + name: "list_tabs", + description: "List all open tabs in Chrome", + inputSchema: { + type: "object", + properties: { + window_id: { + type: "number", + description: "Specific window ID to list tabs from", + }, + }, + }, + }, + { + name: "close_tab", + description: "Close a specific tab", + inputSchema: { + type: "object", + properties: { + tab_id: { type: "number", description: "ID of the tab to close" }, + }, + required: ["tab_id"], + }, + }, + { + name: "switch_to_tab", + description: "Switch to a specific tab", + inputSchema: { + type: "object", + properties: { + tab_id: { + type: "number", + description: "ID of the tab to switch to", + }, + }, + required: ["tab_id"], + }, + }, + { + name: "reload_tab", + description: "Reload a tab", + inputSchema: { + type: "object", + properties: { + tab_id: { + type: "number", + description: "ID of the tab to reload", + }, + }, + }, + }, + { + name: "go_back", + description: "Navigate back in browser history", + inputSchema: { + type: "object", + properties: { + tab_id: { type: "number", description: "ID of the tab" }, + }, + }, + }, + { + name: "go_forward", + description: "Navigate forward in browser history", + inputSchema: { + type: "object", + properties: { + tab_id: { type: "number", description: "ID of the tab" }, + }, + }, + }, + { + name: "execute_javascript", + description: "Execute JavaScript in the current tab", + inputSchema: { + type: "object", + properties: { + code: { + type: "string", + description: "JavaScript code to execute", + }, + tab_id: { type: "number", description: "ID of the tab" }, + }, + required: ["code"], + }, + }, + { + name: "get_page_content", + description: "Get the text content of the current page", + inputSchema: { + type: "object", + properties: { + tab_id: { type: "number", description: "ID of the tab" }, + }, + }, + }, + ], + })); + + this.server.setRequestHandler(CallToolRequestSchema, async (request) => { + const { name, arguments: args } = request.params; + + try { + // Check Chrome availability first + const isChromeAvailable = await this.checkChromeAvailable(); + if (!isChromeAvailable) { + return { + content: [ + { + type: "text", + text: "Error: Google Chrome is not available or not running", + }, + ], + isError: true, + }; + } + + switch (name) { + case "open_url": { + const { url, new_tab = true } = args; + if (!url || typeof url !== "string") { + throw new Error("URL is required and must be a string"); + } + + const escapedUrl = this.escapeForAppleScript(url); + const script = new_tab + ? `tell application "Google Chrome" to open location "${escapedUrl}"` + : `tell application "Google Chrome" to set URL of active tab of front window to "${escapedUrl}"`; + + await this.executeAppleScript(script); + return { + content: [ + { + type: "text", + text: JSON.stringify( + { + success: true, + action: new_tab + ? "opened_new_tab" + : "navigated_current_tab", + url: url, + }, + null, + 2, + ), + }, + ], + }; + } + + case "get_current_tab": { + const script = ` + tell application "Google Chrome" + set currentTab to active tab of front window + set tabInfo to {URL of currentTab, title of currentTab, id of currentTab} + return tabInfo + end tell + `; + const result = await this.executeAppleScript(script); + const [url, title, id] = result.split(", "); + return { + content: [ + { + type: "text", + text: JSON.stringify( + { + success: true, + url, + title, + id: parseInt(id), + }, + null, + 2, + ), + }, + ], + }; + } + + case "list_tabs": { + const script = ` + tell application "Google Chrome" + set tabsList to {} + repeat with w in windows + repeat with t in tabs of w + set end of tabsList to {id of t as string, URL of t, title of t} + end repeat + end repeat + set AppleScript's text item delimiters to "|" + set output to "" + repeat with tabInfo in tabsList + set output to output & (item 1 of tabInfo) & "," & (item 2 of tabInfo) & "," & (item 3 of tabInfo) & "|" + end repeat + return output + end tell + `; + const result = await this.executeAppleScript(script); + const tabs = result + .split("|") + .filter((tab) => tab) + .map((tab) => { + const [id, url, title] = tab.split(","); + return { id: parseInt(id), url, title }; + }); + return { + content: [ + { + type: "text", + text: JSON.stringify( + { + success: true, + tabs: tabs, + count: tabs.length, + }, + null, + 2, + ), + }, + ], + }; + } + + case "close_tab": { + const { tab_id } = args; + + const result = await this.executeTabOperation( + tab_id, + { + tabScript: "close t", + activeScript: ` + tell application "Google Chrome" + close active tab of front window + return "Tab closed" + end tell + `, + }, + "Tab closed", + ); + + return { + content: [ + { + type: "text", + text: JSON.stringify( + { + success: result === "Tab closed", + message: result, + }, + null, + 2, + ), + }, + ], + }; + } + + case "switch_to_tab": { + const { tab_id } = args; + + const result = await this.executeTabOperation( + tab_id, + { + tabScript: ` + set active tab of w to t + set index of w to 1 + activate + `, + activeScript: ` + tell application "Google Chrome" + activate + return "Chrome activated" + end tell + `, + }, + "Switched to tab", + ); + + return { + content: [ + { + type: "text", + text: JSON.stringify( + { + success: result !== "Tab not found", + message: result, + }, + null, + 2, + ), + }, + ], + }; + } + + case "reload_tab": { + const { tab_id } = args; + + const result = await this.executeTabOperation( + tab_id, + { + tabScript: "reload t", + activeScript: ` + tell application "Google Chrome" + reload active tab of front window + return "Tab reloaded" + end tell + `, + }, + "Tab reloaded", + ); + + return { + content: [ + { + type: "text", + text: JSON.stringify( + { + success: result !== "Tab not found", + message: result, + }, + null, + 2, + ), + }, + ], + }; + } + + case "go_back": { + const { tab_id } = args; + + const result = await this.executeTabOperation( + tab_id, + { + tabScript: "go back t", + activeScript: ` + tell application "Google Chrome" + go back active tab of front window + return "Navigated back" + end tell + `, + }, + "Navigated back", + ); + + return { + content: [ + { + type: "text", + text: JSON.stringify( + { + success: result !== "Tab not found", + message: result, + }, + null, + 2, + ), + }, + ], + }; + } + + case "go_forward": { + const { tab_id } = args; + + const result = await this.executeTabOperation( + tab_id, + { + tabScript: "go forward t", + activeScript: ` + tell application "Google Chrome" + go forward active tab of front window + return "Navigated forward" + end tell + `, + }, + "Navigated forward", + ); + + return { + content: [ + { + type: "text", + text: JSON.stringify( + { + success: result !== "Tab not found", + message: result, + }, + null, + 2, + ), + }, + ], + }; + } + + case "execute_javascript": { + const { code, tab_id } = args; + if (!code || typeof code !== "string") { + throw new Error( + "JavaScript code is required and must be a string", + ); + } + + // Wrap the code to capture console.log outputs + const wrappedCode = ` + (function() { + const logs = []; + const originalLog = console.log; + const originalWarn = console.warn; + const originalError = console.error; + const originalInfo = console.info; + + console.log = function(...args) { + logs.push({type: 'log', message: args.map(arg => { + try { + return typeof arg === 'object' ? JSON.stringify(arg) : String(arg); + } catch (e) { + return String(arg); + } + }).join(' ')}); + originalLog.apply(console, args); + }; + + console.warn = function(...args) { + logs.push({type: 'warn', message: args.map(arg => { + try { + return typeof arg === 'object' ? JSON.stringify(arg) : String(arg); + } catch (e) { + return String(arg); + } + }).join(' ')}); + originalWarn.apply(console, args); + }; + + console.error = function(...args) { + logs.push({type: 'error', message: args.map(arg => { + try { + return typeof arg === 'object' ? JSON.stringify(arg) : String(arg); + } catch (e) { + return String(arg); + } + }).join(' ')}); + originalError.apply(console, args); + }; + + console.info = function(...args) { + logs.push({type: 'info', message: args.map(arg => { + try { + return typeof arg === 'object' ? JSON.stringify(arg) : String(arg); + } catch (e) { + return String(arg); + } + }).join(' ')}); + originalInfo.apply(console, args); + }; + + let result; + try { + result = (function() { + ${code} + })(); + } catch (error) { + result = {error: error.toString(), stack: error.stack}; + } finally { + console.log = originalLog; + console.warn = originalWarn; + console.error = originalError; + console.info = originalInfo; + } + + return { + result: result, + logs: logs + }; + })(); + `; + + const escapedCode = this.escapeForAppleScript(wrappedCode); + + const script = tab_id + ? ` + tell application "Google Chrome" + repeat with w in windows + repeat with t in tabs of w + if (id of t as string) is "${tab_id}" then + set result to execute t javascript "${escapedCode}" + return result + end if + end repeat + end repeat + return "Tab not found" + end tell + ` + : ` + tell application "Google Chrome" + execute active tab of front window javascript "${escapedCode}" + end tell + `; + + const result = await this.executeAppleScript(script); + + // Parse the result to extract logs and actual result + try { + const parsed = JSON.parse(result); + + return { + content: [ + { + type: "text", + text: JSON.stringify( + { + success: true, + logs: parsed.logs || [], + result: parsed.result, + hasErrors: + parsed.result && parsed.result.error ? true : false, + }, + null, + 2, + ), + }, + ], + }; + } catch (e) { + // If parsing fails, return structured error + return { + content: [ + { + type: "text", + text: JSON.stringify( + { + success: false, + error: "Failed to parse JavaScript execution result", + rawResult: result || "No result returned", + }, + null, + 2, + ), + }, + ], + }; + } + } + + case "get_page_content": { + const { tab_id } = args; + + const jsCode = "document.body.innerText"; + const script = tab_id + ? ` + tell application "Google Chrome" + repeat with w in windows + repeat with t in tabs of w + if (id of t as string) is "${tab_id}" then + set pageContent to execute t javascript "${jsCode}" + return pageContent + end if + end repeat + end repeat + return "Tab not found" + end tell + ` + : ` + tell application "Google Chrome" + execute active tab of front window javascript "${jsCode}" + end tell + `; + + const result = await this.executeAppleScript(script); + return { + content: [ + { + type: "text", + text: JSON.stringify( + { + success: result !== "Tab not found", + content: result, + contentLength: result.length, + }, + null, + 2, + ), + }, + ], + }; + } + + default: + throw new Error(`Unknown tool: ${name}`); + } + } catch (error) { + console.error(`Error in tool '${name}':`, error); + return { + content: [ + { + type: "text", + text: JSON.stringify( + { + success: false, + error: error.message, + tool: name, + args: args, + }, + null, + 2, + ), + }, + ], + isError: true, + }; + } + }); + } + + async run() { + try { + const isChromeAvailable = await this.checkChromeAvailable(); + if (!isChromeAvailable) { + console.error("Warning: Google Chrome is not available or not running"); + } + + const transport = new StdioServerTransport(); + await this.server.connect(transport); + console.error("Chrome AppleScript MCP server running on stdio"); + } catch (error) { + console.error("Failed to start Chrome AppleScript MCP server:", error); + throw error; + } + } +} + +const server = new ChromeControlServer(); +server.run().catch(console.error); diff --git a/examples/chrome-applescript/yarn.lock b/examples/chrome-applescript/yarn.lock new file mode 100644 index 0000000..68af468 --- /dev/null +++ b/examples/chrome-applescript/yarn.lock @@ -0,0 +1,90 @@ +# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY. +# yarn lockfile v1 + + +"@modelcontextprotocol/sdk@^0.6.0": + version "0.6.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@modelcontextprotocol/sdk/-/sdk-0.6.1.tgz#4e144155992749faf191faa512ac0c7a23152522" + integrity sha512-OkVXMix3EIbB5Z6yife2XTrSlOnVvCLR1Kg91I4pYFEsV9RbnoyQVScXCuVhGaZHOnTZgso8lMQN1Po2TadGKQ== + dependencies: + content-type "^1.0.5" + raw-body "^3.0.0" + zod "^3.23.8" + +bytes@3.1.2: + version "3.1.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/bytes/-/bytes-3.1.2.tgz#8b0beeb98605adf1b128fa4386403c009e0221a5" + integrity sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg== + +content-type@^1.0.5: + version "1.0.5" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/content-type/-/content-type-1.0.5.tgz#8b773162656d1d1086784c8f23a54ce6d73d7918" + integrity sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA== + +depd@2.0.0: + version "2.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/depd/-/depd-2.0.0.tgz#b696163cc757560d09cf22cc8fad1571b79e76df" + integrity sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw== + +http-errors@2.0.0: + version "2.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/http-errors/-/http-errors-2.0.0.tgz#b7774a1486ef73cf7667ac9ae0858c012c57b9d3" + integrity sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ== + dependencies: + depd "2.0.0" + inherits "2.0.4" + setprototypeof "1.2.0" + statuses "2.0.1" + toidentifier "1.0.1" + +iconv-lite@0.6.3: + version "0.6.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/iconv-lite/-/iconv-lite-0.6.3.tgz#a52f80bf38da1952eb5c681790719871a1a72501" + integrity sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw== + dependencies: + safer-buffer ">= 2.1.2 < 3.0.0" + +inherits@2.0.4: + version "2.0.4" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c" + integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ== + +raw-body@^3.0.0: + version "3.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/raw-body/-/raw-body-3.0.0.tgz#25b3476f07a51600619dae3fe82ddc28a36e5e0f" + integrity sha512-RmkhL8CAyCRPXCE28MMH0z2PNWQBNk2Q09ZdxM9IOOXwxwZbN+qbWaatPkdkWIKL2ZVDImrN/pK5HTRz2PcS4g== + dependencies: + bytes "3.1.2" + http-errors "2.0.0" + iconv-lite "0.6.3" + unpipe "1.0.0" + +"safer-buffer@>= 2.1.2 < 3.0.0": + version "2.1.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/safer-buffer/2.1.2/safer-buffer-2.1.2.tgz#44fa161b0187b9549dd84bb91802f9bd8385cd6a" + integrity sha1-RPoWGwGHuVSd2Eu5GAL5vYOFzWo= + +setprototypeof@1.2.0: + version "1.2.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/setprototypeof/-/setprototypeof-1.2.0.tgz#66c9a24a73f9fc28cbe66b09fed3d33dcaf1b424" + integrity sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw== + +statuses@2.0.1: + version "2.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/statuses/-/statuses-2.0.1.tgz#55cb000ccf1d48728bd23c685a063998cf1a1b63" + integrity sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ== + +toidentifier@1.0.1: + version "1.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/toidentifier/-/toidentifier-1.0.1.tgz#3be34321a88a820ed1bd80dfaa33e479fbb8dd35" + integrity sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA== + +unpipe@1.0.0: + version "1.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/unpipe/-/unpipe-1.0.0.tgz#b2bf4ee8514aae6165b4817829d21b2ef49904ec" + integrity sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ== + +zod@^3.23.8: + version "3.25.55" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/zod/-/zod-3.25.55.tgz#b1ffd48a34f558d1a912d1ed6bf84a6ca692fbe1" + integrity sha512-219huNnkSLQnLsQ3uaRjXsxMrVm5C9W3OOpEVt2k5tvMKuA8nBSu38e0B//a+he9Iq2dvmk2VyYVlHqiHa4YBA== diff --git a/examples/file-manager-python/manifest.json b/examples/file-manager-python/manifest.json new file mode 100644 index 0000000..7ae50af --- /dev/null +++ b/examples/file-manager-python/manifest.json @@ -0,0 +1,77 @@ +{ + "dxt_version": "0.1", + "name": "file-manager-python", + "display_name": "Python File Manager MCP", + "version": "0.1.0", + "description": "A Python MCP server for file operations", + "long_description": "This extension provides file management capabilities through a Python MCP server. It demonstrates Python-based Desktop Extension development, including file operations, directory management, and proper MCP protocol implementation.", + "author": { + "name": "Anthropic", + "email": "support@anthropic.com", + "url": "https://github.com/anthropics" + }, + "server": { + "type": "python", + "entry_point": "server/main.py", + "mcp_config": { + "command": "python", + "args": [ + "${__dirname}/server/main.py", + "--workspace=${user_config.workspace_directory}" + ], + "env": { + "DEBUG": "${user_config.debug_mode}", + "PYTHONPATH": "${__dirname}/server/lib" + } + } + }, + "tools": [ + { + "name": "list_files", + "description": "List files in a directory" + }, + { + "name": "read_file", + "description": "Read file contents" + }, + { + "name": "get_file_info", + "description": "Get information about a file" + } + ], + "keywords": [ + "file", + "directory", + "python", + "management", + "filesystem" + ], + "license": "MIT", + "user_config": { + "workspace_directory": { + "type": "directory", + "title": "Workspace Directory", + "description": "Directory to use as workspace", + "default": "${HOME}/Documents", + "required": false + }, + "debug_mode": { + "type": "boolean", + "title": "Debug Mode", + "description": "Enable debug output", + "default": false, + "required": false + } + }, + "compatibility": { + "claude_desktop": ">=0.10.0", + "platforms": [ + "darwin", + "win32", + "linux" + ], + "runtimes": { + "python": ">=3.8.0 <4" + } + } +} \ No newline at end of file diff --git a/examples/file-manager-python/pyproject.toml b/examples/file-manager-python/pyproject.toml new file mode 100644 index 0000000..7895f32 --- /dev/null +++ b/examples/file-manager-python/pyproject.toml @@ -0,0 +1,31 @@ +[build-system] +requires = ["setuptools>=42", "wheel"] +build-backend = "setuptools.build_meta" + +[project] +name = "file-manager-python" +version = "0.1.0" +description = "A Python MCP server for file operations" +authors = [ + {name = "Anthropic", email = "support@anthropic.com"} +] +license = {text = "MIT"} +classifiers = [ + "Private :: Do Not Upload" # Prevents accidental uploads to PyPI +] + +[project.dependencies] +mcp = ">=1.0.0" +trio = ">=0.22.0" + +[tool.setuptools] +packages = ["server"] + +[project.scripts] +bundle-deps = "python:install_deps" + +# Custom scripts section for DXT development +[tool.dxt] +bundle = "pip install \"mcp[all]\" --target server/lib --upgrade --force-reinstall" +test = "python server/main.py --debug" +pack = "npx @anthropic-ai/dxt pack" \ No newline at end of file diff --git a/examples/file-manager-python/requirements.txt b/examples/file-manager-python/requirements.txt new file mode 100644 index 0000000..d90d65c --- /dev/null +++ b/examples/file-manager-python/requirements.txt @@ -0,0 +1,2 @@ +mcp>=1.0.0 +trio>=0.22.0 diff --git a/examples/file-manager-python/server/main.py b/examples/file-manager-python/server/main.py new file mode 100644 index 0000000..f55e039 --- /dev/null +++ b/examples/file-manager-python/server/main.py @@ -0,0 +1,112 @@ +#!/usr/bin/env python3 + +import os +import sys +import argparse +from pathlib import Path +from mcp.server.fastmcp import FastMCP + +# Parse command line arguments +parser = argparse.ArgumentParser(description="File Manager MCP Server") +parser.add_argument( + "--workspace", default=os.path.expanduser("~/Documents"), help="Workspace directory" +) +parser.add_argument("--debug", action="store_true", help="Enable debug mode") +args = parser.parse_args() + +# Initialize server +mcp = FastMCP("file-manager-python") + + +@mcp.tool() +def list_files(path: str) -> str: + """List files in a directory""" + path_obj = Path(path) + + if not path_obj.exists(): + return f"Directory not found: {path}" + + if not path_obj.is_dir(): + return f"Path is not a directory: {path}" + + try: + files = [] + for item in path_obj.iterdir(): + file_type = "directory" if item.is_dir() else "file" + files.append(f"{item.name} ({file_type})") + + if not files: + return f"Directory is empty: {path}" + + file_list = "\n".join(files) + return f"Files in {path}:\n{file_list}" + + except PermissionError: + return f"Permission denied accessing: {path}" + except Exception as e: + return f"Error listing directory: {str(e)}" + + +@mcp.tool() +def read_file(path: str) -> str: + """Read file contents""" + path_obj = Path(path) + + if not path_obj.exists(): + return f"File not found: {path}" + + if not path_obj.is_file(): + return f"Path is not a file: {path}" + + try: + with path_obj.open("r", encoding="utf-8") as f: + content = f.read() + + return f"Contents of {path}:\n{content}" + + except UnicodeDecodeError: + return f"File is not text or uses unsupported encoding: {path}" + except PermissionError: + return f"Permission denied reading: {path}" + except Exception as e: + return f"Error reading file: {str(e)}" + + +@mcp.tool() +def get_file_info(path: str) -> str: + """Get information about a file""" + path_obj = Path(path) + + if not path_obj.exists(): + return f"Path not found: {path}" + + try: + stat_info = path_obj.stat() + file_type = "directory" if path_obj.is_dir() else "file" + + info = [ + f"Path: {path}", + f"Type: {file_type}", + f"Size: {stat_info.st_size} bytes", + f"Modified: {stat_info.st_mtime}", + f"Created: {stat_info.st_ctime}", + ] + + info_text = "\n".join(info) + return f"File Info:\n{info_text}" + + except PermissionError: + return f"Permission denied accessing: {path}" + except Exception as e: + return f"Error getting file info: {str(e)}" + + +# Main execution +if __name__ == "__main__": + # Debug output if enabled + if args.debug: + print("Starting File Manager MCP Server...", file=sys.stderr) + print(f"Workspace: {args.workspace}", file=sys.stderr) + + # Run the server + mcp.run() diff --git a/examples/hello-world-node/icon.png b/examples/hello-world-node/icon.png new file mode 100644 index 0000000000000000000000000000000000000000..3a34a18053b155a977fc3ee0ef9df6a78d7cb689 GIT binary patch literal 506108 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 Hgw(mmEd%0-4luI+CVNS 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�No&!3nA{JZ-+Q}k+^>k-sYRcJ)4`G5R}7= z5AjMoJ{6@|2J$ERP-;t-(n=Ptz%O6hm3HiFq-)q(#_R$xKh?#6TP0VSL*L%qm7b!3 z&sFm5j~zP!I~K18<0uGJ2p!9T)*mBHkXX7gyi5sX5Zd#Iwh3#7gOJB%M0}J33M!WqTCLkDTPyuAaiROwrV6_I(wG>3YVk+uHizUGzaZtm1lSf&DhBJl5mT^dy926~eS1F2uY04}`a4waK}p zQY~D(l;;L{L1gDxelQXYlE+Vd-LEfD4U_C3o|yI=DlcZmjRqy-U~yWp}IqogoSH$~1= zMo79SLP>yn)2*aF+NtxgNA8YLUl~f#tN?4v_mg$Ac+sM`c3byA+Dt75n^#3Bhj!G} zH4CB`%nC|@Tl3$V40$=^jpKc5NL8@kH-co%Uobz&o5v0vr23#Ct}B6r9XWP16s=0e znihwthhJS$8T;)721QNf+?Z28S1BmO48b(B-wBapB#i@hFG-bn>?=uQomFUGgF!sq z%JyX}bL^;tVNzbA-63*mMIp&-?vH-MD{Cg(jYN4QLCr#$f z+pq40Pg4d5YFWCB(me{HxMFT`st0*2nnm?b6xnz}7ngA=Dk~RIeQ|yuO>KlmmeoR* z&YuvdmvY{&l#)!ZQbR?gr60aZ8apxl@Ri-^4&TFwP$}yKbaKBcL|ox-*EDi^6!3S)sw z+4p^rVmB){&~fvy{`-*XD1b>JmB8CLx>W+chP z*snjGXj4m0*{tNgWx6duotK!T3E}zQprxe3&3_^U=P@8&dF?$Q>|?;!rI{Ct0M_C+ z9{-o$`57$v20VlgJb``br8oAZQgY{&Qs-GrmjdcSU?L!jiLd=%-+D9c*?TZ8t+s}@ zeE>-7dGKB~@dY6FcT)wBVGkstww5+L%@a{S;5sq9VT7TuT}?Io2jJzikeMc-Kw8^L zV**k)#`w;=?~oS^8B77d^9X@Y#3O!dH=Kc|sVh%MwF`s@S~|}1*pL;em9C=d?ifsO zZr>AyhQ?gK%=nsF!KPylPU9t2S5`(m(VpH`iIadQbiWb)z~i75vcTt3PkbWb20L?| z8S0Ia%ZpK9dhUi42H8AT9Bd+2xT{NuzMS0XHfk1Fy=zuj=iZYgTaV$**a6M_ZN0IA z+`_bG1qew^HBFGN2I13=a2gQ8xN;{{g2MWed5Vil5mJ@F=VpKagAd@nvx(jCdib^{ z)p}P@s=OuwS33?GOs>76;vx*08H_2$33IKmHBPSwEaFg7S_INmh*6Xq*L97_Odo~7 zjqm!*h15s5XUozsz()6(D2lM40xLWp;+%f(^y!QI8^&O>O!T5S_$MzjOhowd(Z)HN$ZLPq+$l9Jx*enmFFA`&Hy$>G3WsHlG(h>>{&0}d^OFL2i zGT4iO{4ItgscrY}-2uZ!Z45j`g}5n(u2bWf=0N+b!GBhw?+)RZ%ywJ`OM#yN&C-ZWAtLjJO_4u_Bt(90g80SkuOr7+-_ zALdDeaU50Ku4AxEYV038OBinv1YoLnvL<%#*&ivSR=(5QKZ)Y#LQ(1YHn)&{0E{bQ zGXxaAfPya*fWZ$Pp?D37wg^M_-90C`#uUh)WPD)sX~4HMcd}j>2Qmf*xLzTA8%v5W zUb2k!p@)B!!Z*j#5cjE9Cl^G8Y#HAIjP5z0DTg7M&IO^gkj@cGB~Q(hUqbwv(#;Ry z0PyIf1)nF5ju(ybEn&oE_5T$yrb zl}NqOA!LPn%J&R0wLl=84oW2Yp(3&l!LbufWG~%~qCJ<|fxb&1Sqf#(Ey<@@(q_n( zRPRK_8uAu>0~YU-9$y6K5Zc{P#8kfNzIz zyzPj9`Lol7;`WsOAK{R_oBbZ&8PW4vLpT5S*O42@APqke4wNlQ{2%Yb!Yy~*{|OlI zTZk*#(>WtynV!|#doC z!r>PYlEPUNS!7o+H1zCb2FKI#>^{D&W^3kAn$_ChELyz)Un*1E-^wKrwyH#M*?T~^ z*;rAJ-XG)E*4;?TK_~Va6Ja-)4cJUmEk-JHa+>;I;I*{(9*-vj54Rz*H8n>bx9>>L~6layi`|rCa zy5Fh97c8h{7LxHrMmvL_Ea33W9Tw!hfZy`a;_bOB+QR!6<;>D_{^$s;EoPXC( ze!(o(0TP5!*E4cVo&FgJ41XFj2@iz7M-^2lZ3KZE-jpIe0KKkq^6O8WIEe>L7c|z6 zX-F$pE{s%D>%kjew(6pN$@Nqf{CWuz1ryYIRu4a55q1E z6o9U21)y;5bvzsujU+FPEk857rO~ZI6mpi(>589DeF&jY8SD0J&~S-#HIy8O#6I%) zp}}qp{w~IlwaDMf2!*rCN%(Zqlw6R$LLlO$#DS?X50w4-YcHplw!NI*f}gT;m-Q;> zY>DT;9hlyndb2xZm|K$By|k#V7A2IA(w&5H+LPXZXS0y9#ITFfORw)k26RVR@EIVA zc7)u2=ot54yKfrEFwUZ1t}nAmB&(gqh|pNHDVJ-sllI5UXpgJkbLj1N(?$3Ul2+H< zxsni8UuuIRw3)7n>o;r!F=|rGBI7WY`{*|S2jjreddAACa<1PQY3JTUVYoWqxgc$p zYBr8tQBlF#BlN_c=zzDPVJpHQdGI{zT4hsRU5yN-X%5D?id91891L0Kc?}sVmf?MV zPeYoQkFsZNnCEU2n-dfW`{^%UNk91O=inXWMk=fbl1A^tH2<;9`cWLJ85k>uz$7b5 z{=9@ItddmT>QIe^gXP-D5DGkX_KT^%u5}R~`Aj0a{2ABX6c)gTQK7MqI8 z`z|I6Vo5R;)i4Fnxp47`7%F_5;d>dkpT^#j<6wMW!zjjO#7OcBQKb)$T`rFG016=l zYg}mjyQk|x14UydGS>0|RO|?4o<+`-sf6qa&g&ZWceWAVquvH%GZuL@k-3qKdEp%7 zY}TQOk%ot8h4*>uOD{f?6xq8W)?!E9deq48em6TH-Wb)qAqx?9nR*p1@VE~yb@QC; z&A;z;ivcilTFw%JY~)fmZ=93I5us$gAO7N>*BrTn>>GUU00m6phy3kPLVJ=7ol(Cx z7GbK8pGFB_YtldX=;z2=UlA6oaKAm*+uMf1bC2c=EE?mI-j8irjV)cmvU4$b87D-@ zd$Phq;uh?38Os09_uoKy-bnjs1XN5Ro%N7?K+zHIxxlbJ>6?H0JuGS#9$sKEu_h~6 zH8ppTQq)FHJj5|bIxY}l*2{SMZWwbp275q z$2MW5QZ%J=D6OP$PIQf81D}FHta7wKh9tK^7N6ez6&EW4Mi|Uzx4*zJ8*S{^DQWky z*7RFn`XnVo7p6n|PY|=58!^0#RN;I3?cI>(`or6@c+xJqoHezbp_f4&je970d2T2g zd`x5mnF40zJ2$OXuhVNmC2NhZTCo~J+HuAbLaHVUlw$)2!wLwiRD>3}~CkJp;@hFe-& zIzUeLM_kz++qOeC{x0cCrLCgX^47w3b5EI^!+r5xj5R|U#z5^fre|kIJhMOY3-bBN zCPWZ1B{6T#QPU|%h5Zn>IKP`TSjntIQ=HsLu8%@k{`q*UDs4Bu!nThhR86g&5$hf$ zIqBW&)p&l54ZY>eSkBhG>w_U?ZRlN3U=64Yfg$l`0tda1Q|_q7A%U6bnR{J zK?*G?CR2vFm_==g+s9Yv*x2=LYT9Tl*WWd$!js7cGQ4`%zwbxc zR31_x?fw@Awcm!7=B(B>mN8M$s4%BOOcjdl@1;^F-oJaq^SYlLXJ3YWG&G7!YnjVg zk$XNBLuUWM{S=DY8wN!M1$u<`?IE)N;1OVW8quIQTpO;>GWLWmjoYb9F^6h|3l`K- z7vwnSBSn&ZCY&sS)<)*fJRtsjQsw4gTx%>y0z7)WF}%`d3@4f3)=)T$A=A*<7#tJF z$n`mvrZ^XnS;ms9>dJ94PNx&Bkx~e4b=9@$Osuc*!QEN4tTyT(48avRH`Ei2he~k< z%!)X1vL9YeO{5bahod9c#WXlQPPZxhu?WVed;q0rhC^cPCv)7nF4Y3g?Emm8c>jXXdx{sS4`@)t<0^v z(hMiSIuR#$-V@DTDIbF&d*+P%7NMb$xelnC#bBIXBTTP*ZfP;{8Nx1x^+iI1?q6Ya z_ki>3x#Y>XhBW#Nu}#FduzkCkNYlygK_Z1hFNaiZN#TN#^jXnX77X(TiUeBY9@cqK zmdM$XtK&Gh=j;P87-3k#q3!H7!cQVzI(c^Nj6y*e;Bp6Y+3ylO2QkbvLdT6)&$+kd zykOv<$CP6cgJ-?#T(NSwrlsjY3Az6(IHy-Iifl`)e)5^a5mX59tiIHWBmd9d@=wMi z{^w8r-F(HNAMv+ud7J{vZ;l=^@{2Nv3*S7=NBwe(0T4)e9Am|*(R1DWQd}&%Nv|~e z`G?_tp&dWFX#jAn%JKFW27v|ud)*e8LN}lN;y-1x)P+J&hzt+{XeW&?3Xt%9V_=>} zA#nqRZrWL?<#6#9T@0b5RcI_YnZ%(yn1Icj7vt^C!1_F$KK+IJS$J6oykGtD&Gci+ z%?i^9#}0F>gc+eI7xsG;q>*qU)G4$j0-)76j1ZGKuI1=6>dgwf1k*DXgMw2J(3Y&T zSTy#Pre!CB;LBhAOuFa(_2kF*Q88{83lu@iN)qx_@Y&g~4+gvztls%qHoh@N^MNfw zae@t5M)=^r`}{+c932y3k^}n=gwfJ}noWijP$;N7=%4aIU~08gaKTO0Y$G%rD^ zM!F2f(Th6{rX1q*j&D?lW1R@kpCgCaieQr`0;RuyDQ$&3b^Q2|^qv3s{pd9?gE+b9 zjn|qDG3lu%A7P`<387zy@N0u9EF@V(xS|ZhV0?IDZgRW7T}}J;9EweA4*Sks`(PK> z!FyPS+#(;BakdDL%05d)1L{MGJ14?+Di$}G`)Jn8*_?k~D1LMQ`v_@Rj6-E20nmK% z%E}5npdN$+sX5F$4}|d1`(WL%`BktA4TY0JRwGgm*kU+QFo^4#?&TbqZfM;3r$2v* zw6=?B#fnAQ`aqdl=t#6CtNxgsBQ`M4>?RDOU_@B$+IfU~!Lwy;**NF`hLXqjLTp<` zoe3LMNhI63Z$I}!bukJW*&r%IFYJp>+gsr1v15t<;+5Dk)uvBEr4u-3-#{0cEeE;3 zCB(rOre9Is*ECV9P%d4(FjZ7k!q;eofM+gyH~Wn-V>}|J$vuX^LeROcV@-2!?#C?7 ziJ{A;75$Ly?00;*zCAuXBcGRjs!=%|xOY0FU7HLIK&sVK)LSwYw6Cv==NgW6uQ2v} zqe9PfsW=q2xw$12_Ua2hh8-X4j~=CxBbgVh&zu>wghg1(qtPL--bden+=}+Nx06kc z7$6x;Zk~S!Eb|tSAv+4XhE}ay%G_Go^?iCE9HH@)DY|qBM7BsS)lslyb1$3_W88)S zyLH?Lcf9)I*fGExpj zF|uUkLslfxekT*Wt!_XTai;wT$IOF%tOeCnXF6aoZAm*J{a(fui>E{ z_%NJ=wQk8<9g-~5;vx@J4zEQ|SR?cT=ju4rogRN`Yuw`*IvidlARMwVJ2x=O8k2GeUN9FJQnt39>M;SH^lDO!s87uDT%vd2a2E#$!;xo8@5QE^S z7y$fo4Ff=VqOMaX`nlw2T#E(NMdiM(PT9!B?)iHVi&~)|8&&Tr7oj2? zTSEPO+b3Ef&*D2SLdoFU+r^aKiQ6EbA*DK}M;ILJmT8Wi`yz zTF?qA50bL7jC|WxNQb9RHj--AnA(VO-A|g`MButN_cQ|Q=Td^RGc0-`c^6t)DZ-Du zcRgU)ti6L*)0e;WaC(yJf-fW3fBuViSYVe(^;v>o9!swMS{hr>Km{Jdd}8ytcsfF2 zCxJbWkX|-C+(*5EWsnvxq;|Y*`2jW>aV~r=S>Td@=9N@%zG-Rwy5#{ke)|XiiJAgH ze?VgzlvkOD9E8uq4{k~JpSO^R>6cASP3gOT{oR0@jc0DyxF$R(>*E`{-1**~^z6@G z3c{MHYeImVOgmb>93kHsV`?hdI0V%lN?&H@2F8kn9Ak|N0sG76=g&%8?%f*5jwwA> zva?Ts3}*jzQ6xoTn$Y4FN~+o;VgG@HAuuHhiF63@`BQJf>UxF|tQ;tG>BgKu7{hw* zmNj*3?H>5dkA50WlBQ9cAcvT*H5pv@ddVtv@7a4a<;rtsNPwg`zwxjlX2*r#i5zr{> z+_j+><37+R(3?@1x(C9*@o)C0W1%&n0@H|g{-%R+%mzuR!tgK#+}+cKfOc+02;}r2 z1lct1Z^zDyIc_Q%s|8M;G83}gQjEP4*3gu+ckez(cMwZwm$A-B3#JH>DZF!t4|icC z8d7mQt)G7y0bD>`iM1|GlrW7*`eLy){ z+B(zBq8ad!Xy~=?Xxek4JuR;#O8_+VG-<=(onwUMpqN$W8pek5OotP7k-)8FSNWPY zZP!dgMcH1m#sn1!QTmqkRW9l{I7X&APR7f(^5=92z4jK+C=rD+6on}r#+OE*9=zET z1MEM^-Fok4KDf5zdrTpu>3ZscteeC7u=j!YJ)Ll(uanICR1DGU?4dz8RjcUaD7UK@ z)W`E&Vy`O44M!=bqSGkXl;dEwhH_n}!<5f3el>7WaMq&;{l~rQc#I+Jql0LAt$Ra6 z!n9eHq2ySNWp!bu8~KIt$aJB1dHah?`0>bpZvX7p{)+RAyc=K2zUH14nfU*EeaHaF z&Y-f+6t;hlob{G7Wr}@7@pGkk5I-M1+y}_+z+d8AT1I*ZaTrP)2L=I6u@A^;ci;PP zdhGEpgn$`?has`6;Y252)pNzWVK5Z95qP5y z{=j7>=FYp80RNSwNeI+_EXzOti)SGIK-NG=p9V6LfK^5ZxUmQwjRA#^ldETJ(GTz2 zh3U17M?1m36!Kxku}SPIS4>RF>;mnmnRsUF)>3nSbH@CCfi|+oNuzT^u35b*44>*s zyTMILbBN_$r7(%`qOoEHpf&Z4eRYxNs~6GPGe9fS$GIjI%t#m8_WFKmrb7%YnTtTH zL)qs6IhMxw*wXScilvw8id|jQ;K$(U=p0D@r9e$_6k-;&5s{gK zcf9Ydlj&YiinZ&PV#$mL?mPuYgVe1N-a=)iAf@(23RIpdraQ#4v9T)}c7+aKf_h4GSa#h;5b4SFyYv#{KK~JNXdzRAU zcQp9iX~n=N1#$f(z-C$GY_4X-Tm&71E`t)%?)0duR!RWdHk z?5Ai|26zY5zL?;t`C%9u&1!^FZB14B`A?rsZ*1QV3e+3* z;Ab$W3Jkqb4I90lDTK^aemOG=LNHC?{`3%=JDXEG9;%@OE4LZfK1FdQg}@v<(^`zt zWAtXXcf9v$SWIuzbuCNUd&J(3-`!gtqgUqIckj9O!w3Ko^H32QJ4*VQu&ss#x;%uQ zhPbu)4V7WvMo$H~HF910@%&ZLLaP?*asQ|k!l2+<=Mk31zJ-z%ti`1k?wTKl?1}oL z7*5R?26%{YdG5S(OFDR9FZ~#f2A{(!!B7OQ#wzUUMnFzrXJZhHf^LNw7oJOrws2CPd$)UudPh~{GWU|jk|s>y?f+D z!lg)iK=C>;)~299w6N`-s0XVju0of*EJ`vN#jF?VSc%l=Wg6a^iJaK8?KlFJ_04#@ zSLCN$#4D9Ns8O=ci(5dI5r-mVX0wY z_)@fzOR#R;hlFd87aFfR4ThhmAunw`tl=sT!Hj_8_4TnvJkIqjf*2{mDtOMRQLdxM zG7tFQ;!zq$I&O~t5XSo0aTX;SPjywxY|D6bwa2Z*zHu;=A@Szu2ma&@*OmYO&wa)I zb#PHl{>WZ&ve7?2^5;hy03RIbnQor#=C5x0xWNw&%znG&(0Hhk&qt3{srp^DHEW1L zF94!DON+~=i50_=XOSCzXg(=yOQ8*{dEpla+Ho?4YZ#J+v6fsI(8B#WpaHfFZ6LSZ zSZx_XzZ(dwm$*;~eY1b}Uwj7d0Hw^vvc&1X{^oZn4AjlS!?+-L>cnKRdKL!4<2=V$ z{?nLpc={|D2i1jSnNtO#UBDE`&i*(Am1GoIy>-=n-PT2J<(m(jaZ>Ama z2l6J_!ysG4atx*cA2)WLP5$2(Mu=us;$0&c_OtgEeyG@x#bAz?#>->Fkgsl2=#<77B^0OnfzJ?BMB z-l~O?j}~L3%p#;AYH$U`W|0w7iiCErUuOd|4+?YJd>S)czI;h+$ZP{D5I85ujsV`{ zpL~$lXM`~~L>|AdlMsqTv-IkP5qmJ;G!8xacm%o%)aSOl zV;7LMO2hRc6l@IHcw~-7AaVL0yh+cYhn|I&3d7(V!+t{6rk(+y?ansllXx$NA9gF* zF=tUoV`&0q?ST}ih|eTarcod~8pa80S0bx|Q%}=*bd4+cxBkY7;B=C z!P_94#Ll9IvqV}n&~zBQmd|0gL>2W>ii};uP?-)y-O<^Fq8Uh^`|OkH;}74D6ObQ9 z&|iM@-_ep5WCVp|+MJ%HM#kibWm|IsqmOkk#Z*#5k<8gRNS~?)5hssztW|Vh{>tO* zgCWo()99ukFKsXd!h2;O57}7C-gdpnVVVUoa|UIXUAqhCSFx5m15vP&q0Umo%=yf< ztfRHCrV5huT$FzWO#P|pPk;D4$V`8#A-!1nW{B1M7G~G`=ENvivuz64+d5%%E(95I z{JpofHdC1m&r;?bCqtfqYfsX&JmdGvOUAMXll zOE^|*Ujd|buV9)1)F#w&1wkS?(EFSTF~rVYj)0`CL)2X_nmsN3@z=kI7fnxe(sv{= zegAJ?gvizgQHX*dz@P!$BK(CfJ-3tV0%R!p8)1e}aGVWS zHa4-iNmWDPZ(6g0YtiM7w5>UX1qix<^tIpmN(k-0#nYZR{$p{A002M$NklZLc*k;Y?b<}``{ zwVhA1$$eIdSX;fN`%HT3!S(4Me)WrN)NAR*m$#?y{mqZzR}ACL&KvO}7m_lx1sH8L z{oO4!JT2|nNvApg{)B0Hrw97k)EZb9((Bva45LJnVe_emm{(VZ z-hmABNJnEnL|=sW?cCLa@REtGWv{0%T5$mdH;4j|uq4E(0idNWOaC&ShYW5}fSEI? zQ;*;~eAs3xFt#CiDio@#sbAjGfssH9+GQ(H7~~ogSDjy1gJMV6;%$pQ*+adqt`@-} z(MV{OlDsoW#p3rpdrt;x;rNvl&E)~cATU{wLRmlcqbc~vCNTM+VC^BN_h4I)4{ zFwm~NKLMrE7xTd8Nq_s3*LW6G z)?NddHGo&%NP)5<_Lc-ZiGLQKnLRVBBk$U5?H+(RzmBj%UfMxHsmJca&_8n(BkvT? zKLKy|3^fu6`C$Bg@2_4+#bq-wfIwt0u2p&}t1!q|HQw7wl=B^A4-L>4#d6OYPYQR( zO6dRKp>~Y2eAavpaQ8U4LQOz1852IT7%)T+Y(JSEdF*c121GbQ4A((tRAkB}Ghxc+ z7N=)ld=*27J_gLU>vt^9h;q@r;2g<_gwfV4TNna&%4Aw`bByEZew010yv%rA8WE(d zqS!TF_4-A0%#cv_OMcB^owapz#QnMzPUGE+2-^N#vaD-z0As^i{~8ajpKGkS!dZld zku5G@Gbj3y8jGhe73-4x!g_jMOEV zP#~K_oFi0R{3rII)}wEFv;6O8wf@oDPLNIQwcfLRN2|D*MJy zqjV~sC}S#oI|Rgb&KM;|f@O*&&Zwm78-P$Do^7Jx(Z}!KkY0Z0Sjwj`i?f2<0u~&f zUU_2&0;GphyPfF<_pyHCod_>$ZC}IC$^!~NnYQiNMYE6s;&eCC(L?)O;XLDH2y2!h zl|4%tP?YcucmR`7{O0lNy|s4$jS?rHFoBp|ZwKRT5e*^oEcHu|({T|xSJ?|SYN_Y4 zfiHs02rC-`u$WUtWi2EiQit?pSt)k((wI4C7eG8BJySC(_U+pfoD1s&;8R9;$r|NC z?~*UK-b+Qs*|YH;2(@s$aNz~6rB@+2a2`x@VL(Y>JE;@VNsa#5g}Jc~t+c4%aQWvk z2NFdUATPeK4PiVPZblstb$y^pvHqDK5ur0E|C1+A;@M%$I#!I60F8W*?f^jCXF7sYJ zpVio$SG_79!t4ykR|rKcrtZjARm0l_Pf zMJqIf^t$x?ZRTQ()*2O^hnd%hRzN=7jKCj&Xj(<)!2Vb#E0-++A?(4sl^H$&DhN!@ zejmr0>_>*^09=F@fZhqk<-RcGt_vg7s)e6?{Nt&jI4`~W-0P4`OVXB2cZFiJC&mJh zs`^u>AaYiu-~F9`9P#UeI3wlE?H4}%2>gy-&_@hC!jgt1UL!2{)|>Symttf$FxvFS zGx!{WCF8HGQ�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%0AOV6ryE%os|vedDVI&^Be{fmnH% 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

-nWFYb3^PXL>WX#lw1^3BIy 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%0ANo+f1*8 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�@2~2==#_9sYYnJ3J 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.10.0", + "platforms": ["darwin", "win32", "linux"], + "runtimes": { + "node": ">=16.0.0" + } + } +} diff --git a/examples/hello-world-node/package.json b/examples/hello-world-node/package.json new file mode 100644 index 0000000..a418730 --- /dev/null +++ b/examples/hello-world-node/package.json @@ -0,0 +1,11 @@ +{ + "name": "hello-world-node", + "version": "0.1.0", + "description": "A simple MCP server that returns the current time", + "type": "module", + "main": "server/index.js", + "license": "MIT", + "dependencies": { + "@modelcontextprotocol/sdk": "^1.12.1" + } +} diff --git a/examples/hello-world-node/server/index.js b/examples/hello-world-node/server/index.js new file mode 100644 index 0000000..03efb72 --- /dev/null +++ b/examples/hello-world-node/server/index.js @@ -0,0 +1,70 @@ +#!/usr/bin/env node + +import { Server } from "@modelcontextprotocol/sdk/server/index.js"; +import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"; +import { + CallToolRequestSchema, + ListToolsRequestSchema, +} from "@modelcontextprotocol/sdk/types.js"; + +const server = new Server( + { + name: "hello-world-node", + version: "1.0.0", + }, + { + capabilities: { + tools: {}, + }, + }, +); + +// Handle tool listing +server.setRequestHandler(ListToolsRequestSchema, async (request) => { + return { + tools: [ + { + name: "get_current_time", + description: "Get the current computer time", + inputSchema: { + type: "object", + properties: {}, + }, + }, + ], + }; +}); + +// Handle tool execution +server.setRequestHandler(CallToolRequestSchema, async (request) => { + if (request.params.name === "get_current_time") { + const now = new Date(); + const timeString = now.toLocaleString("en-US", { + weekday: "long", + year: "numeric", + month: "long", + day: "numeric", + hour: "2-digit", + minute: "2-digit", + second: "2-digit", + timeZoneName: "short", + }); + + return { + content: [ + { + type: "text", + text: `The current time is: ${timeString}`, + }, + ], + }; + } + + throw new Error(`Unknown tool: ${request.params.name}`); +}); + +// Start the server +const transport = new StdioServerTransport(); +server.connect(transport); + +console.error("Hello World MCP server running..."); diff --git a/examples/hello-world-node/yarn.lock b/examples/hello-world-node/yarn.lock new file mode 100644 index 0000000..e4b6da8 --- /dev/null +++ b/examples/hello-world-node/yarn.lock @@ -0,0 +1,621 @@ +# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY. +# yarn lockfile v1 + + +"@modelcontextprotocol/sdk@^1.12.1": + version "1.12.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@modelcontextprotocol/sdk/-/sdk-1.12.1.tgz#f77503f0263b33cb1e5b81a6ff0c322393cabd37" + integrity sha512-KG1CZhZfWg+u8pxeM/mByJDScJSrjjxLc8fwQqbsS8xCjBmQfMNEBTotYdNanKekepnfRI85GtgQlctLFpcYPw== + dependencies: + ajv "^6.12.6" + content-type "^1.0.5" + cors "^2.8.5" + cross-spawn "^7.0.5" + eventsource "^3.0.2" + express "^5.0.1" + express-rate-limit "^7.5.0" + pkce-challenge "^5.0.0" + raw-body "^3.0.0" + zod "^3.23.8" + zod-to-json-schema "^3.24.1" + +accepts@^2.0.0: + version "2.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/accepts/-/accepts-2.0.0.tgz#bbcf4ba5075467f3f2131eab3cffc73c2f5d7895" + integrity sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng== + dependencies: + mime-types "^3.0.0" + negotiator "^1.0.0" + +ajv@^6.12.6: + version "6.12.6" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/ajv/-/ajv-6.12.6.tgz#baf5a62e802b07d977034586f8c3baf5adf26df4" + integrity sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g== + dependencies: + fast-deep-equal "^3.1.1" + fast-json-stable-stringify "^2.0.0" + json-schema-traverse "^0.4.1" + uri-js "^4.2.2" + +body-parser@^2.2.0: + version "2.2.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/body-parser/-/body-parser-2.2.0.tgz#f7a9656de305249a715b549b7b8fd1ab9dfddcfa" + integrity sha512-02qvAaxv8tp7fBa/mw1ga98OGm+eCbqzJOKoRt70sLmfEEi+jyBYVTDGfCL/k06/4EMk/z01gCe7HoCH/f2LTg== + dependencies: + bytes "^3.1.2" + content-type "^1.0.5" + debug "^4.4.0" + http-errors "^2.0.0" + iconv-lite "^0.6.3" + on-finished "^2.4.1" + qs "^6.14.0" + raw-body "^3.0.0" + type-is "^2.0.0" + +bytes@3.1.2, bytes@^3.1.2: + version "3.1.2" + resolved "https://registry.yarnpkg.com/bytes/-/bytes-3.1.2.tgz#8b0beeb98605adf1b128fa4386403c009e0221a5" + integrity sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg== + +call-bind-apply-helpers@^1.0.1, call-bind-apply-helpers@^1.0.2: + version "1.0.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz#4b5428c222be985d79c3d82657479dbe0b59b2d6" + integrity sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ== + dependencies: + es-errors "^1.3.0" + function-bind "^1.1.2" + +call-bound@^1.0.2: + version "1.0.4" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/call-bound/-/call-bound-1.0.4.tgz#238de935d2a2a692928c538c7ccfa91067fd062a" + integrity sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg== + dependencies: + call-bind-apply-helpers "^1.0.2" + get-intrinsic "^1.3.0" + +content-disposition@^1.0.0: + version "1.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/content-disposition/-/content-disposition-1.0.0.tgz#844426cb398f934caefcbb172200126bc7ceace2" + integrity sha512-Au9nRL8VNUut/XSzbQA38+M78dzP4D+eqg3gfJHMIHHYa3bg067xj1KxMUWj+VULbiZMowKngFFbKczUrNJ1mg== + dependencies: + safe-buffer "5.2.1" + +content-type@^1.0.5: + version "1.0.5" + resolved "https://registry.yarnpkg.com/content-type/-/content-type-1.0.5.tgz#8b773162656d1d1086784c8f23a54ce6d73d7918" + integrity sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA== + +cookie-signature@^1.2.1: + version "1.2.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/cookie-signature/-/cookie-signature-1.2.2.tgz#57c7fc3cc293acab9fec54d73e15690ebe4a1793" + integrity sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg== + +cookie@^0.7.1: + version "0.7.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/cookie/-/cookie-0.7.2.tgz#556369c472a2ba910f2979891b526b3436237ed7" + integrity sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w== + +cors@^2.8.5: + version "2.8.5" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/cors/-/cors-2.8.5.tgz#eac11da51592dd86b9f06f6e7ac293b3df875d29" + integrity sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g== + dependencies: + object-assign "^4" + vary "^1" + +cross-spawn@^7.0.5: + version "7.0.6" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/cross-spawn/-/cross-spawn-7.0.6.tgz#8a58fe78f00dcd70c370451759dfbfaf03e8ee9f" + integrity sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA== + dependencies: + path-key "^3.1.0" + shebang-command "^2.0.0" + which "^2.0.1" + +debug@^4.3.5, debug@^4.4.0: + version "4.4.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/debug/-/debug-4.4.1.tgz#e5a8bc6cbc4c6cd3e64308b0693a3d4fa550189b" + integrity sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ== + dependencies: + ms "^2.1.3" + +depd@2.0.0, depd@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/depd/-/depd-2.0.0.tgz#b696163cc757560d09cf22cc8fad1571b79e76df" + integrity sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw== + +dunder-proto@^1.0.1: + version "1.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/dunder-proto/-/dunder-proto-1.0.1.tgz#d7ae667e1dc83482f8b70fd0f6eefc50da30f58a" + integrity sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A== + dependencies: + call-bind-apply-helpers "^1.0.1" + es-errors "^1.3.0" + gopd "^1.2.0" + +ee-first@1.1.1: + version "1.1.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/ee-first/-/ee-first-1.1.1.tgz#590c61156b0ae2f4f0255732a158b266bc56b21d" + integrity sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow== + +encodeurl@^2.0.0: + version "2.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/encodeurl/-/encodeurl-2.0.0.tgz#7b8ea898077d7e409d3ac45474ea38eaf0857a58" + integrity sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg== + +es-define-property@^1.0.1: + version "1.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/es-define-property/-/es-define-property-1.0.1.tgz#983eb2f9a6724e9303f61addf011c72e09e0b0fa" + integrity sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g== + +es-errors@^1.3.0: + version "1.3.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/es-errors/-/es-errors-1.3.0.tgz#05f75a25dab98e4fb1dcd5e1472c0546d5057c8f" + integrity sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw== + +es-object-atoms@^1.0.0, es-object-atoms@^1.1.1: + version "1.1.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/es-object-atoms/-/es-object-atoms-1.1.1.tgz#1c4f2c4837327597ce69d2ca190a7fdd172338c1" + integrity sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA== + dependencies: + es-errors "^1.3.0" + +escape-html@^1.0.3: + version "1.0.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/escape-html/-/escape-html-1.0.3.tgz#0258eae4d3d0c0974de1c169188ef0051d1d1988" + integrity sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow== + +etag@^1.8.1: + version "1.8.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/etag/-/etag-1.8.1.tgz#41ae2eeb65efa62268aebfea83ac7d79299b0887" + integrity sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg== + +eventsource-parser@^3.0.1: + version "3.0.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/eventsource-parser/-/eventsource-parser-3.0.2.tgz#0fea1abd26eca8201099ff5212f6c4e7ca2fd5d3" + integrity sha512-6RxOBZ/cYgd8usLwsEl+EC09Au/9BcmCKYF2/xbml6DNczf7nv0MQb+7BA2F+li6//I+28VNlQR37XfQtcAJuA== + +eventsource@^3.0.2: + version "3.0.7" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/eventsource/-/eventsource-3.0.7.tgz#1157622e2f5377bb6aef2114372728ba0c156989" + integrity sha512-CRT1WTyuQoD771GW56XEZFQ/ZoSfWid1alKGDYMmkt2yl8UXrVR4pspqWNEcqKvVIzg6PAltWjxcSSPrboA4iA== + dependencies: + eventsource-parser "^3.0.1" + +express-rate-limit@^7.5.0: + version "7.5.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/express-rate-limit/-/express-rate-limit-7.5.0.tgz#6a67990a724b4fbbc69119419feef50c51e8b28f" + integrity sha512-eB5zbQh5h+VenMPM3fh+nw1YExi5nMr6HUCR62ELSP11huvxm/Uir1H1QEyTkk5QX6A58pX6NmaTMceKZ0Eodg== + +express@^5.0.1: + version "5.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/express/-/express-5.1.0.tgz#d31beaf715a0016f0d53f47d3b4d7acf28c75cc9" + integrity sha512-DT9ck5YIRU+8GYzzU5kT3eHGA5iL+1Zd0EutOmTE9Dtk+Tvuzd23VBU+ec7HPNSTxXYO55gPV/hq4pSBJDjFpA== + dependencies: + accepts "^2.0.0" + body-parser "^2.2.0" + content-disposition "^1.0.0" + content-type "^1.0.5" + cookie "^0.7.1" + cookie-signature "^1.2.1" + debug "^4.4.0" + encodeurl "^2.0.0" + escape-html "^1.0.3" + etag "^1.8.1" + finalhandler "^2.1.0" + fresh "^2.0.0" + http-errors "^2.0.0" + merge-descriptors "^2.0.0" + mime-types "^3.0.0" + on-finished "^2.4.1" + once "^1.4.0" + parseurl "^1.3.3" + proxy-addr "^2.0.7" + qs "^6.14.0" + range-parser "^1.2.1" + router "^2.2.0" + send "^1.1.0" + serve-static "^2.2.0" + statuses "^2.0.1" + type-is "^2.0.1" + vary "^1.1.2" + +fast-deep-equal@^3.1.1: + version "3.1.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz#3a7d56b559d6cbc3eb512325244e619a65c6c525" + integrity sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q== + +fast-json-stable-stringify@^2.0.0: + version "2.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz#874bf69c6f404c2b5d99c481341399fd55892633" + integrity sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw== + +finalhandler@^2.1.0: + version "2.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/finalhandler/-/finalhandler-2.1.0.tgz#72306373aa89d05a8242ed569ed86a1bff7c561f" + integrity sha512-/t88Ty3d5JWQbWYgaOGCCYfXRwV1+be02WqYYlL6h0lEiUAMPM8o8qKGO01YIkOHzka2up08wvgYD0mDiI+q3Q== + dependencies: + debug "^4.4.0" + encodeurl "^2.0.0" + escape-html "^1.0.3" + on-finished "^2.4.1" + parseurl "^1.3.3" + statuses "^2.0.1" + +forwarded@0.2.0: + version "0.2.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/forwarded/-/forwarded-0.2.0.tgz#2269936428aad4c15c7ebe9779a84bf0b2a81811" + integrity sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow== + +fresh@^2.0.0: + version "2.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/fresh/-/fresh-2.0.0.tgz#8dd7df6a1b3a1b3a5cf186c05a5dd267622635a4" + integrity sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A== + +function-bind@^1.1.2: + version "1.1.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/function-bind/-/function-bind-1.1.2.tgz#2c02d864d97f3ea6c8830c464cbd11ab6eab7a1c" + integrity sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA== + +get-intrinsic@^1.2.5, get-intrinsic@^1.3.0: + version "1.3.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/get-intrinsic/-/get-intrinsic-1.3.0.tgz#743f0e3b6964a93a5491ed1bffaae054d7f98d01" + integrity sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ== + dependencies: + call-bind-apply-helpers "^1.0.2" + es-define-property "^1.0.1" + es-errors "^1.3.0" + es-object-atoms "^1.1.1" + function-bind "^1.1.2" + get-proto "^1.0.1" + gopd "^1.2.0" + has-symbols "^1.1.0" + hasown "^2.0.2" + math-intrinsics "^1.1.0" + +get-proto@^1.0.1: + version "1.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/get-proto/-/get-proto-1.0.1.tgz#150b3f2743869ef3e851ec0c49d15b1d14d00ee1" + integrity sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g== + dependencies: + dunder-proto "^1.0.1" + es-object-atoms "^1.0.0" + +gopd@^1.2.0: + version "1.2.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/gopd/-/gopd-1.2.0.tgz#89f56b8217bdbc8802bd299df6d7f1081d7e51a1" + integrity sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg== + +has-symbols@^1.1.0: + version "1.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/has-symbols/-/has-symbols-1.1.0.tgz#fc9c6a783a084951d0b971fe1018de813707a338" + integrity sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ== + +hasown@^2.0.2: + version "2.0.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/hasown/-/hasown-2.0.2.tgz#003eaf91be7adc372e84ec59dc37252cedb80003" + integrity sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ== + dependencies: + function-bind "^1.1.2" + +http-errors@2.0.0, http-errors@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/http-errors/-/http-errors-2.0.0.tgz#b7774a1486ef73cf7667ac9ae0858c012c57b9d3" + integrity sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ== + dependencies: + depd "2.0.0" + inherits "2.0.4" + setprototypeof "1.2.0" + statuses "2.0.1" + toidentifier "1.0.1" + +iconv-lite@0.6.3, iconv-lite@^0.6.3: + version "0.6.3" + resolved "https://registry.yarnpkg.com/iconv-lite/-/iconv-lite-0.6.3.tgz#a52f80bf38da1952eb5c681790719871a1a72501" + integrity sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw== + dependencies: + safer-buffer ">= 2.1.2 < 3.0.0" + +inherits@2.0.4: + version "2.0.4" + resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c" + integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ== + +ipaddr.js@1.9.1: + version "1.9.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/ipaddr.js/-/ipaddr.js-1.9.1.tgz#bff38543eeb8984825079ff3a2a8e6cbd46781b3" + integrity sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g== + +is-promise@^4.0.0: + version "4.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/is-promise/-/is-promise-4.0.0.tgz#42ff9f84206c1991d26debf520dd5c01042dd2f3" + integrity sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ== + +isexe@^2.0.0: + version "2.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/isexe/-/isexe-2.0.0.tgz#e8fbf374dc556ff8947a10dcb0572d633f2cfa10" + integrity sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw== + +json-schema-traverse@^0.4.1: + version "0.4.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/json-schema-traverse/0.4.1/json-schema-traverse-0.4.1.tgz#69f6a87d9513ab8bb8fe63bdb0979c448e684660" + integrity sha1-afaofZUTq4u4/mO9sJecRI5oRmA= + +math-intrinsics@^1.1.0: + version "1.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/math-intrinsics/-/math-intrinsics-1.1.0.tgz#a0dd74be81e2aa5c2f27e65ce283605ee4e2b7f9" + integrity sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g== + +media-typer@^1.1.0: + version "1.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/media-typer/-/media-typer-1.1.0.tgz#6ab74b8f2d3320f2064b2a87a38e7931ff3a5561" + integrity sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw== + +merge-descriptors@^2.0.0: + version "2.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/merge-descriptors/-/merge-descriptors-2.0.0.tgz#ea922f660635a2249ee565e0449f951e6b603808" + integrity sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g== + +mime-db@^1.54.0: + version "1.54.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/mime-db/-/mime-db-1.54.0.tgz#cddb3ee4f9c64530dff640236661d42cb6a314f5" + integrity sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ== + +mime-types@^3.0.0, mime-types@^3.0.1: + version "3.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/mime-types/-/mime-types-3.0.1.tgz#b1d94d6997a9b32fd69ebaed0db73de8acb519ce" + integrity sha512-xRc4oEhT6eaBpU1XF7AjpOFD+xQmXNB5OVKwp4tqCuBpHLS/ZbBDrc07mYTDqVMg6PfxUjjNp85O6Cd2Z/5HWA== + dependencies: + mime-db "^1.54.0" + +ms@^2.1.3: + version "2.1.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/ms/-/ms-2.1.3.tgz#574c8138ce1d2b5861f0b44579dbadd60c6615b2" + integrity sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA== + +negotiator@^1.0.0: + version "1.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/negotiator/-/negotiator-1.0.0.tgz#b6c91bb47172d69f93cfd7c357bbb529019b5f6a" + integrity sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg== + +object-assign@^4: + version "4.1.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/object-assign/-/object-assign-4.1.1.tgz#2109adc7965887cfc05cbbd442cac8bfbb360863" + integrity sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg== + +object-inspect@^1.13.3: + version "1.13.4" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/object-inspect/-/object-inspect-1.13.4.tgz#8375265e21bc20d0fa582c22e1b13485d6e00213" + integrity sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew== + +on-finished@^2.4.1: + version "2.4.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/on-finished/-/on-finished-2.4.1.tgz#58c8c44116e54845ad57f14ab10b03533184ac3f" + integrity sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg== + dependencies: + ee-first "1.1.1" + +once@^1.4.0: + version "1.4.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/once/-/once-1.4.0.tgz#583b1aa775961d4b113ac17d9c50baef9dd76bd1" + integrity sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w== + dependencies: + wrappy "1" + +parseurl@^1.3.3: + version "1.3.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/parseurl/-/parseurl-1.3.3.tgz#9da19e7bee8d12dff0513ed5b76957793bc2e8d4" + integrity sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ== + +path-key@^3.1.0: + version "3.1.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/path-key/-/path-key-3.1.1.tgz#581f6ade658cbba65a0d3380de7753295054f375" + integrity sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q== + +path-to-regexp@^8.0.0: + version "8.2.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/path-to-regexp/-/path-to-regexp-8.2.0.tgz#73990cc29e57a3ff2a0d914095156df5db79e8b4" + integrity sha512-TdrF7fW9Rphjq4RjrW0Kp2AW0Ahwu9sRGTkS6bvDi0SCwZlEZYmcfDbEsTz8RVk0EHIS/Vd1bv3JhG+1xZuAyQ== + +pkce-challenge@^5.0.0: + version "5.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/pkce-challenge/-/pkce-challenge-5.0.0.tgz#c3a405cb49e272094a38e890a2b51da0228c4d97" + integrity sha512-ueGLflrrnvwB3xuo/uGob5pd5FN7l0MsLf0Z87o/UQmRtwjvfylfc9MurIxRAWywCYTgrvpXBcqjV4OfCYGCIQ== + +proxy-addr@^2.0.7: + version "2.0.7" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/proxy-addr/-/proxy-addr-2.0.7.tgz#f19fe69ceab311eeb94b42e70e8c2070f9ba1025" + integrity sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg== + dependencies: + forwarded "0.2.0" + ipaddr.js "1.9.1" + +punycode@^2.1.0: + version "2.3.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/punycode/-/punycode-2.3.1.tgz#027422e2faec0b25e1549c3e1bd8309b9133b6e5" + integrity sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg== + +qs@^6.14.0: + version "6.14.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/qs/-/qs-6.14.0.tgz#c63fa40680d2c5c941412a0e899c89af60c0a930" + integrity sha512-YWWTjgABSKcvs/nWBi9PycY/JiPJqOD4JA6o9Sej2AtvSGarXxKC3OQSk4pAarbdQlKAh5D4FCQkJNkW+GAn3w== + dependencies: + side-channel "^1.1.0" + +range-parser@^1.2.1: + version "1.2.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/range-parser/-/range-parser-1.2.1.tgz#3cf37023d199e1c24d1a55b84800c2f3e6468031" + integrity sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg== + +raw-body@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/raw-body/-/raw-body-3.0.0.tgz#25b3476f07a51600619dae3fe82ddc28a36e5e0f" + integrity sha512-RmkhL8CAyCRPXCE28MMH0z2PNWQBNk2Q09ZdxM9IOOXwxwZbN+qbWaatPkdkWIKL2ZVDImrN/pK5HTRz2PcS4g== + dependencies: + bytes "3.1.2" + http-errors "2.0.0" + iconv-lite "0.6.3" + unpipe "1.0.0" + +router@^2.2.0: + version "2.2.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/router/-/router-2.2.0.tgz#019be620b711c87641167cc79b99090f00b146ef" + integrity sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ== + dependencies: + debug "^4.4.0" + depd "^2.0.0" + is-promise "^4.0.0" + parseurl "^1.3.3" + path-to-regexp "^8.0.0" + +safe-buffer@5.2.1: + version "5.2.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/safe-buffer/-/safe-buffer-5.2.1.tgz#1eaf9fa9bdb1fdd4ec75f58f9cdb4e6b7827eec6" + integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ== + +"safer-buffer@>= 2.1.2 < 3.0.0": + version "2.1.2" + resolved "https://registry.yarnpkg.com/safer-buffer/-/safer-buffer-2.1.2.tgz#44fa161b0187b9549dd84bb91802f9bd8385cd6a" + integrity sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg== + +send@^1.1.0, send@^1.2.0: + version "1.2.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/send/-/send-1.2.0.tgz#32a7554fb777b831dfa828370f773a3808d37212" + integrity sha512-uaW0WwXKpL9blXE2o0bRhoL2EGXIrZxQ2ZQ4mgcfoBxdFmQold+qWsD2jLrfZ0trjKL6vOw0j//eAwcALFjKSw== + dependencies: + debug "^4.3.5" + encodeurl "^2.0.0" + escape-html "^1.0.3" + etag "^1.8.1" + fresh "^2.0.0" + http-errors "^2.0.0" + mime-types "^3.0.1" + ms "^2.1.3" + on-finished "^2.4.1" + range-parser "^1.2.1" + statuses "^2.0.1" + +serve-static@^2.2.0: + version "2.2.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/serve-static/-/serve-static-2.2.0.tgz#9c02564ee259bdd2251b82d659a2e7e1938d66f9" + integrity sha512-61g9pCh0Vnh7IutZjtLGGpTA355+OPn2TyDv/6ivP2h/AdAVX9azsoxmg2/M6nZeQZNYBEwIcsne1mJd9oQItQ== + dependencies: + encodeurl "^2.0.0" + escape-html "^1.0.3" + parseurl "^1.3.3" + send "^1.2.0" + +setprototypeof@1.2.0: + version "1.2.0" + resolved "https://registry.yarnpkg.com/setprototypeof/-/setprototypeof-1.2.0.tgz#66c9a24a73f9fc28cbe66b09fed3d33dcaf1b424" + integrity sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw== + +shebang-command@^2.0.0: + version "2.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/shebang-command/-/shebang-command-2.0.0.tgz#ccd0af4f8835fbdc265b82461aaf0c36663f34ea" + integrity sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA== + dependencies: + shebang-regex "^3.0.0" + +shebang-regex@^3.0.0: + version "3.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/shebang-regex/-/shebang-regex-3.0.0.tgz#ae16f1644d873ecad843b0307b143362d4c42172" + integrity sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A== + +side-channel-list@^1.0.0: + version "1.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/side-channel-list/-/side-channel-list-1.0.0.tgz#10cb5984263115d3b7a0e336591e290a830af8ad" + integrity sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA== + dependencies: + es-errors "^1.3.0" + object-inspect "^1.13.3" + +side-channel-map@^1.0.1: + version "1.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/side-channel-map/-/side-channel-map-1.0.1.tgz#d6bb6b37902c6fef5174e5f533fab4c732a26f42" + integrity sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA== + dependencies: + call-bound "^1.0.2" + es-errors "^1.3.0" + get-intrinsic "^1.2.5" + object-inspect "^1.13.3" + +side-channel-weakmap@^1.0.2: + version "1.0.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz#11dda19d5368e40ce9ec2bdc1fb0ecbc0790ecea" + integrity sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A== + dependencies: + call-bound "^1.0.2" + es-errors "^1.3.0" + get-intrinsic "^1.2.5" + object-inspect "^1.13.3" + side-channel-map "^1.0.1" + +side-channel@^1.1.0: + version "1.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/side-channel/-/side-channel-1.1.0.tgz#c3fcff9c4da932784873335ec9765fa94ff66bc9" + integrity sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw== + dependencies: + es-errors "^1.3.0" + object-inspect "^1.13.3" + side-channel-list "^1.0.0" + side-channel-map "^1.0.1" + side-channel-weakmap "^1.0.2" + +statuses@2.0.1, statuses@^2.0.1: + version "2.0.1" + resolved "https://registry.yarnpkg.com/statuses/-/statuses-2.0.1.tgz#55cb000ccf1d48728bd23c685a063998cf1a1b63" + integrity sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ== + +toidentifier@1.0.1: + version "1.0.1" + resolved "https://registry.yarnpkg.com/toidentifier/-/toidentifier-1.0.1.tgz#3be34321a88a820ed1bd80dfaa33e479fbb8dd35" + integrity sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA== + +type-is@^2.0.0, type-is@^2.0.1: + version "2.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/type-is/-/type-is-2.0.1.tgz#64f6cf03f92fce4015c2b224793f6bdd4b068c97" + integrity sha512-OZs6gsjF4vMp32qrCbiVSkrFmXtG/AZhY3t0iAMrMBiAZyV9oALtXO8hsrHbMXF9x6L3grlFuwW2oAz7cav+Gw== + dependencies: + content-type "^1.0.5" + media-typer "^1.1.0" + mime-types "^3.0.0" + +unpipe@1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/unpipe/-/unpipe-1.0.0.tgz#b2bf4ee8514aae6165b4817829d21b2ef49904ec" + integrity sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ== + +uri-js@^4.2.2: + version "4.4.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/uri-js/-/uri-js-4.4.1.tgz#9b1a52595225859e55f669d928f88c6c57f2a77e" + integrity sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg== + dependencies: + punycode "^2.1.0" + +vary@^1, vary@^1.1.2: + version "1.1.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/vary/-/vary-1.1.2.tgz#2299f02c6ded30d4a5961b0b9f74524a18f634fc" + integrity sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg== + +which@^2.0.1: + version "2.0.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/which/-/which-2.0.2.tgz#7c6a8dd0a636a0327e10b59c9286eee93f3f51b1" + integrity sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA== + dependencies: + isexe "^2.0.0" + +wrappy@1: + version "1.0.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/wrappy/1.0.2/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f" + integrity sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8= + +zod-to-json-schema@^3.24.1: + version "3.24.5" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/zod-to-json-schema/-/zod-to-json-schema-3.24.5.tgz#d1095440b147fb7c2093812a53c54df8d5df50a3" + integrity sha512-/AuWwMP+YqiPbsJx5D6TfgRTc4kTLjsh5SOcd4bLsfUg2RcEXrFMJl1DGgdHy2aCfsIA/cr/1JM0xcB2GZji8g== + +zod@^3.23.8: + version "3.25.63" + resolved "https://registry.yarnpkg.com/zod/-/zod-3.25.63.tgz#5eac66b56aa9f5e1cd3604dd541b819110474efa" + integrity sha512-3ttCkqhtpncYXfP0f6dsyabbYV/nEUW+Xlu89jiXbTBifUfjaSqXOG6JnQPLtqt87n7KAmnMqcjay6c0Wq0Vbw== diff --git a/jest.config.js b/jest.config.js new file mode 100644 index 0000000..8337f2a --- /dev/null +++ b/jest.config.js @@ -0,0 +1,23 @@ +export default { + preset: "ts-jest", + testEnvironment: "node", + testMatch: ["**/test/**/*.test.ts"], + collectCoverageFrom: ["src/**/*.ts", "!src/**/*.d.ts"], + moduleFileExtensions: ["ts", "js", "json"], + transform: { + "^.+\\.ts$": [ + "ts-jest", + { + tsconfig: { + module: "es2022", + esModuleInterop: true, + allowJs: true, + target: "es2020", + }, + }, + ], + }, + moduleNameMapper: { + "^(\\.{1,2}/.*)\\.js$": "$1", + }, +}; diff --git a/package.json b/package.json new file mode 100644 index 0000000..435e1ab --- /dev/null +++ b/package.json @@ -0,0 +1,77 @@ +{ + "name": "@anthropic-ai/dxt", + "description": "Tools for building Desktop Extensions", + "version": "0.1.0-dev.20250622054707", + "type": "module", + "main": "dist/index.js", + "module": "dist/index.js", + "types": "dist/index.d.ts", + "exports": { + ".": { + "types": "./dist/index.d.ts", + "import": "./dist/index.js", + "require": "./dist/index.js" + }, + "./browser": { + "types": "./dist/browser.d.ts", + "import": "./dist/browser.js", + "require": "./dist/browser.js" + }, + "./node": { + "types": "./dist/node.d.ts", + "import": "./dist/node.js", + "require": "./dist/node.js" + }, + "./cli": { + "types": "./dist/cli.d.ts", + "import": "./dist/cli.js", + "require": "./dist/cli.js" + } + }, + "bin": { + "dxt": "dist/cli/cli.js" + }, + "files": [ + "dist" + ], + "scripts": { + "build": "tsc", + "dev": "tsc --watch", + "test": "jest", + "test:watch": "jest --watch", + "prepublishOnly": "npm run build", + "fix": "eslint --ext .ts . --fix && prettier -w .", + "lint": "tsc -p ./tsconfig.json && eslint --ext .ts .", + "dev-version": "./scripts/create-dev-version.js" + }, + "author": "Anthropic ", + "license": "MIT", + "devDependencies": { + "@types/jest": "^29.5.14", + "@types/node": "^22.15.3", + "@types/node-forge": "1.3.11", + "@typescript-eslint/eslint-plugin": "^5.62.0", + "@typescript-eslint/parser": "^5.62.0", + "eslint": "^8.43.0", + "eslint-config-prettier": "^8.10.0", + "eslint-import-resolver-typescript": "^3.6.1", + "eslint-plugin-import": "^2.29.1", + "eslint-plugin-prettier": "^5.1.3", + "eslint-plugin-simple-import-sort": "^10.0.0", + "jest": "^29.7.0", + "prettier": "^3.3.3", + "ts-jest": "^29.3.2", + "typescript": "^5.6.3" + }, + "dependencies": { + "@inquirer/prompts": "^6.0.1", + "commander": "^13.1.0", + "fflate": "^0.8.2", + "node-forge": "^1.3.1", + "zod": "^3.24.4" + }, + "resolutions": { + "@babel/helpers": "7.27.1", + "@babel/parser": "7.27.3" + } +} diff --git a/scripts/create-dev-version.js b/scripts/create-dev-version.js new file mode 100755 index 0000000..8de366a --- /dev/null +++ b/scripts/create-dev-version.js @@ -0,0 +1,33 @@ +#!/usr/bin/env node + +import fs from "fs"; + +try { + // Read current package.json + const packageJson = JSON.parse(fs.readFileSync("package.json", "utf8")); + + // Get current version and strip any existing prerelease + const baseVersion = packageJson.version.split("-")[0]; + + // Generate timestamp (YYYYMMDDHHMMSS) + const now = new Date(); + const timestamp = + now.getFullYear().toString() + + (now.getMonth() + 1).toString().padStart(2, "0") + + now.getDate().toString().padStart(2, "0") + + now.getHours().toString().padStart(2, "0") + + now.getMinutes().toString().padStart(2, "0") + + now.getSeconds().toString().padStart(2, "0"); + + // Create dev version + const devVersion = `${baseVersion}-dev.${timestamp}`; + + console.log(`Publishing ${devVersion}...`); + + // Update package.json version + packageJson.version = devVersion; + fs.writeFileSync("package.json", JSON.stringify(packageJson, null, 2) + "\n"); +} catch (error) { + console.error("Failed to publish:", error.message); + process.exit(1); +} diff --git a/src/browser.ts b/src/browser.ts new file mode 100644 index 0000000..c4fd89a --- /dev/null +++ b/src/browser.ts @@ -0,0 +1,4 @@ +// Browser-compatible exports +export * from "./schemas.js"; +export * from "./shared/config.js"; +export * from "./types.js"; diff --git a/src/cli.ts b/src/cli.ts new file mode 100644 index 0000000..45780f9 --- /dev/null +++ b/src/cli.ts @@ -0,0 +1,13 @@ +// CLI-specific exports +export * from "./cli/init.js"; +export * from "./cli/pack.js"; + +// Include all shared exports +export * from "./schemas.js"; +export * from "./shared/config.js"; +export * from "./types.js"; + +// Include node exports since CLI needs them +export * from "./node/files.js"; +export * from "./node/sign.js"; +export * from "./node/validate.js"; diff --git a/src/cli/cli.ts b/src/cli/cli.ts new file mode 100644 index 0000000..a1a01c1 --- /dev/null +++ b/src/cli/cli.ts @@ -0,0 +1,314 @@ +#!/usr/bin/env node + +import { execSync } from "child_process"; +import { Command } from "commander"; +import { existsSync, readFileSync, statSync } from "fs"; +import { basename, dirname, join, resolve } from "path"; +import { fileURLToPath } from "url"; + +import { signDxtFile, unsignDxtFile, verifyDxtFile } from "../node/sign.js"; +import { validateManifest } from "../node/validate.js"; +import { initExtension } from "./init.js"; +import { packExtension } from "./pack.js"; + +// ES modules equivalent of __dirname +const __filename = fileURLToPath(import.meta.url); +const __dirname = dirname(__filename); + +// Get version from package.json +const packageJsonPath = join(__dirname, "..", "..", "package.json"); +const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8")); +const version = packageJson.version; + +/** + * Create a self-signed certificate for signing DXT extensions + */ +function createSelfSignedCertificate(certPath: string, keyPath: string): void { + const subject = "/CN=DXT Self-Signed Certificate/O=DXT Extensions/C=US"; + + try { + // Generate a self-signed certificate valid for 10 years, no password + execSync( + `openssl req -x509 -newkey rsa:4096 -keyout "${keyPath}" -out "${certPath}" -days 3650 -nodes -subj "${subject}"`, + { stdio: "pipe" }, + ); + } catch (error) { + throw new Error(`Failed to create self-signed certificate: ${error}`); + } +} + +// Create the CLI program +const program = new Command(); + +program + .name("dxt") + .description("Tools for building Desktop Extensions") + .version(version); + +// Init command +program + .command("init [directory]") + .description("Create a new DXT extension manifest") + .option("-y, --yes", "Accept all defaults (non-interactive mode)") + .action((directory?: string, options?: { yes?: boolean }) => { + void (async () => { + try { + const success = await initExtension(directory, options?.yes); + process.exit(success ? 0 : 1); + } catch (error) { + console.error( + `ERROR: ${error instanceof Error ? error.message : "Unknown error"}`, + ); + process.exit(1); + } + })(); + }); + +// Validate command +program + .command("validate ") + .description("Validate a DXT manifest file") + .action((manifestPath: string) => { + const success = validateManifest(manifestPath); + process.exit(success ? 0 : 1); + }); + +// Pack command +program + .command("pack [directory] [output]") + .description("Pack a directory into a DXT extension") + .action((directory: string = process.cwd(), output?: string) => { + void (async () => { + try { + const success = await packExtension({ + extensionPath: directory, + outputPath: output, + }); + process.exit(success ? 0 : 1); + } catch (error) { + console.error( + `ERROR: ${error instanceof Error ? error.message : "Unknown error"}`, + ); + process.exit(1); + } + })(); + }); + +// Sign command +program + .command("sign ") + .description("Sign a DXT extension file") + .option( + "-c, --cert ", + "Path to certificate file (PEM format)", + "cert.pem", + ) + .option( + "-k, --key ", + "Path to private key file (PEM format)", + "key.pem", + ) + .option( + "-i, --intermediate ", + "Paths to intermediate certificate files", + ) + .option("--self-signed", "Create a self-signed certificate if none exists") + .action( + ( + dxtFile: string, + options: { + cert: string; + key: string; + intermediate?: string[]; + selfSigned?: boolean; + }, + ) => { + void (async () => { + try { + const dxtPath = resolve(dxtFile); + + if (!existsSync(dxtPath)) { + console.error(`ERROR: DXT file not found: ${dxtFile}`); + process.exit(1); + } + + let certPath = options.cert; + let keyPath = options.key; + + // Create self-signed certificate if requested + if (options.selfSigned) { + const dxtDir = resolve(__dirname, ".."); + certPath = join(dxtDir, "self-signed-cert.pem"); + keyPath = join(dxtDir, "self-signed-key.pem"); + + if (!existsSync(certPath) || !existsSync(keyPath)) { + console.log("Creating self-signed certificate..."); + createSelfSignedCertificate(certPath, keyPath); + console.log("Self-signed certificate created"); + } else { + console.log("Using existing self-signed certificate"); + } + } else { + // Check for manual certificate paths + if (!existsSync(certPath)) { + console.error(`ERROR: Certificate file not found: ${certPath}`); + console.log( + "Tip: Use --self-signed to create a self-signed certificate", + ); + process.exit(1); + } + + if (!existsSync(keyPath)) { + console.error(`ERROR: Private key file not found: ${keyPath}`); + process.exit(1); + } + } + + console.log(`Signing ${basename(dxtPath)}...`); + signDxtFile(dxtPath, certPath, keyPath, options.intermediate); + console.log(`Successfully signed ${basename(dxtPath)}`); + + // Display certificate info + const signatureInfo = await verifyDxtFile(dxtPath); + if ( + signatureInfo.status === "signed" || + signatureInfo.status === "self-signed" + ) { + console.log(`Signed by: ${signatureInfo.publisher}`); + console.log(`Issuer: ${signatureInfo.issuer}`); + if (signatureInfo.status === "self-signed") { + console.log(`Warning: Certificate is self-signed`); + } + } + } catch (error) { + console.log( + `ERROR: Signing failed: ${error instanceof Error ? error.message : "Unknown error"}`, + ); + process.exit(1); + } + })(); + }, + ); + +// Verify command +program + .command("verify ") + .description("Verify the signature of a DXT extension file") + .action((dxtFile: string) => { + void (async () => { + try { + const dxtPath = resolve(dxtFile); + + if (!existsSync(dxtPath)) { + console.error(`ERROR: DXT file not found: ${dxtFile}`); + process.exit(1); + } + + console.log(`Verifying ${basename(dxtPath)}...`); + const result = await verifyDxtFile(dxtPath); + + if (result.status === "signed") { + console.log(`Signature is valid`); + console.log(`Signed by: ${result.publisher}`); + console.log(`Issuer: ${result.issuer}`); + console.log( + `Valid from: ${new Date(result.valid_from!).toLocaleDateString()} to ${new Date(result.valid_to!).toLocaleDateString()}`, + ); + console.log(`Fingerprint: ${result.fingerprint}`); + } else if (result.status === "self-signed") { + console.log(`Signature is valid (self-signed)`); + console.log(`WARNING: This extension is self-signed`); + console.log(`Signed by: ${result.publisher}`); + console.log( + `Valid from: ${new Date(result.valid_from!).toLocaleDateString()} to ${new Date(result.valid_to!).toLocaleDateString()}`, + ); + console.log(`Fingerprint: ${result.fingerprint}`); + } else { + console.error(`ERROR: Extension is not signed`); + process.exit(1); + } + } catch (error) { + console.log( + `ERROR: Verification failed: ${error instanceof Error ? error.message : "Unknown error"}`, + ); + process.exit(1); + } + })(); + }); + +// Info command +program + .command("info ") + .description("Display information about a DXT extension file") + .action((dxtFile: string) => { + void (async () => { + try { + const dxtPath = resolve(dxtFile); + + if (!existsSync(dxtPath)) { + console.error(`ERROR: DXT file not found: ${dxtFile}`); + process.exit(1); + } + + const stat = statSync(dxtPath); + console.log(`File: ${basename(dxtPath)}`); + console.log(`Size: ${(stat.size / 1024).toFixed(2)} KB`); + + // Check if signed + const signatureInfo = await verifyDxtFile(dxtPath); + if (signatureInfo.status === "signed") { + console.log(`\nSignature Information:`); + console.log(` Subject: ${signatureInfo.publisher}`); + console.log(` Issuer: ${signatureInfo.issuer}`); + console.log( + ` Valid from: ${new Date(signatureInfo.valid_from!).toLocaleDateString()} to ${new Date(signatureInfo.valid_to!).toLocaleDateString()}`, + ); + console.log(` Fingerprint: ${signatureInfo.fingerprint}`); + console.log(` Status: Valid`); + } else if (signatureInfo.status === "self-signed") { + console.log(`\nSignature Information:`); + console.log(` Subject: ${signatureInfo.publisher}`); + console.log(` Issuer: ${signatureInfo.issuer} (self-signed)`); + console.log( + ` Valid from: ${new Date(signatureInfo.valid_from!).toLocaleDateString()} to ${new Date(signatureInfo.valid_to!).toLocaleDateString()}`, + ); + console.log(` Fingerprint: ${signatureInfo.fingerprint}`); + console.log(` Status: Valid (self-signed)`); + } else { + console.log(`\nWARNING: Not signed`); + } + } catch (error) { + console.log( + `ERROR: Failed to read DXT info: ${error instanceof Error ? error.message : "Unknown error"}`, + ); + process.exit(1); + } + })(); + }); + +// Unsign command (for development/testing) +program + .command("unsign ") + .description("Remove signature from a DXT extension file") + .action((dxtFile: string) => { + try { + const dxtPath = resolve(dxtFile); + + if (!existsSync(dxtPath)) { + console.error(`ERROR: DXT file not found: ${dxtFile}`); + process.exit(1); + } + + console.log(`Removing signature from ${basename(dxtPath)}...`); + unsignDxtFile(dxtPath); + console.log(`Signature removed`); + } catch (error) { + console.log( + `ERROR: Failed to remove signature: ${error instanceof Error ? error.message : "Unknown error"}`, + ); + process.exit(1); + } + }); + +// Parse command line arguments +program.parse(); diff --git a/src/cli/init.ts b/src/cli/init.ts new file mode 100644 index 0000000..70c3c17 --- /dev/null +++ b/src/cli/init.ts @@ -0,0 +1,928 @@ +import { confirm, input, select } from "@inquirer/prompts"; +import { existsSync, readFileSync, writeFileSync } from "fs"; +import { basename, join, resolve } from "path"; + +import type { DxtManifest } from "../types.js"; + +interface PackageJson { + name?: string; + version?: string; + description?: string; + main?: string; + author?: string | { name?: string; email?: string; url?: string }; + repository?: string | { type?: string; url?: string }; + license?: string; +} + +export function readPackageJson(dirPath: string): PackageJson { + const packageJsonPath = join(dirPath, "package.json"); + if (existsSync(packageJsonPath)) { + try { + return JSON.parse(readFileSync(packageJsonPath, "utf-8")); + } catch (e) { + // Ignore package.json parsing errors + } + } + return {}; +} + +export function getDefaultAuthorName(packageData: PackageJson): string { + if (typeof packageData.author === "string") { + return packageData.author; + } + return packageData.author?.name || ""; +} + +export function getDefaultAuthorEmail(packageData: PackageJson): string { + if (typeof packageData.author === "object") { + return packageData.author?.email || ""; + } + return ""; +} + +export function getDefaultAuthorUrl(packageData: PackageJson): string { + if (typeof packageData.author === "object") { + return packageData.author?.url || ""; + } + return ""; +} + +export function getDefaultRepositoryUrl(packageData: PackageJson): string { + if (typeof packageData.repository === "string") { + return packageData.repository; + } + return packageData.repository?.url || ""; +} + +export function getDefaultBasicInfo( + packageData: PackageJson, + resolvedPath: string, +) { + const name = packageData.name || basename(resolvedPath); + const authorName = getDefaultAuthorName(packageData) || "Unknown Author"; + const displayName = name; + const version = packageData.version || "1.0.0"; + const description = packageData.description || "A DXT extension"; + + return { name, authorName, displayName, version, description }; +} + +export function getDefaultAuthorInfo(packageData: PackageJson) { + return { + authorEmail: getDefaultAuthorEmail(packageData), + authorUrl: getDefaultAuthorUrl(packageData), + }; +} + +export function getDefaultServerConfig(packageData?: PackageJson) { + const serverType = "node" as const; + const entryPoint = getDefaultEntryPoint(serverType, packageData); + const mcp_config = createMcpConfig(serverType, entryPoint); + + return { serverType, entryPoint, mcp_config }; +} + +export function getDefaultOptionalFields(packageData: PackageJson) { + return { + keywords: "", + license: packageData.license || "MIT", + repository: undefined, + }; +} + +export function createMcpConfig( + serverType: "node" | "python" | "binary", + entryPoint: string, +): { + command: string; + args: string[]; + env?: Record; +} { + switch (serverType) { + case "node": + return { + command: "node", + args: ["${__dirname}/" + entryPoint], + env: {}, + }; + case "python": + return { + command: "python", + args: ["${__dirname}/" + entryPoint], + env: { + PYTHONPATH: "server/lib", + }, + }; + case "binary": + return { + command: "${__dirname}/" + entryPoint, + args: [], + env: {}, + }; + } +} + +export function getDefaultEntryPoint( + serverType: "node" | "python" | "binary", + packageData?: PackageJson, +): string { + switch (serverType) { + case "node": + return packageData?.main || "server/index.js"; + case "python": + return "server/main.py"; + case "binary": + return "server/my-server"; + } +} + +export async function promptBasicInfo( + packageData: PackageJson, + resolvedPath: string, +) { + const defaultName = packageData.name || basename(resolvedPath); + + const name = await input({ + message: "Extension name:", + default: defaultName, + validate: (value) => value.trim().length > 0 || "Name is required", + }); + + const authorName = await input({ + message: "Author name:", + default: getDefaultAuthorName(packageData), + validate: (value) => value.trim().length > 0 || "Author name is required", + }); + + const displayName = await input({ + message: "Display name (optional):", + default: name, + }); + + const version = await input({ + message: "Version:", + default: packageData.version || "1.0.0", + validate: (value) => { + if (!value.trim()) return "Version is required"; + if (!/^\d+\.\d+\.\d+/.test(value)) { + return "Version must follow semantic versioning (e.g., 1.0.0)"; + } + return true; + }, + }); + + const description = await input({ + message: "Description:", + default: packageData.description || "", + validate: (value) => value.trim().length > 0 || "Description is required", + }); + + return { name, authorName, displayName, version, description }; +} + +export async function promptAuthorInfo(packageData: PackageJson) { + const authorEmail = await input({ + message: "Author email (optional):", + default: getDefaultAuthorEmail(packageData), + }); + + const authorUrl = await input({ + message: "Author URL (optional):", + default: getDefaultAuthorUrl(packageData), + }); + + return { authorEmail, authorUrl }; +} + +export async function promptServerConfig(packageData?: PackageJson) { + const serverType = (await select({ + message: "Server type:", + choices: [ + { name: "Node.js", value: "node" }, + { name: "Python", value: "python" }, + { name: "Binary", value: "binary" }, + ], + default: "node", + })) as "node" | "python" | "binary"; + + const entryPoint = await input({ + message: "Entry point:", + default: getDefaultEntryPoint(serverType, packageData), + }); + + const mcp_config = createMcpConfig(serverType, entryPoint); + + return { serverType, entryPoint, mcp_config }; +} + +export async function promptTools() { + const addTools = await confirm({ + message: + "Does your MCP Server provide tools you want to advertise (optional)?", + default: true, + }); + + const tools: Array<{ name: string; description?: string }> = []; + let toolsGenerated = false; + + if (addTools) { + let addMore = true; + while (addMore) { + const toolName = await input({ + message: "Tool name:", + validate: (value) => value.trim().length > 0 || "Tool name is required", + }); + const toolDescription = await input({ + message: "Tool description (optional):", + }); + + tools.push({ + name: toolName, + ...(toolDescription ? { description: toolDescription } : {}), + }); + + addMore = await confirm({ + message: "Add another tool?", + default: false, + }); + } + + // Ask about generated tools + toolsGenerated = await confirm({ + message: "Does your server generate additional tools at runtime?", + default: false, + }); + } + + return { tools, toolsGenerated }; +} + +export async function promptPrompts() { + const addPrompts = await confirm({ + message: + "Does your MCP Server provide prompts you want to advertise (optional)?", + default: false, + }); + + const prompts: Array<{ + name: string; + description?: string; + arguments?: string[]; + text: string; + }> = []; + let promptsGenerated = false; + + if (addPrompts) { + let addMore = true; + while (addMore) { + const promptName = await input({ + message: "Prompt name:", + validate: (value) => + value.trim().length > 0 || "Prompt name is required", + }); + const promptDescription = await input({ + message: "Prompt description (optional):", + }); + + // Ask about arguments + const hasArguments = await confirm({ + message: "Does this prompt have arguments?", + default: false, + }); + + const argumentNames: string[] = []; + if (hasArguments) { + let addMoreArgs = true; + while (addMoreArgs) { + const argName = await input({ + message: "Argument name:", + validate: (value) => { + if (!value.trim()) return "Argument name is required"; + if (argumentNames.includes(value)) { + return "Argument names must be unique"; + } + return true; + }, + }); + argumentNames.push(argName); + + addMoreArgs = await confirm({ + message: "Add another argument?", + default: false, + }); + } + } + + // Prompt for the text template + const promptText = await input({ + message: hasArguments + ? `Prompt text (use \${arguments.name} for arguments: ${argumentNames.join(", ")}):` + : "Prompt text:", + validate: (value) => + value.trim().length > 0 || "Prompt text is required", + }); + + prompts.push({ + name: promptName, + ...(promptDescription ? { description: promptDescription } : {}), + ...(argumentNames.length > 0 ? { arguments: argumentNames } : {}), + text: promptText, + }); + + addMore = await confirm({ + message: "Add another prompt?", + default: false, + }); + } + + // Ask about generated prompts + promptsGenerated = await confirm({ + message: "Does your server generate additional prompts at runtime?", + default: false, + }); + } + + return { prompts, promptsGenerated }; +} + +export async function promptOptionalFields(packageData: PackageJson) { + const keywords = await input({ + message: "Keywords (comma-separated, optional):", + default: "", + }); + + const license = await input({ + message: "License:", + default: packageData.license || "MIT", + }); + + const addRepository = await confirm({ + message: "Add repository information?", + default: !!packageData.repository, + }); + + let repository: { type: string; url: string } | undefined; + if (addRepository) { + const repoUrl = await input({ + message: "Repository URL:", + default: getDefaultRepositoryUrl(packageData), + }); + if (repoUrl) { + repository = { + type: "git", + url: repoUrl, + }; + } + } + + return { keywords, license, repository }; +} + +export async function promptLongDescription(description: string) { + const hasLongDescription = await confirm({ + message: "Add a detailed long description?", + default: false, + }); + + if (hasLongDescription) { + const longDescription = await input({ + message: "Long description (supports basic markdown):", + default: description, + }); + return longDescription; + } + + return undefined; +} + +export async function promptUrls() { + const homepage = await input({ + message: "Homepage URL (optional):", + validate: (value) => { + if (!value.trim()) return true; + try { + new URL(value); + return true; + } catch { + return "Must be a valid URL (e.g., https://example.com)"; + } + }, + }); + + const documentation = await input({ + message: "Documentation URL (optional):", + validate: (value) => { + if (!value.trim()) return true; + try { + new URL(value); + return true; + } catch { + return "Must be a valid URL"; + } + }, + }); + + const support = await input({ + message: "Support URL (optional):", + validate: (value) => { + if (!value.trim()) return true; + try { + new URL(value); + return true; + } catch { + return "Must be a valid URL"; + } + }, + }); + + return { homepage, documentation, support }; +} + +export async function promptVisualAssets() { + const icon = await input({ + message: "Icon file path (optional, relative to manifest):", + validate: (value) => { + if (!value.trim()) return true; + if (value.includes("..")) return "Relative paths cannot include '..'"; + return true; + }, + }); + + const addScreenshots = await confirm({ + message: "Add screenshots?", + default: false, + }); + + const screenshots: string[] = []; + if (addScreenshots) { + let addMore = true; + while (addMore) { + const screenshot = await input({ + message: "Screenshot file path (relative to manifest):", + validate: (value) => { + if (!value.trim()) return "Screenshot path is required"; + if (value.includes("..")) return "Relative paths cannot include '..'"; + return true; + }, + }); + screenshots.push(screenshot); + + addMore = await confirm({ + message: "Add another screenshot?", + default: false, + }); + } + } + + return { icon, screenshots }; +} + +export async function promptCompatibility( + serverType: "node" | "python" | "binary", +) { + const addCompatibility = await confirm({ + message: "Add compatibility constraints?", + default: false, + }); + + if (!addCompatibility) { + return undefined; + } + + const addPlatforms = await confirm({ + message: "Specify supported platforms?", + default: false, + }); + + let platforms: ("darwin" | "win32" | "linux")[] | undefined; + if (addPlatforms) { + const selectedPlatforms: ("darwin" | "win32" | "linux")[] = []; + + const supportsDarwin = await confirm({ + message: "Support macOS (darwin)?", + default: true, + }); + if (supportsDarwin) selectedPlatforms.push("darwin"); + + const supportsWin32 = await confirm({ + message: "Support Windows (win32)?", + default: true, + }); + if (supportsWin32) selectedPlatforms.push("win32"); + + const supportsLinux = await confirm({ + message: "Support Linux?", + default: true, + }); + if (supportsLinux) selectedPlatforms.push("linux"); + + platforms = selectedPlatforms.length > 0 ? selectedPlatforms : undefined; + } + + let runtimes: { python?: string; node?: string } | undefined; + if (serverType !== "binary") { + const addRuntimes = await confirm({ + message: "Specify runtime version constraints?", + default: false, + }); + + if (addRuntimes) { + if (serverType === "python") { + const pythonVersion = await input({ + message: "Python version constraint (e.g., >=3.8,<4.0):", + validate: (value) => + value.trim().length > 0 || "Python version constraint is required", + }); + runtimes = { python: pythonVersion }; + } else if (serverType === "node") { + const nodeVersion = await input({ + message: "Node.js version constraint (e.g., >=16.0.0):", + validate: (value) => + value.trim().length > 0 || "Node.js version constraint is required", + }); + runtimes = { node: nodeVersion }; + } + } + } + + return { + ...(platforms ? { platforms } : {}), + ...(runtimes ? { runtimes } : {}), + }; +} + +export async function promptUserConfig() { + const addUserConfig = await confirm({ + message: "Add user-configurable options?", + default: false, + }); + + if (!addUserConfig) { + return {}; + } + + const userConfig: Record< + string, + { + type: "string" | "number" | "boolean" | "directory" | "file"; + title: string; + description: string; + required?: boolean; + default?: string | number | boolean | string[]; + multiple?: boolean; + sensitive?: boolean; + min?: number; + max?: number; + } + > = {}; + + let addMore = true; + while (addMore) { + const optionKey = await input({ + message: "Configuration option key (unique identifier):", + validate: (value) => { + if (!value.trim()) return "Key is required"; + if (userConfig[value]) return "Key must be unique"; + return true; + }, + }); + + const optionType = (await select({ + message: "Option type:", + choices: [ + { name: "String", value: "string" }, + { name: "Number", value: "number" }, + { name: "Boolean", value: "boolean" }, + { name: "Directory", value: "directory" }, + { name: "File", value: "file" }, + ], + })) as "string" | "number" | "boolean" | "directory" | "file"; + + const optionTitle = await input({ + message: "Option title (human-readable name):", + validate: (value) => value.trim().length > 0 || "Title is required", + }); + + const optionDescription = await input({ + message: "Option description:", + validate: (value) => value.trim().length > 0 || "Description is required", + }); + + const optionRequired = await confirm({ + message: "Is this option required?", + default: false, + }); + + const optionSensitive = await confirm({ + message: "Is this option sensitive (like a password)?", + default: false, + }); + + // Build the option object + const option: { + type: "string" | "number" | "boolean" | "directory" | "file"; + title: string; + description: string; + required: boolean; + sensitive: boolean; + default?: string | number | boolean | string[]; + min?: number; + max?: number; + } = { + type: optionType, + title: optionTitle, + description: optionDescription, + required: optionRequired, + sensitive: optionSensitive, + }; + + // Add default value if not required + if (!optionRequired) { + let defaultValue: string | number | boolean | string[] | undefined; + if (optionType === "boolean") { + defaultValue = await confirm({ + message: "Default value:", + default: false, + }); + } else if (optionType === "number") { + const defaultStr = await input({ + message: "Default value (number):", + validate: (value) => { + if (!value.trim()) return true; + return !isNaN(Number(value)) || "Must be a valid number"; + }, + }); + defaultValue = defaultStr ? Number(defaultStr) : undefined; + } else { + defaultValue = await input({ + message: "Default value (optional):", + }); + } + if (defaultValue !== undefined && defaultValue !== "") { + option.default = defaultValue; + } + } + + // Add constraints for number types + if (optionType === "number") { + const addConstraints = await confirm({ + message: "Add min/max constraints?", + default: false, + }); + if (addConstraints) { + const min = await input({ + message: "Minimum value (optional):", + validate: (value) => { + if (!value.trim()) return true; + return !isNaN(Number(value)) || "Must be a valid number"; + }, + }); + const max = await input({ + message: "Maximum value (optional):", + validate: (value) => { + if (!value.trim()) return true; + return !isNaN(Number(value)) || "Must be a valid number"; + }, + }); + if (min) option.min = Number(min); + if (max) option.max = Number(max); + } + } + + userConfig[optionKey] = option; + + addMore = await confirm({ + message: "Add another configuration option?", + default: false, + }); + } + + return userConfig; +} + +export function buildManifest( + basicInfo: { + name: string; + displayName: string; + version: string; + description: string; + authorName: string; + }, + longDescription: string | undefined, + authorInfo: { + authorEmail: string; + authorUrl: string; + }, + urls: { + homepage: string; + documentation: string; + support: string; + }, + visualAssets: { + icon: string; + screenshots: string[]; + }, + serverConfig: { + serverType: "node" | "python" | "binary"; + entryPoint: string; + mcp_config: { + command: string; + args: string[]; + env?: Record; + }; + }, + tools: Array<{ name: string; description?: string }>, + toolsGenerated: boolean, + prompts: Array<{ + name: string; + description?: string; + arguments?: string[]; + text: string; + }>, + promptsGenerated: boolean, + compatibility: + | { + claude_desktop?: string; + platforms?: ("darwin" | "win32" | "linux")[]; + runtimes?: { python?: string; node?: string }; + } + | undefined, + userConfig: Record< + string, + { + type: "string" | "number" | "boolean" | "directory" | "file"; + title: string; + description: string; + required?: boolean; + default?: string | number | boolean | string[]; + multiple?: boolean; + sensitive?: boolean; + min?: number; + max?: number; + } + >, + optionalFields: { + keywords: string; + license: string; + repository?: { type: string; url: string }; + }, +): DxtManifest { + const { name, displayName, version, description, authorName } = basicInfo; + const { authorEmail, authorUrl } = authorInfo; + const { serverType, entryPoint, mcp_config } = serverConfig; + const { keywords, license, repository } = optionalFields; + + return { + dxt_version: "0.1", + name, + ...(displayName && displayName !== name + ? { display_name: displayName } + : {}), + version, + description, + ...(longDescription ? { long_description: longDescription } : {}), + author: { + name: authorName, + ...(authorEmail ? { email: authorEmail } : {}), + ...(authorUrl ? { url: authorUrl } : {}), + }, + ...(urls.homepage ? { homepage: urls.homepage } : {}), + ...(urls.documentation ? { documentation: urls.documentation } : {}), + ...(urls.support ? { support: urls.support } : {}), + ...(visualAssets.icon ? { icon: visualAssets.icon } : {}), + ...(visualAssets.screenshots.length > 0 + ? { screenshots: visualAssets.screenshots } + : {}), + server: { + type: serverType, + entry_point: entryPoint, + mcp_config, + }, + ...(tools.length > 0 ? { tools } : {}), + ...(toolsGenerated ? { tools_generated: true } : {}), + ...(prompts.length > 0 ? { prompts } : {}), + ...(promptsGenerated ? { prompts_generated: true } : {}), + ...(compatibility ? { compatibility } : {}), + ...(Object.keys(userConfig).length > 0 ? { user_config: userConfig } : {}), + ...(keywords + ? { + keywords: keywords + .split(",") + .map((k) => k.trim()) + .filter((k) => k), + } + : {}), + ...(license ? { license } : {}), + ...(repository ? { repository } : {}), + }; +} + +export function printNextSteps() { + console.log("\nNext steps:"); + console.log( + `1. Ensure all your production dependencies are in this directory`, + ); + console.log(`2. Run 'dxt pack' to create your .dxt file`); +} + +export async function initExtension( + targetPath: string = process.cwd(), + nonInteractive = false, +): Promise { + const resolvedPath = resolve(targetPath); + const manifestPath = join(resolvedPath, "manifest.json"); + + if (existsSync(manifestPath)) { + if (nonInteractive) { + console.log( + "manifest.json already exists. Use --force to overwrite in non-interactive mode.", + ); + return false; + } + const overwrite = await confirm({ + message: "manifest.json already exists. Overwrite?", + default: false, + }); + if (!overwrite) { + console.log("Cancelled"); + return false; + } + } + + if (!nonInteractive) { + console.log( + "This utility will help you create a manifest.json file for your DXT extension.", + ); + console.log("Press ^C at any time to quit.\n"); + } else { + console.log("Creating manifest.json with default values..."); + } + + try { + const packageData = readPackageJson(resolvedPath); + + // Prompt for all information or use defaults + const basicInfo = nonInteractive + ? getDefaultBasicInfo(packageData, resolvedPath) + : await promptBasicInfo(packageData, resolvedPath); + const longDescription = nonInteractive + ? undefined + : await promptLongDescription(basicInfo.description); + const authorInfo = nonInteractive + ? getDefaultAuthorInfo(packageData) + : await promptAuthorInfo(packageData); + const urls = nonInteractive + ? { homepage: "", documentation: "", support: "" } + : await promptUrls(); + const visualAssets = nonInteractive + ? { icon: "", screenshots: [] } + : await promptVisualAssets(); + const serverConfig = nonInteractive + ? getDefaultServerConfig(packageData) + : await promptServerConfig(packageData); + const toolsData = nonInteractive + ? { tools: [], toolsGenerated: false } + : await promptTools(); + const promptsData = nonInteractive + ? { prompts: [], promptsGenerated: false } + : await promptPrompts(); + const compatibility = nonInteractive + ? undefined + : await promptCompatibility(serverConfig.serverType); + const userConfig = nonInteractive ? {} : await promptUserConfig(); + const optionalFields = nonInteractive + ? getDefaultOptionalFields(packageData) + : await promptOptionalFields(packageData); + + // Build manifest + const manifest = buildManifest( + basicInfo, + longDescription, + authorInfo, + urls, + visualAssets, + serverConfig, + toolsData.tools, + toolsData.toolsGenerated, + promptsData.prompts, + promptsData.promptsGenerated, + compatibility, + userConfig, + optionalFields, + ); + + // Write manifest + writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + "\n"); + console.log(`\nCreated manifest.json at ${manifestPath}`); + + printNextSteps(); + + return true; + } catch (error) { + if (error instanceof Error && error.message.includes("User force closed")) { + console.log("\nCancelled"); + return false; + } + throw error; + } +} diff --git a/src/cli/pack.ts b/src/cli/pack.ts new file mode 100644 index 0000000..75396fc --- /dev/null +++ b/src/cli/pack.ts @@ -0,0 +1,222 @@ +import { confirm } from "@inquirer/prompts"; +import { createHash } from "crypto"; +import { zipSync } from "fflate"; +import { + existsSync, + mkdirSync, + readFileSync, + statSync, + writeFileSync, +} from "fs"; +import { basename, join, relative, resolve, sep } from "path"; + +import { getAllFilesWithCount, readDxtIgnorePatterns } from "../node/files.js"; +import { validateManifest } from "../node/validate.js"; +import { DxtManifestSchema } from "../schemas.js"; +import { getLogger } from "../shared/log.js"; +import { initExtension } from "./init.js"; + +interface PackOptions { + extensionPath: string; + outputPath?: string; + silent?: boolean; +} + +function formatFileSize(bytes: number): string { + if (bytes < 1024) { + return `${bytes}B`; + } else if (bytes < 1024 * 1024) { + return `${(bytes / 1024).toFixed(1)}kB`; + } else { + return `${(bytes / (1024 * 1024)).toFixed(1)}MB`; + } +} + +function sanitizeNameForFilename(name: string): string { + // Replace spaces with hyphens + // Remove or replace characters that are problematic in filenames + return name + .toLowerCase() + .replace(/\s+/g, "-") // Replace spaces with hyphens + .replace(/[^a-z0-9-_.]/g, "") // Keep only alphanumeric, hyphens, underscores, and dots + .replace(/-+/g, "-") // Replace multiple hyphens with single hyphen + .replace(/^-+|-+$/g, "") // Remove leading/trailing hyphens + .substring(0, 100); // Limit length to 100 characters +} + +export async function packExtension({ + extensionPath, + outputPath, + silent, +}: PackOptions): Promise { + const resolvedPath = resolve(extensionPath); + const logger = getLogger({ silent }); + + // Check if directory exists + if (!existsSync(resolvedPath) || !statSync(resolvedPath).isDirectory()) { + logger.error(`ERROR: Directory not found: ${extensionPath}`); + return false; + } + + // Check if manifest exists + const manifestPath = join(resolvedPath, "manifest.json"); + if (!existsSync(manifestPath)) { + logger.log(`No manifest.json found in ${extensionPath}`); + const shouldInit = await confirm({ + message: "Would you like to create a manifest.json file?", + default: true, + }); + + if (shouldInit) { + const success = await initExtension(extensionPath); + if (!success) { + logger.error("ERROR: Failed to create manifest"); + return false; + } + } else { + logger.error("ERROR: Cannot pack extension without manifest.json"); + return false; + } + } + + // Validate manifest first + logger.log("Validating manifest..."); + if (!validateManifest(manifestPath)) { + logger.error("ERROR: Cannot pack extension with invalid manifest"); + return false; + } + + // Read and parse manifest + let manifest; + try { + const manifestContent = readFileSync(manifestPath, "utf-8"); + const manifestData = JSON.parse(manifestContent); + manifest = DxtManifestSchema.parse(manifestData); + } catch (error) { + logger.error("ERROR: Failed to parse manifest.json"); + if (error instanceof Error) { + logger.error(` ${error.message}`); + } + return false; + } + + // Determine output path + const extensionName = basename(resolvedPath); + const finalOutputPath = outputPath + ? resolve(outputPath) + : resolve(`${extensionName}.dxt`); + + // Ensure output directory exists + const outputDir = join(finalOutputPath, ".."); + mkdirSync(outputDir, { recursive: true }); + + try { + // Read .dxtignore patterns if present + const dxtIgnorePatterns = readDxtIgnorePatterns(resolvedPath); + + // Get all files in the extension directory + const { files, ignoredCount } = getAllFilesWithCount( + resolvedPath, + resolvedPath, + {}, + dxtIgnorePatterns, + ); + + // Print package header + logger.log(`\n📦 ${manifest.name}@${manifest.version}`); + + // Print file list + logger.log("Archive Contents"); + const fileEntries = Object.entries(files); + let totalUnpackedSize = 0; + + // Sort files for consistent output + fileEntries.sort(([a], [b]) => a.localeCompare(b)); + + // Group files by directory for deep nesting + const directoryGroups = new Map< + string, + { files: string[]; totalSize: number } + >(); + const shallowFiles: Array<{ path: string; size: number }> = []; + + for (const [filePath, content] of fileEntries) { + const relPath = relative(resolvedPath, filePath); + const size = + typeof content === "string" + ? Buffer.byteLength(content, "utf8") + : content.length; + totalUnpackedSize += size; + + // Check if file is deeply nested (3+ levels) + const parts = relPath.split(sep); + if (parts.length > 3) { + // Group by the first 3 directory levels + const groupKey = parts.slice(0, 3).join("/"); + if (!directoryGroups.has(groupKey)) { + directoryGroups.set(groupKey, { files: [], totalSize: 0 }); + } + const group = directoryGroups.get(groupKey)!; + group.files.push(relPath); + group.totalSize += size; + } else { + shallowFiles.push({ path: relPath, size }); + } + } + + // Print shallow files first + for (const { path, size } of shallowFiles) { + logger.log(`${formatFileSize(size).padStart(8)} ${path}`); + } + + // Print grouped directories + for (const [dir, { files, totalSize }] of directoryGroups) { + if (files.length === 1) { + // If only one file in the group, print it normally + const filePath = files[0]; + const fileSize = totalSize; + logger.log(`${formatFileSize(fileSize).padStart(8)} ${filePath}`); + } else { + // Print directory summary + logger.log( + `${formatFileSize(totalSize).padStart(8)} ${dir}/ [and ${files.length} more files]`, + ); + } + } + + // Create zip + const zipData = zipSync(files, { + level: 9, // Maximum compression + mtime: new Date(), + }); + + // Write zip file + writeFileSync(finalOutputPath, zipData); + + // Calculate SHA sum + const shasum = createHash("sha1").update(zipData).digest("hex"); + + // Print archive details + const sanitizedName = sanitizeNameForFilename(manifest.name); + const archiveName = `${sanitizedName}-${manifest.version}.dxt`; + logger.log("\nArchive Details"); + logger.log(`name: ${manifest.name}`); + logger.log(`version: ${manifest.version}`); + logger.log(`filename: ${archiveName}`); + logger.log(`package size: ${formatFileSize(zipData.length)}`); + logger.log(`unpacked size: ${formatFileSize(totalUnpackedSize)}`); + logger.log(`shasum: ${shasum}`); + logger.log(`total files: ${fileEntries.length}`); + logger.log(`ignored (.dxtignore) files: ${ignoredCount}`); + + logger.log(`\nOutput: ${finalOutputPath}`); + return true; + } catch (error) { + if (error instanceof Error) { + logger.error(`ERROR: Archive error: ${error.message}`); + } else { + logger.error("ERROR: Unknown archive error occurred"); + } + return false; + } +} diff --git a/src/index.ts b/src/index.ts new file mode 100644 index 0000000..0e01556 --- /dev/null +++ b/src/index.ts @@ -0,0 +1,9 @@ +// Default export includes everything (backward compatibility) +export * from "./cli/init.js"; +export * from "./cli/pack.js"; +export * from "./node/files.js"; +export * from "./node/sign.js"; +export * from "./node/validate.js"; +export * from "./schemas.js"; +export * from "./shared/config.js"; +export * from "./types.js"; diff --git a/src/node.ts b/src/node.ts new file mode 100644 index 0000000..3af29fb --- /dev/null +++ b/src/node.ts @@ -0,0 +1,9 @@ +// Node.js-specific exports +export * from "./node/files.js"; +export * from "./node/sign.js"; +export * from "./node/validate.js"; + +// Include all shared exports +export * from "./schemas.js"; +export * from "./shared/config.js"; +export * from "./types.js"; diff --git a/src/node/files.ts b/src/node/files.ts new file mode 100644 index 0000000..cf17e1f --- /dev/null +++ b/src/node/files.ts @@ -0,0 +1,191 @@ +import { existsSync, readdirSync, readFileSync, statSync } from "fs"; +import { basename, join, relative, sep } from "path"; + +// Files/patterns to exclude from the package +export const EXCLUDE_PATTERNS = [ + ".DS_Store", + "Thumbs.db", + ".gitignore", + ".git", + ".dxtignore", + "*.log", + ".npm", + ".npmrc", + ".yarnrc", + ".yarn", + ".eslintrc", + ".editorconfig", + ".prettierrc", + ".prettierignore", + ".eslintignore", + ".nycrc", + ".babelrc", + ".pnp.*", + "node_modules/.cache", + "node_modules/.bin", + "*.map", + ".env.local", + ".env.*.local", + "npm-debug.log*", + "yarn-debug.log*", + "yarn-error.log*", + "package-lock.json", + "yarn.lock", + "*.dxt", + "*.d.ts", + "*.tsbuildinfo", + "tsconfig.json", +]; + +/** + * Read and parse .dxtignore file patterns + */ +export function readDxtIgnorePatterns(baseDir: string): string[] { + const dxtIgnorePath = join(baseDir, ".dxtignore"); + if (!existsSync(dxtIgnorePath)) { + return []; + } + + try { + const content = readFileSync(dxtIgnorePath, "utf-8"); + return content + .split(/\r?\n/) + .map((line) => line.trim()) + .filter((line) => line.length > 0 && !line.startsWith("#")); + } catch (error) { + console.warn( + `Warning: Could not read .dxtignore file: ${error instanceof Error ? error.message : "Unknown error"}`, + ); + return []; + } +} + +export function shouldExclude( + filePath: string, + additionalPatterns: string[] = [], +): boolean { + const fileName = basename(filePath); + const allPatterns = [...EXCLUDE_PATTERNS, ...additionalPatterns]; + + for (const pattern of allPatterns) { + if (pattern.includes("*")) { + // Enhanced glob matching to handle directory paths like "temp/*" + let patternToMatch = pattern; + + // Handle patterns like "dir/" by converting to "dir/**" + if (pattern.endsWith("/")) { + patternToMatch = pattern + "**"; + } + + // Convert glob pattern to regex, with case sensitivity + const regexPattern = + "^" + + patternToMatch + .replace(/\./g, "\\.") // Escape dots + .replace(/\*\*/g, ".*") // ** matches anything including / + .replace(/\*/g, "[^/]*") + // * matches anything except / + "$"; + + const regex = new RegExp(regexPattern); + + // Test full path + if (regex.test(filePath)) return true; + + // Test filename + if (regex.test(fileName)) return true; + + // Check if any part of the path matches for patterns like "node_modules" + const pathParts = filePath.split(sep); + for (const part of pathParts) { + if (regex.test(part)) return true; + } + } else { + // Exact match + if (fileName === pattern) return true; + + // Check if any part of the path matches + if (filePath.includes(pattern)) return true; + + // Handle directory patterns like "tests/" + if (pattern.endsWith("/") && filePath.startsWith(pattern)) { + return true; + } + } + } + + return false; +} + +export function getAllFiles( + dirPath: string, + baseDir: string = dirPath, + fileList: Record = {}, + additionalPatterns: string[] = [], +): Record { + const files = readdirSync(dirPath); + + for (const file of files) { + const filePath = join(dirPath, file); + const relativePath = relative(baseDir, filePath); + + if (shouldExclude(relativePath, additionalPatterns)) { + continue; + } + + const stat = statSync(filePath); + + if (stat.isDirectory()) { + getAllFiles(filePath, baseDir, fileList, additionalPatterns); + } else { + // Use forward slashes in zip file paths + const zipPath = relativePath.split(sep).join("/"); + fileList[zipPath] = readFileSync(filePath); + } + } + + return fileList; +} + +export interface GetAllFilesResult { + files: Record; + ignoredCount: number; +} + +export function getAllFilesWithCount( + dirPath: string, + baseDir: string = dirPath, + fileList: Record = {}, + additionalPatterns: string[] = [], + ignoredCount = 0, +): GetAllFilesResult { + const files = readdirSync(dirPath); + + for (const file of files) { + const filePath = join(dirPath, file); + const relativePath = relative(baseDir, filePath); + + if (shouldExclude(relativePath, additionalPatterns)) { + ignoredCount++; + continue; + } + + const stat = statSync(filePath); + + if (stat.isDirectory()) { + const result = getAllFilesWithCount( + filePath, + baseDir, + fileList, + additionalPatterns, + ignoredCount, + ); + ignoredCount = result.ignoredCount; + } else { + // Use forward slashes in zip file paths + const zipPath = relativePath.split(sep).join("/"); + fileList[zipPath] = readFileSync(filePath); + } + } + + return { files: fileList, ignoredCount }; +} diff --git a/src/node/sign.ts b/src/node/sign.ts new file mode 100644 index 0000000..48b311d --- /dev/null +++ b/src/node/sign.ts @@ -0,0 +1,409 @@ +import { execFile } from "child_process"; +import { readFileSync, writeFileSync } from "fs"; +import { mkdtemp, rm, writeFile } from "fs/promises"; +import forge from "node-forge"; +import { tmpdir } from "os"; +import { join } from "path"; +import { promisify } from "util"; + +import type { DxtSignatureInfo } from "../types.js"; + +// Signature block markers +const SIGNATURE_HEADER = "DXT_SIG_V1"; +const SIGNATURE_FOOTER = "DXT_SIG_END"; + +const execFileAsync = promisify(execFile); + +/** + * Signs a DXT file with the given certificate and private key using PKCS#7 + * + * @param dxtPath Path to the DXT file to sign + * @param certPath Path to the certificate file (PEM format) + * @param keyPath Path to the private key file (PEM format) + * @param intermediates Optional array of intermediate certificate paths + */ +export function signDxtFile( + dxtPath: string, + certPath: string, + keyPath: string, + intermediates?: string[], +): void { + // Read the original DXT file + const dxtContent = readFileSync(dxtPath); + + // Read certificate and key + const certificatePem = readFileSync(certPath, "utf-8"); + const privateKeyPem = readFileSync(keyPath, "utf-8"); + + // Read intermediate certificates if provided + const intermediatePems = intermediates?.map((path) => + readFileSync(path, "utf-8"), + ); + + // Create PKCS#7 signed data + const p7 = forge.pkcs7.createSignedData(); + p7.content = forge.util.createBuffer(dxtContent); + + // Parse and add certificates + const signingCert = forge.pki.certificateFromPem(certificatePem); + const privateKey = forge.pki.privateKeyFromPem(privateKeyPem); + + p7.addCertificate(signingCert); + + // Add intermediate certificates + if (intermediatePems) { + for (const pem of intermediatePems) { + p7.addCertificate(forge.pki.certificateFromPem(pem)); + } + } + + // Add signer + p7.addSigner({ + key: privateKey, + certificate: signingCert, + digestAlgorithm: forge.pki.oids.sha256, + authenticatedAttributes: [ + { + type: forge.pki.oids.contentType, + value: forge.pki.oids.data, + }, + { + type: forge.pki.oids.messageDigest, + // Value will be auto-populated + }, + { + type: forge.pki.oids.signingTime, + // Value will be auto-populated with current time + }, + ], + }); + + // Sign with detached signature + p7.sign({ detached: true }); + + // Convert to DER format + const asn1 = forge.asn1.toDer(p7.toAsn1()); + const pkcs7Signature = Buffer.from(asn1.getBytes(), "binary"); + + // Create signature block with PKCS#7 data + const signatureBlock = createSignatureBlock(pkcs7Signature); + + // Append signature block to DXT file + const signedContent = Buffer.concat([dxtContent, signatureBlock]); + writeFileSync(dxtPath, signedContent); +} + +/** + * Verifies a signed DXT file using OS certificate store + * + * @param dxtPath Path to the signed DXT file + * @returns Signature information including verification status + */ +export async function verifyDxtFile( + dxtPath: string, +): Promise { + try { + const fileContent = readFileSync(dxtPath); + + // Find and extract signature block + const { originalContent, pkcs7Signature } = + extractSignatureBlock(fileContent); + if (!pkcs7Signature) { + return { status: "unsigned" }; + } + + // Parse PKCS#7 signature + const asn1 = forge.asn1.fromDer(pkcs7Signature.toString("binary")); + const p7Message = forge.pkcs7.messageFromAsn1(asn1); + + // Verify it's signed data and cast to correct type + if ( + !("type" in p7Message) || + p7Message.type !== forge.pki.oids.signedData + ) { + return { status: "unsigned" }; + } + + // Now we know it's PkcsSignedData. The types are incorrect, so we'll + // fix them there + const p7 = p7Message as unknown as forge.pkcs7.PkcsSignedData & { + signerInfos: Array<{ + authenticatedAttributes: Array<{ + type: string; + value: unknown; + }>; + }>; + verify: (options?: { authenticatedAttributes?: boolean }) => boolean; + }; + + // Extract certificates from PKCS#7 + const certificates = p7.certificates || []; + if (certificates.length === 0) { + return { status: "unsigned" }; + } + + // Get the signing certificate (first one) + const signingCert = certificates[0]; + + // Verify PKCS#7 signature + const contentBuf = forge.util.createBuffer(originalContent); + + try { + p7.verify({ authenticatedAttributes: true }); + + // Also verify the content matches + const signerInfos = p7.signerInfos; + const signerInfo = signerInfos?.[0]; + if (signerInfo) { + const md = forge.md.sha256.create(); + md.update(contentBuf.getBytes()); + const digest = md.digest().getBytes(); + + // Find the message digest attribute + let messageDigest = null; + for (const attr of signerInfo.authenticatedAttributes) { + if (attr.type === forge.pki.oids.messageDigest) { + messageDigest = attr.value; + break; + } + } + + if (!messageDigest || messageDigest !== digest) { + return { status: "unsigned" }; + } + } + } catch (error) { + return { status: "unsigned" }; + } + + // Convert forge certificate to PEM for OS verification + const certPem = forge.pki.certificateToPem(signingCert); + const intermediatePems = certificates + .slice(1) + .map((cert) => Buffer.from(forge.pki.certificateToPem(cert))); + + // Verify certificate chain against OS trust store + const chainValid = await verifyCertificateChain( + Buffer.from(certPem), + intermediatePems, + ); + + if (!chainValid) { + // Signature is valid but certificate is not trusted + return { status: "unsigned" }; + } + + // Extract certificate info + const isSelfSigned = + signingCert.issuer.getField("CN")?.value === + signingCert.subject.getField("CN")?.value; + + return { + status: isSelfSigned ? "self-signed" : "signed", + publisher: signingCert.subject.getField("CN")?.value || "Unknown", + issuer: signingCert.issuer.getField("CN")?.value || "Unknown", + valid_from: signingCert.validity.notBefore.toISOString(), + valid_to: signingCert.validity.notAfter.toISOString(), + fingerprint: forge.md.sha256 + .create() + .update( + forge.asn1.toDer(forge.pki.certificateToAsn1(signingCert)).getBytes(), + ) + .digest() + .toHex(), + }; + } catch (error) { + throw new Error(`Failed to verify DXT file: ${error}`); + } +} + +/** + * Creates a signature block buffer with PKCS#7 signature + */ +function createSignatureBlock(pkcs7Signature: Buffer): Buffer { + const parts: Buffer[] = []; + + // Header + parts.push(Buffer.from(SIGNATURE_HEADER, "utf-8")); + + // PKCS#7 signature length and data + const sigLengthBuffer = Buffer.alloc(4); + sigLengthBuffer.writeUInt32LE(pkcs7Signature.length, 0); + parts.push(sigLengthBuffer); + parts.push(pkcs7Signature); + + // Footer + parts.push(Buffer.from(SIGNATURE_FOOTER, "utf-8")); + + return Buffer.concat(parts); +} + +/** + * Extracts the signature block from a signed DXT file + */ +function extractSignatureBlock(fileContent: Buffer): { + originalContent: Buffer; + pkcs7Signature?: Buffer; +} { + // Look for signature footer at the end + const footerBytes = Buffer.from(SIGNATURE_FOOTER, "utf-8"); + const footerIndex = fileContent.lastIndexOf(footerBytes); + + if (footerIndex === -1) { + return { originalContent: fileContent }; + } + + // Look for signature header before footer + const headerBytes = Buffer.from(SIGNATURE_HEADER, "utf-8"); + let headerIndex = -1; + + // Search backwards from footer + for (let i = footerIndex - 1; i >= 0; i--) { + if (fileContent.slice(i, i + headerBytes.length).equals(headerBytes)) { + headerIndex = i; + break; + } + } + + if (headerIndex === -1) { + return { originalContent: fileContent }; + } + + // Extract original content (everything before signature block) + const originalContent = fileContent.slice(0, headerIndex); + + // Parse signature block + let offset = headerIndex + headerBytes.length; + + try { + // Read PKCS#7 signature length + const sigLength = fileContent.readUInt32LE(offset); + offset += 4; + + // Read PKCS#7 signature + const pkcs7Signature = fileContent.slice(offset, offset + sigLength); + + return { + originalContent, + pkcs7Signature, + }; + } catch { + return { originalContent: fileContent }; + } +} + +/** + * Verifies certificate chain against OS trust store + */ +export async function verifyCertificateChain( + certificate: Buffer, + intermediates?: Buffer[], +): Promise { + let tempDir: string | null = null; + + try { + tempDir = await mkdtemp(join(tmpdir(), "dxt-verify-")); + const certChainPath = join(tempDir, "chain.pem"); + const certChain = [certificate, ...(intermediates || [])].join("\n"); + await writeFile(certChainPath, certChain); + + // Platform-specific verification + if (process.platform === "darwin") { + try { + await execFileAsync("security", [ + "verify-cert", + "-c", + certChainPath, + "-p", + "codeSign", + ]); + return true; + } catch (error) { + return false; + } + } else if (process.platform === "win32") { + const psCommand = ` + $ErrorActionPreference = 'Stop' + $certCollection = New-Object System.Security.Cryptography.X509Certificates.X509Certificate2Collection + $certCollection.Import('${certChainPath}') + + if ($certCollection.Count -eq 0) { + Write-Error 'No certificates found' + exit 1 + } + + $leafCert = $certCollection[0] + $chain = New-Object System.Security.Cryptography.X509Certificates.X509Chain + + # Enable revocation checking + $chain.ChainPolicy.RevocationMode = 'Online' + $chain.ChainPolicy.RevocationFlag = 'EntireChain' + $chain.ChainPolicy.UrlRetrievalTimeout = New-TimeSpan -Seconds 30 + + # Add code signing application policy + $codeSignOid = New-Object System.Security.Cryptography.Oid '1.3.6.1.5.5.7.3.3' + $chain.ChainPolicy.ApplicationPolicy.Add($codeSignOid) + + # Add intermediate certificates to extra store + for ($i = 1; $i -lt $certCollection.Count; $i++) { + [void]$chain.ChainPolicy.ExtraStore.Add($certCollection[$i]) + } + + # Build and validate chain + $result = $chain.Build($leafCert) + + if ($result) { + 'Valid' + } else { + $chain.ChainStatus | ForEach-Object { + Write-Error "$($_.Status): $($_.StatusInformation)" + } + exit 1 + } + `.trim(); + + const { stdout } = await execFileAsync("powershell.exe", [ + "-NoProfile", + "-NonInteractive", + "-Command", + psCommand, + ]); + + return stdout.includes("Valid"); + } else { + // Linux: Use openssl + try { + await execFileAsync("openssl", [ + "verify", + "-purpose", + "codesigning", + "-CApath", + "/etc/ssl/certs", + certChainPath, + ]); + return true; + } catch (error) { + return false; + } + } + } catch (error) { + return false; + } finally { + if (tempDir) { + try { + await rm(tempDir, { recursive: true, force: true }); + } catch { + // Ignore cleanup errors + } + } + } +} + +/** + * Removes signature from a DXT file + */ +export function unsignDxtFile(dxtPath: string): void { + const fileContent = readFileSync(dxtPath); + const { originalContent } = extractSignatureBlock(fileContent); + writeFileSync(dxtPath, originalContent); +} diff --git a/src/node/validate.ts b/src/node/validate.ts new file mode 100644 index 0000000..09afa7e --- /dev/null +++ b/src/node/validate.ts @@ -0,0 +1,52 @@ +import { existsSync, readFileSync, statSync } from "fs"; +import { join, resolve } from "path"; + +import { DxtManifestSchema } from "../schemas.js"; + +export function validateManifest(inputPath: string): boolean { + try { + const resolvedPath = resolve(inputPath); + let manifestPath = resolvedPath; + + // If input is a directory, look for manifest.json inside it + if (existsSync(resolvedPath) && statSync(resolvedPath).isDirectory()) { + manifestPath = join(resolvedPath, "manifest.json"); + } + + const manifestContent = readFileSync(manifestPath, "utf-8"); + const manifestData = JSON.parse(manifestContent); + + const result = DxtManifestSchema.safeParse(manifestData); + + if (result.success) { + console.log("Manifest is valid!"); + return true; + } else { + console.log("ERROR: Manifest validation failed:\n"); + result.error.issues.forEach((issue) => { + const path = issue.path.join("."); + console.log(` - ${path ? `${path}: ` : ""}${issue.message}`); + }); + return false; + } + } catch (error) { + if (error instanceof Error) { + if (error.message.includes("ENOENT")) { + console.error(`ERROR: File not found: ${inputPath}`); + if ( + existsSync(resolve(inputPath)) && + statSync(resolve(inputPath)).isDirectory() + ) { + console.error(` (No manifest.json found in directory)`); + } + } else if (error.message.includes("JSON")) { + console.error(`ERROR: Invalid JSON in manifest file: ${error.message}`); + } else { + console.error(`ERROR: Error reading manifest: ${error.message}`); + } + } else { + console.error("ERROR: Unknown error occurred"); + } + return false; + } +} diff --git a/src/schemas.ts b/src/schemas.ts new file mode 100644 index 0000000..8c42091 --- /dev/null +++ b/src/schemas.ts @@ -0,0 +1,101 @@ +import { z } from "zod"; + +export const McpServerConfigSchema = z.object({ + command: z.string(), + args: z.array(z.string()).optional(), + env: z.record(z.string()).optional(), +}); + +export const DxtManifestAuthorSchema = z.object({ + name: z.string(), + email: z.string().email().optional(), + url: z.string().url().optional(), +}); + +export const DxtManifestRepositorySchema = z.object({ + type: z.string(), + url: z.string().url(), +}); + +export const DxtManifestPlatformOverrideSchema = + McpServerConfigSchema.partial(); + +export const DxtManifestMcpConfigSchema = McpServerConfigSchema.extend({ + platform_overrides: z + .record(z.string(), DxtManifestPlatformOverrideSchema) + .optional(), +}); + +export const DxtManifestServerSchema = z.object({ + type: z.enum(["python", "node", "binary"]), + entry_point: z.string(), + mcp_config: DxtManifestMcpConfigSchema, +}); + +export const DxtManifestCompatibilitySchema = z + .object({ + claude_desktop: z.string().optional(), + platforms: z.array(z.enum(["darwin", "win32", "linux"])).optional(), + runtimes: z + .object({ + python: z.string().optional(), + node: z.string().optional(), + }) + .optional(), + }) + .passthrough(); + +export const DxtManifestToolSchema = z.object({ + name: z.string(), + description: z.string().optional(), +}); + +export const DxtManifestPromptSchema = z.object({ + name: z.string(), + description: z.string().optional(), + arguments: z.array(z.string()).optional(), + text: z.string(), +}); + +export const DxtUserConfigurationOptionSchema = z.object({ + type: z.enum(["string", "number", "boolean", "directory", "file"]), + title: z.string(), + description: z.string(), + required: z.boolean().optional(), + default: z + .union([z.string(), z.number(), z.boolean(), z.array(z.string())]) + .optional(), + multiple: z.boolean().optional(), + sensitive: z.boolean().optional(), + min: z.number().optional(), + max: z.number().optional(), +}); + +export const DxtUserConfigValuesSchema = z.record( + z.union([z.string(), z.number(), z.boolean(), z.array(z.string())]), +); + +export const DxtManifestSchema = z.object({ + dxt_version: z.string(), + name: z.string(), + display_name: z.string().optional(), + version: z.string(), + description: z.string(), + long_description: z.string().optional(), + author: DxtManifestAuthorSchema, + repository: DxtManifestRepositorySchema.optional(), + homepage: z.string().url().optional(), + documentation: z.string().url().optional(), + support: z.string().url().optional(), + icon: z.string().optional(), + screenshots: z.array(z.string()).optional(), + server: DxtManifestServerSchema, + tools: z.array(DxtManifestToolSchema).optional(), + tools_generated: z.boolean().optional(), + prompts: z.array(DxtManifestPromptSchema).optional(), + prompts_generated: z.boolean().optional(), + keywords: z.array(z.string()).optional(), + license: z.string().optional(), + compatibility: DxtManifestCompatibilitySchema.optional(), + user_config: z.record(DxtUserConfigurationOptionSchema).optional(), +}); diff --git a/src/shared/config.ts b/src/shared/config.ts new file mode 100644 index 0000000..32cfc7a --- /dev/null +++ b/src/shared/config.ts @@ -0,0 +1,217 @@ +import type { + DxtManifest, + DxtUserConfigValues, + Logger, + McpServerConfig, +} from "../types"; + +/** + * This file contains utility functions for handling DXT configuration, + * including variable replacement and MCP server configuration generation. + */ + +/** + * Recursively replaces variables in any value. Handles strings, arrays, and objects. + * + * @param value The value to process + * @param variables Object containing variable replacements + * @returns The processed value with all variables replaced + */ +export function replaceVariables( + value: unknown, + variables: Record, +): unknown { + if (typeof value === "string") { + let result = value; + + // Replace all variables in the string + for (const [key, replacement] of Object.entries(variables)) { + const pattern = new RegExp(`\\$\\{${key}\\}`, "g"); + + // Check if this pattern actually exists in the string + if (result.match(pattern)) { + if (Array.isArray(replacement)) { + console.warn( + `Cannot replace ${key} with array value in string context: "${value}"`, + { key, replacement }, + ); + } else { + result = result.replace(pattern, replacement); + } + } + } + + return result; + } else if (Array.isArray(value)) { + // For arrays, we need to handle special case of array expansion + const result: unknown[] = []; + + for (const item of value) { + if ( + typeof item === "string" && + item.match(/^\$\{user_config\.[^}]+\}$/) + ) { + // This is a user config variable that might expand to multiple values + const varName = item.match(/^\$\{([^}]+)\}$/)?.[1]; + if (varName && variables[varName]) { + const replacement = variables[varName]; + if (Array.isArray(replacement)) { + // Expand array inline + result.push(...replacement); + } else { + result.push(replacement); + } + } else { + // Variable not found, keep original + result.push(item); + } + } else { + // Recursively process non-variable items + result.push(replaceVariables(item, variables)); + } + } + + return result; + } else if (value && typeof value === "object") { + const result: Record = {}; + for (const [key, val] of Object.entries(value)) { + result[key] = replaceVariables(val, variables); + } + + return result; + } + + return value; +} + +interface GetMcpConfigForManifestOptions { + manifest: DxtManifest; + extensionPath: string; + systemDirs: Record; + userConfig: DxtUserConfigValues; + pathSeparator: string; + logger?: Logger; +} + +export async function getMcpConfigForManifest( + options: GetMcpConfigForManifestOptions, +): Promise { + const { + manifest, + extensionPath, + systemDirs, + userConfig, + pathSeparator, + logger, + } = options; + const baseConfig = manifest.server?.mcp_config; + if (!baseConfig) { + return undefined; + } + + let result: McpServerConfig = { + ...baseConfig, + }; + + if (baseConfig.platform_overrides) { + if (process.platform in baseConfig.platform_overrides) { + const platformConfig = baseConfig.platform_overrides[process.platform]; + + result.command = platformConfig.command || result.command; + result.args = platformConfig.args || result.args; + result.env = platformConfig.env || result.env; + } + } + + // Check if required configuration is missing + if (hasRequiredConfigMissing({ manifest, userConfig })) { + logger?.warn( + `Extension ${manifest.name} has missing required configuration, skipping MCP config`, + ); + return undefined; + } + + const variables: Record = { + __dirname: extensionPath, + pathSeparator, + "/": pathSeparator, + ...systemDirs, + }; + + // Build merged configuration from defaults and user settings + const mergedConfig: Record = {}; + + // First, add defaults from manifest + if (manifest.user_config) { + for (const [key, configOption] of Object.entries(manifest.user_config)) { + if (configOption.default !== undefined) { + mergedConfig[key] = configOption.default; + } + } + } + + // Then, override with user settings + if (userConfig) { + Object.assign(mergedConfig, userConfig); + } + + // Add merged configuration variables for substitution + for (const [key, value] of Object.entries(mergedConfig)) { + // Convert user config to the format expected by variable substitution + const userConfigKey = `user_config.${key}`; + + if (Array.isArray(value)) { + // Keep arrays as arrays for proper expansion + variables[userConfigKey] = value.map(String); + } else if (typeof value === "boolean") { + // Convert booleans to "true"/"false" strings as per spec + variables[userConfigKey] = value ? "true" : "false"; + } else { + // Convert other types to strings + variables[userConfigKey] = String(value); + } + } + + // Replace all variables in the config + result = replaceVariables(result, variables) as McpServerConfig; + + return result; +} + +interface HasRequiredConfigMissingOptions { + manifest: DxtManifest; + userConfig?: DxtUserConfigValues; +} + +/** + * Check if an extension has missing required configuration + * @param manifest The extension manifest + * @param userConfig The user configuration + * @returns true if required configuration is missing + */ +export function hasRequiredConfigMissing({ + manifest, + userConfig, +}: HasRequiredConfigMissingOptions): boolean { + if (!manifest.user_config) { + return false; + } + + const config = userConfig || {}; + + for (const [key, configOption] of Object.entries(manifest.user_config)) { + if (configOption.required) { + const value = config[key]; + if ( + value === undefined || + value === null || + value === "" || + (Array.isArray(value) && value.length === 0) + ) { + return true; + } + } + } + + return false; +} diff --git a/src/shared/log.ts b/src/shared/log.ts new file mode 100644 index 0000000..b644895 --- /dev/null +++ b/src/shared/log.ts @@ -0,0 +1,33 @@ +interface LoggerOptions { + silent?: boolean; +} + +export function getLogger({ silent = false }: LoggerOptions = {}) { + return { + log: (...args: unknown[]) => { + if (!silent) { + console.log(...args); + } + }, + error: (...args: unknown[]) => { + if (!silent) { + console.error(...args); + } + }, + warn: (...args: unknown[]) => { + if (!silent) { + console.warn(...args); + } + }, + info: (...args: unknown[]) => { + if (!silent) { + console.info(...args); + } + }, + debug: (...args: unknown[]) => { + if (!silent) { + console.debug(...args); + } + }, + }; +} diff --git a/src/types.ts b/src/types.ts new file mode 100644 index 0000000..8a6f908 --- /dev/null +++ b/src/types.ts @@ -0,0 +1,64 @@ +import type { z } from "zod"; + +import type { + DxtManifestAuthorSchema, + DxtManifestCompatibilitySchema, + DxtManifestMcpConfigSchema, + DxtManifestPlatformOverrideSchema, + DxtManifestPromptSchema, + DxtManifestRepositorySchema, + DxtManifestSchema, + DxtManifestServerSchema, + DxtManifestToolSchema, + DxtUserConfigurationOptionSchema, + DxtUserConfigValuesSchema, + McpServerConfigSchema, +} from "./schemas.js"; + +export type McpServerConfig = z.infer; + +export type DxtManifestAuthor = z.infer; + +export type DxtManifestRepository = z.infer; + +export type DxtManifestPlatformOverride = z.infer< + typeof DxtManifestPlatformOverrideSchema +>; + +export type DxtManifestMcpConfig = z.infer; + +export type DxtManifestServer = z.infer; + +export type DxtManifestCompatibility = z.infer< + typeof DxtManifestCompatibilitySchema +>; + +export type DxtManifestTool = z.infer; + +export type DxtManifestPrompt = z.infer; + +export type DxtUserConfigurationOption = z.infer< + typeof DxtUserConfigurationOptionSchema +>; + +export type DxtUserConfigValues = z.infer; + +export type DxtManifest = z.infer; + +/** + * Information about a DXT package signature + */ +export interface DxtSignatureInfo { + status: "signed" | "unsigned" | "self-signed"; + publisher?: string; + issuer?: string; + valid_from?: string; + valid_to?: string; + fingerprint?: string; +} + +export interface Logger { + log: (...args: unknown[]) => void; + error: (...args: unknown[]) => void; + warn: (...args: unknown[]) => void; +} diff --git a/test/cli.test.ts b/test/cli.test.ts new file mode 100644 index 0000000..e059aae --- /dev/null +++ b/test/cli.test.ts @@ -0,0 +1,80 @@ +import { execSync } from "node:child_process"; +import fs from "node:fs"; +import { join } from "node:path"; + +interface ExecSyncError extends Error { + stdout: Buffer; + stderr: Buffer; + status: number | null; + signal: string | null; +} + +describe("DXT CLI", () => { + const cliPath = join(__dirname, "../dist/cli/cli.js"); + const validManifestPath = join(__dirname, "valid-manifest.json"); + const invalidManifestPath = join(__dirname, "invalid-manifest.json"); + + beforeAll(() => { + // Ensure the CLI is built + execSync("yarn build", { cwd: join(__dirname, "..") }); + }); + + it("should validate a valid manifest", () => { + const result = execSync(`node ${cliPath} validate ${validManifestPath}`, { + encoding: "utf-8", + }); + expect(result).toContain("Manifest is valid!"); + }); + + it("should reject an invalid manifest", () => { + expect(() => { + execSync(`node ${cliPath} validate ${invalidManifestPath}`, { + encoding: "utf-8", + }); + }).toThrow(); + }); + + it("should show usage when no arguments provided", () => { + try { + execSync(`node ${cliPath}`, { encoding: "utf-8", stdio: "pipe" }); + } catch (error) { + // Commander outputs help to stderr when no command is provided + const execError = error as ExecSyncError; + expect(execError.stderr.toString()).toContain( + "Usage: dxt [options] [command]", + ); + } + }); + + it("should handle non-existent files", () => { + try { + execSync(`node ${cliPath} validate /non/existent/file.json`, { + encoding: "utf-8", + stdio: "pipe", + }); + fail("Should have thrown an error"); + } catch (error) { + const execError = error as ExecSyncError; + expect(execError.stderr.toString()).toContain("ERROR: File not found"); + } + }); + + it("should handle invalid JSON", () => { + const invalidJsonPath = join(__dirname, "invalid-json.json"); + fs.writeFileSync(invalidJsonPath, "{ invalid json }"); + + try { + execSync(`node ${cliPath} validate ${invalidJsonPath}`, { + encoding: "utf-8", + stdio: "pipe", + }); + fail("Should have thrown an error"); + } catch (error) { + const execError = error as ExecSyncError; + expect(execError.stderr.toString()).toContain("ERROR: Invalid JSON"); + } + + // Clean up + fs.unlinkSync(invalidJsonPath); + }); +}); diff --git a/test/config.test.ts b/test/config.test.ts new file mode 100644 index 0000000..da70ea2 --- /dev/null +++ b/test/config.test.ts @@ -0,0 +1,483 @@ +import { + getMcpConfigForManifest, + hasRequiredConfigMissing, + replaceVariables, +} from "../src/shared/config"; +import type { DxtManifest, Logger } from "../src/types"; + +describe("replaceVariables", () => { + it("should replace variables in strings", () => { + const result = replaceVariables("Hello ${name}!", { name: "World" }); + expect(result).toBe("Hello World!"); + }); + + it("should replace multiple variables in strings", () => { + const result = replaceVariables("${greeting} ${name}!", { + greeting: "Hello", + name: "World", + }); + expect(result).toBe("Hello World!"); + }); + + it("should warn and not replace arrays in string context", () => { + const consoleWarnSpy = jest.spyOn(console, "warn").mockImplementation(); + const result = replaceVariables("Hello ${names}!", { + names: ["Alice", "Bob"], + }); + expect(result).toBe("Hello ${names}!"); + expect(consoleWarnSpy).toHaveBeenCalled(); + consoleWarnSpy.mockRestore(); + }); + + it("should replace variables in objects", () => { + const result = replaceVariables( + { message: "Hello ${name}!" }, + { name: "World" }, + ); + expect(result).toEqual({ message: "Hello World!" }); + }); + + it("should handle user config variables in arrays with string expansion", () => { + const result = replaceVariables(["${user_config.path}"], { + "user_config.path": "/some/path", + }); + expect(result).toEqual(["/some/path"]); + }); + + it("should handle user config variables in arrays with array expansion", () => { + const result = replaceVariables(["${user_config.paths}"], { + "user_config.paths": ["/path1", "/path2"], + }); + expect(result).toEqual(["/path1", "/path2"]); + }); + + it("should recursively process arrays", () => { + const result = replaceVariables(["Hello ${name}!", "Goodbye ${name}!"], { + name: "World", + }); + expect(result).toEqual(["Hello World!", "Goodbye World!"]); + }); + + it("should handle mixed arrays with variable expansion", () => { + const result = replaceVariables(["start", "${user_config.items}", "end"], { + "user_config.items": ["item1", "item2"], + }); + expect(result).toEqual(["start", "item1", "item2", "end"]); + }); + + it("should return primitive values unchanged", () => { + expect(replaceVariables(42, {})).toBe(42); + expect(replaceVariables(true, {})).toBe(true); + expect(replaceVariables(null, {})).toBe(null); + }); + + it("should handle undefined variables by keeping them as-is", () => { + const result = replaceVariables("Hello ${unknown}!", {}); + expect(result).toBe("Hello ${unknown}!"); + }); +}); + +describe("getMcpConfigForManifest", () => { + const mockLogger: Logger = { + log: jest.fn(), + error: jest.fn(), + warn: jest.fn(), + }; + + const mockSystemDirs = { + home: "/home/user", + data: "/data", + }; + + const baseManifest: DxtManifest = { + dxt_version: "1.0.0", + name: "test-extension", + version: "1.0.0", + description: "Test extension", + author: { name: "Test Author" }, + server: { + type: "node", + entry_point: "server.js", + mcp_config: { + command: "node", + args: ["server.js", "${__dirname}"], + }, + }, + compatibility: { claude_desktop: "0.1.0" }, + }; + + beforeEach(() => { + jest.clearAllMocks(); + }); + + it("should return undefined when manifest has no mcp_config", async () => { + const manifest = { + ...baseManifest, + server: undefined, + } as unknown as DxtManifest; + + const result = await getMcpConfigForManifest({ + manifest, + extensionPath: "/ext/path", + systemDirs: mockSystemDirs, + userConfig: {}, + pathSeparator: "/", + logger: mockLogger, + }); + + expect(result).toBeUndefined(); + }); + + it("should return undefined when required config is missing", async () => { + const manifest: DxtManifest = { + ...baseManifest, + user_config: { + apiKey: { + type: "string", + title: "API Key", + description: "API Key", + required: true, + }, + }, + }; + + const result = await getMcpConfigForManifest({ + manifest, + extensionPath: "/ext/path", + systemDirs: mockSystemDirs, + userConfig: {}, + pathSeparator: "/", + logger: mockLogger, + }); + + expect(result).toBeUndefined(); + expect(mockLogger.warn).toHaveBeenCalled(); + }); + + it("should replace variables in basic config", async () => { + const result = await getMcpConfigForManifest({ + manifest: baseManifest, + extensionPath: "/ext/path", + systemDirs: mockSystemDirs, + userConfig: {}, + pathSeparator: "/", + logger: mockLogger, + }); + + expect(result).toEqual({ + command: "node", + args: ["server.js", "/ext/path"], + }); + }); + + it("should apply platform overrides", async () => { + const manifest: DxtManifest = { + ...baseManifest, + server: { + type: "node", + entry_point: "server.js", + mcp_config: { + command: "default-command", + args: ["default"], + platform_overrides: { + [process.platform]: { + command: "platform-command", + args: ["platform-specific"], + }, + }, + }, + }, + }; + + const result = await getMcpConfigForManifest({ + manifest, + extensionPath: "/ext/path", + systemDirs: mockSystemDirs, + userConfig: {}, + pathSeparator: "/", + logger: mockLogger, + }); + + expect(result?.command).toBe("platform-command"); + expect(result?.args).toEqual(["platform-specific"]); + }); + + it("should handle user config variable replacement with defaults", async () => { + const manifest: DxtManifest = { + ...baseManifest, + user_config: { + port: { + type: "number", + title: "Port Number", + description: "Port number", + default: 8080, + }, + }, + server: { + type: "node", + entry_point: "server.js", + mcp_config: { + command: "node", + args: ["server.js", "--port=${user_config.port}"], + }, + }, + }; + + const result = await getMcpConfigForManifest({ + manifest, + extensionPath: "/ext/path", + systemDirs: mockSystemDirs, + userConfig: {}, + pathSeparator: "/", + logger: mockLogger, + }); + + expect(result?.args).toEqual(["server.js", "--port=8080"]); + }); + + it("should handle user config variable replacement with user values", async () => { + const manifest: DxtManifest = { + ...baseManifest, + user_config: { + paths: { + type: "string", + title: "File Paths", + description: "File paths", + default: ["/default"], + multiple: true, + }, + }, + server: { + type: "node", + entry_point: "server.js", + mcp_config: { + command: "node", + args: ["server.js", "${user_config.paths}"], + }, + }, + }; + + const result = await getMcpConfigForManifest({ + manifest, + extensionPath: "/ext/path", + systemDirs: mockSystemDirs, + userConfig: { paths: ["/user/path1", "/user/path2"] }, + pathSeparator: "/", + logger: mockLogger, + }); + + expect(result?.args).toEqual(["server.js", "/user/path1", "/user/path2"]); + }); + + it("should convert boolean user config values to strings", async () => { + const manifest: DxtManifest = { + ...baseManifest, + user_config: { + verbose: { + type: "boolean", + title: "Verbose Mode", + description: "Verbose output", + default: false, + }, + }, + server: { + type: "node", + entry_point: "server.js", + mcp_config: { + command: "node", + args: ["server.js", "--verbose=${user_config.verbose}"], + }, + }, + }; + + const result = await getMcpConfigForManifest({ + manifest, + extensionPath: "/ext/path", + systemDirs: mockSystemDirs, + userConfig: { verbose: true }, + pathSeparator: "/", + logger: mockLogger, + }); + + expect(result?.args).toEqual(["server.js", "--verbose=true"]); + }); +}); + +describe("hasRequiredConfigMissing", () => { + const baseManifest: DxtManifest = { + dxt_version: "1.0.0", + name: "test-extension", + version: "1.0.0", + description: "Test extension", + author: { name: "Test Author" }, + server: { + type: "node", + entry_point: "server.js", + mcp_config: { + command: "node", + args: ["server.js"], + }, + }, + }; + + it("should return false when manifest has no user_config", () => { + const result = hasRequiredConfigMissing({ + manifest: baseManifest, + userConfig: {}, + }); + expect(result).toBe(false); + }); + + it("should return false when no config fields are required", () => { + const manifest: DxtManifest = { + ...baseManifest, + user_config: { + port: { + type: "number", + title: "Port", + description: "Port number", + required: false, + }, + }, + }; + + const result = hasRequiredConfigMissing({ + manifest, + userConfig: {}, + }); + expect(result).toBe(false); + }); + + it("should return false when required config is provided", () => { + const manifest: DxtManifest = { + ...baseManifest, + user_config: { + apiKey: { + type: "string", + title: "API Key", + description: "API Key", + required: true, + }, + }, + }; + + const result = hasRequiredConfigMissing({ + manifest, + userConfig: { apiKey: "test-key" }, + }); + expect(result).toBe(false); + }); + + it("should return true when required config is undefined", () => { + const manifest: DxtManifest = { + ...baseManifest, + user_config: { + apiKey: { + type: "string", + title: "API Key", + description: "API Key", + required: true, + }, + }, + }; + + const result = hasRequiredConfigMissing({ + manifest, + userConfig: {}, + }); + expect(result).toBe(true); + }); + + it("should return true when required config is empty string", () => { + const manifest: DxtManifest = { + ...baseManifest, + user_config: { + apiKey: { + type: "string", + title: "API Key", + description: "API Key", + required: true, + }, + }, + }; + + const result = hasRequiredConfigMissing({ + manifest, + userConfig: { apiKey: "" }, + }); + expect(result).toBe(true); + }); + + it("should return true when required config is empty array", () => { + const manifest: DxtManifest = { + ...baseManifest, + user_config: { + paths: { + type: "string", + title: "Paths", + description: "File paths", + required: true, + multiple: true, + }, + }, + }; + + const result = hasRequiredConfigMissing({ + manifest, + userConfig: { paths: [] }, + }); + expect(result).toBe(true); + }); + + it("should return false when no user config is provided but nothing is required", () => { + const result = hasRequiredConfigMissing({ + manifest: baseManifest, + // userConfig not provided + }); + expect(result).toBe(false); + }); + + it("should handle multiple required config fields", () => { + const manifest: DxtManifest = { + ...baseManifest, + user_config: { + apiKey: { + type: "string", + title: "API Key", + description: "API Key", + required: true, + }, + database: { + type: "string", + title: "Database", + description: "Database connection", + required: true, + }, + port: { + type: "number", + title: "Port", + description: "Port number", + required: false, + }, + }, + }; + + const resultMissingBoth = hasRequiredConfigMissing({ + manifest, + userConfig: {}, + }); + expect(resultMissingBoth).toBe(true); + + const resultMissingOne = hasRequiredConfigMissing({ + manifest, + userConfig: { apiKey: "test-key" }, + }); + expect(resultMissingOne).toBe(true); + + const resultHasBoth = hasRequiredConfigMissing({ + manifest, + userConfig: { apiKey: "test-key", database: "test-db" }, + }); + expect(resultHasBoth).toBe(false); + }); +}); diff --git a/test/dxtignore.test.ts b/test/dxtignore.test.ts new file mode 100644 index 0000000..f5ebe4c --- /dev/null +++ b/test/dxtignore.test.ts @@ -0,0 +1,261 @@ +import * as fs from "fs"; +import * as os from "os"; +import * as path from "path"; + +import { + getAllFiles, + readDxtIgnorePatterns, + shouldExclude, +} from "../src/node/files.js"; + +describe("DxtIgnore functionality", () => { + let tempDir: string; + let dxtIgnorePath: string; + + beforeEach(() => { + // Create a temp directory for each test + tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "dxt-test-")); + dxtIgnorePath = path.join(tempDir, ".dxtignore"); + }); + + afterEach(() => { + // Clean up temp directory after each test + fs.rmSync(tempDir, { recursive: true, force: true }); + }); + + describe("readDxtIgnorePatterns", () => { + it("should return empty array when .dxtignore doesn't exist", () => { + const patterns = readDxtIgnorePatterns(tempDir); + expect(patterns).toEqual([]); + }); + + it("should read patterns from .dxtignore file", () => { + const content = `*.log +node_modules/ +temp/ +.env`; + fs.writeFileSync(dxtIgnorePath, content); + + const patterns = readDxtIgnorePatterns(tempDir); + expect(patterns).toEqual(["*.log", "node_modules/", "temp/", ".env"]); + }); + + it("should ignore empty lines and comments", () => { + const content = `# Comment line +*.log + +# Another comment +node_modules/ + +.env`; + fs.writeFileSync(dxtIgnorePath, content); + + const patterns = readDxtIgnorePatterns(tempDir); + expect(patterns).toEqual(["*.log", "node_modules/", ".env"]); + }); + + it("should trim whitespace from lines", () => { + const content = ` *.log + node_modules/ +temp/`; + fs.writeFileSync(dxtIgnorePath, content); + + const patterns = readDxtIgnorePatterns(tempDir); + expect(patterns).toEqual(["*.log", "node_modules/", "temp/"]); + }); + + it("should handle Windows line endings", () => { + const content = `*.log\r\nnode_modules/\r\ntemp/`; + fs.writeFileSync(dxtIgnorePath, content); + + const patterns = readDxtIgnorePatterns(tempDir); + expect(patterns).toEqual(["*.log", "node_modules/", "temp/"]); + }); + + it("should return empty array if file cannot be read", () => { + const content = "*.log"; + fs.writeFileSync(dxtIgnorePath, content); + fs.chmodSync(dxtIgnorePath, 0); // Make file unreadable + + const patterns = readDxtIgnorePatterns(tempDir); + expect(patterns).toEqual([]); + + // Restore permissions for cleanup + fs.chmodSync(dxtIgnorePath, 0o644); + }); + }); + + describe("shouldExclude with additional patterns", () => { + it("should exclude files matching additional patterns", () => { + const additionalPatterns = ["*.test.js", "coverage/"]; + + expect(shouldExclude("test.test.js", additionalPatterns)).toBe(true); + expect(shouldExclude("coverage/file.txt", additionalPatterns)).toBe(true); + expect(shouldExclude("src/index.js", additionalPatterns)).toBe(false); + }); + + it("should still exclude default patterns", () => { + const additionalPatterns = ["*.test.js"]; + + // Test default pattern + expect(shouldExclude(".DS_Store", additionalPatterns)).toBe(true); + // Test additional pattern + expect(shouldExclude("test.test.js", additionalPatterns)).toBe(true); + // Test non-excluded file + expect(shouldExclude("src/index.js", additionalPatterns)).toBe(false); + }); + + it("should handle glob patterns correctly", () => { + const additionalPatterns = ["*.log", "temp/*"]; + + expect(shouldExclude("debug.log", additionalPatterns)).toBe(true); + expect(shouldExclude("temp/file.txt", additionalPatterns)).toBe(true); + expect(shouldExclude("src/main.js", additionalPatterns)).toBe(false); + }); + + it("should handle exact path matches", () => { + const additionalPatterns = ["node_modules", "dist"]; + + expect(shouldExclude("node_modules", additionalPatterns)).toBe(true); + expect(shouldExclude("dist", additionalPatterns)).toBe(true); + expect(shouldExclude("src/node_modules", additionalPatterns)).toBe(true); + expect(shouldExclude("src", additionalPatterns)).toBe(false); + }); + }); + + describe("getAllFiles with .dxtignore", () => { + let testStructure: string; + + beforeEach(() => { + // Create test directory structure + testStructure = path.join(tempDir, "test-extension"); + fs.mkdirSync(testStructure); + fs.mkdirSync(path.join(testStructure, "src")); + fs.mkdirSync(path.join(testStructure, "tests")); + fs.mkdirSync(path.join(testStructure, "coverage")); + fs.mkdirSync(path.join(testStructure, "logs")); + + // Create test files + fs.writeFileSync(path.join(testStructure, "manifest.json"), "{}"); + fs.writeFileSync( + path.join(testStructure, "src/index.js"), + "console.log('hi')", + ); + fs.writeFileSync(path.join(testStructure, "tests/test.js"), "test()"); + fs.writeFileSync( + path.join(testStructure, "coverage/report.txt"), + "coverage", + ); + fs.writeFileSync(path.join(testStructure, "logs/debug.log"), "log"); + fs.writeFileSync(path.join(testStructure, "debug.log"), "log"); + }); + + it("should exclude files matching .dxtignore patterns", () => { + // Create .dxtignore + const dxtIgnoreContent = `*.log +tests/ +coverage/`; + fs.writeFileSync( + path.join(testStructure, ".dxtignore"), + dxtIgnoreContent, + ); + + const patterns = readDxtIgnorePatterns(testStructure); + const files = getAllFiles(testStructure, testStructure, {}, patterns); + + const fileNames = Object.keys(files); + + // Should include + expect(fileNames).toContain("manifest.json"); + expect(fileNames).toContain("src/index.js"); + + // Should exclude + expect(fileNames).not.toContain("debug.log"); + expect(fileNames).not.toContain("logs/debug.log"); + expect(fileNames).not.toContain("tests/test.js"); + expect(fileNames).not.toContain("coverage/report.txt"); + expect(fileNames).not.toContain(".dxtignore"); + }); + + it("should exclude both default patterns and .dxtignore patterns", () => { + // Create .dxtignore + const dxtIgnoreContent = `tests/`; + fs.writeFileSync( + path.join(testStructure, ".dxtignore"), + dxtIgnoreContent, + ); + + // Create a .git file (default exclusion) + fs.writeFileSync(path.join(testStructure, ".gitignore"), "ignore"); + + const patterns = readDxtIgnorePatterns(testStructure); + const files = getAllFiles(testStructure, testStructure, {}, patterns); + + const fileNames = Object.keys(files); + + // Should include + expect(fileNames).toContain("manifest.json"); + expect(fileNames).toContain("src/index.js"); + + // Should exclude (from .dxtignore) + expect(fileNames).not.toContain("tests/test.js"); + + // Should exclude (from default patterns) + expect(fileNames).not.toContain(".gitignore"); + }); + + it("should work without .dxtignore file", () => { + const files = getAllFiles(testStructure, testStructure, {}, []); + const fileNames = Object.keys(files); + + // Should include all files except default exclusions + expect(fileNames).toContain("manifest.json"); + expect(fileNames).toContain("src/index.js"); + expect(fileNames).toContain("tests/test.js"); + expect(fileNames).toContain("coverage/report.txt"); + // Note: *.log files are excluded by default, so these won't be included + expect(fileNames).not.toContain("logs/debug.log"); + expect(fileNames).not.toContain("debug.log"); + }); + }); + + describe("Pattern matching edge cases", () => { + it("should handle nested directories", () => { + const additionalPatterns = ["node_modules/"]; + + expect( + shouldExclude("node_modules/package/index.js", additionalPatterns), + ).toBe(true); + expect( + shouldExclude("src/node_modules/package/index.js", additionalPatterns), + ).toBe(true); + }); + + it("should handle paths with directory patterns", () => { + const additionalPatterns = ["tests/"]; + + expect(shouldExclude("tests/unit/test.js", additionalPatterns)).toBe( + true, + ); + expect( + shouldExclude("tests/integration/test.js", additionalPatterns), + ).toBe(true); + // Note: "tests" appears anywhere in path due to current implementation + expect(shouldExclude("src/tests/test.js", additionalPatterns)).toBe(true); + // But paths without "tests" should not be excluded + expect(shouldExclude("src/main.js", additionalPatterns)).toBe(false); + }); + + it("should match patterns (implementation details)", () => { + const additionalPatterns = ["specific-file.LOG"]; + + // Test that the pattern is matched + expect(shouldExclude("specific-file.LOG", additionalPatterns)).toBe(true); + + // Test completely different file name + expect(shouldExclude("totally-different.txt", additionalPatterns)).toBe( + false, + ); + }); + }); +}); diff --git a/test/init.test.ts b/test/init.test.ts new file mode 100644 index 0000000..d01387a --- /dev/null +++ b/test/init.test.ts @@ -0,0 +1,363 @@ +import { existsSync, readFileSync } from "fs"; + +import { + buildManifest, + createMcpConfig, + getDefaultAuthorEmail, + getDefaultAuthorName, + getDefaultAuthorUrl, + getDefaultEntryPoint, + getDefaultRepositoryUrl, + readPackageJson, +} from "../src/cli/init.js"; + +// Mock the fs module +jest.mock("fs", () => ({ + existsSync: jest.fn(), + readFileSync: jest.fn(), + writeFileSync: jest.fn(), +})); + +describe("init functions", () => { + beforeEach(() => { + jest.clearAllMocks(); + }); + + describe("readPackageJson", () => { + it("should return empty object when package.json doesn't exist", () => { + (existsSync as jest.Mock).mockReturnValue(false); + const result = readPackageJson("/test/path"); + expect(result).toEqual({}); + }); + + it("should parse package.json when it exists", () => { + (existsSync as jest.Mock).mockReturnValue(true); + const mockPackageData = { name: "test-package", version: "1.0.0" }; + (readFileSync as jest.Mock).mockReturnValue( + JSON.stringify(mockPackageData), + ); + + const result = readPackageJson("/test/path"); + expect(result).toEqual(mockPackageData); + }); + + it("should return empty object when package.json is invalid", () => { + (existsSync as jest.Mock).mockReturnValue(true); + (readFileSync as jest.Mock).mockReturnValue("invalid json"); + + const result = readPackageJson("/test/path"); + expect(result).toEqual({}); + }); + }); + + describe("getDefaultAuthorName", () => { + it("should return string author when author is string", () => { + const result = getDefaultAuthorName({ author: "John Doe" }); + expect(result).toBe("John Doe"); + }); + + it("should return author.name when author is object", () => { + const result = getDefaultAuthorName({ author: { name: "John Doe" } }); + expect(result).toBe("John Doe"); + }); + + it("should return empty string when no author", () => { + const result = getDefaultAuthorName({}); + expect(result).toBe(""); + }); + }); + + describe("getDefaultAuthorEmail", () => { + it("should return author.email when author is object with email", () => { + const result = getDefaultAuthorEmail({ + author: { email: "john@example.com" }, + }); + expect(result).toBe("john@example.com"); + }); + + it("should return empty string when author is string", () => { + const result = getDefaultAuthorEmail({ author: "John Doe" }); + expect(result).toBe(""); + }); + + it("should return empty string when no email", () => { + const result = getDefaultAuthorEmail({ author: { name: "John" } }); + expect(result).toBe(""); + }); + }); + + describe("getDefaultAuthorUrl", () => { + it("should return author.url when author is object with url", () => { + const result = getDefaultAuthorUrl({ + author: { url: "https://example.com" }, + }); + expect(result).toBe("https://example.com"); + }); + + it("should return empty string when author is string", () => { + const result = getDefaultAuthorUrl({ author: "John Doe" }); + expect(result).toBe(""); + }); + + it("should return empty string when no url", () => { + const result = getDefaultAuthorUrl({ author: { name: "John" } }); + expect(result).toBe(""); + }); + }); + + describe("getDefaultRepositoryUrl", () => { + it("should return string repository when repository is string", () => { + const result = getDefaultRepositoryUrl({ + repository: "https://github.com/user/repo", + }); + expect(result).toBe("https://github.com/user/repo"); + }); + + it("should return repository.url when repository is object", () => { + const result = getDefaultRepositoryUrl({ + repository: { type: "git", url: "https://github.com/user/repo" }, + }); + expect(result).toBe("https://github.com/user/repo"); + }); + + it("should return empty string when no repository", () => { + const result = getDefaultRepositoryUrl({}); + expect(result).toBe(""); + }); + }); + + describe("createMcpConfig", () => { + it("should create node config", () => { + const result = createMcpConfig("node", "server/index.js"); + expect(result).toEqual({ + command: "node", + args: ["${__dirname}/server/index.js"], + env: {}, + }); + }); + + it("should create python config", () => { + const result = createMcpConfig("python", "server/main.py"); + expect(result).toEqual({ + command: "python", + args: ["${__dirname}/server/main.py"], + env: { + PYTHONPATH: "server/lib", + }, + }); + }); + + it("should create binary config", () => { + const result = createMcpConfig("binary", "server/my-server"); + expect(result).toEqual({ + command: "${__dirname}/server/my-server", + args: [], + env: {}, + }); + }); + }); + + describe("getDefaultEntryPoint", () => { + it("should return node default", () => { + expect(getDefaultEntryPoint("node")).toBe("server/index.js"); + }); + + it("should return python default", () => { + expect(getDefaultEntryPoint("python")).toBe("server/main.py"); + }); + + it("should return binary default", () => { + expect(getDefaultEntryPoint("binary")).toBe("server/my-server"); + }); + }); + + describe("buildManifest", () => { + it("should build minimal manifest", () => { + const manifest = buildManifest( + { + name: "test-extension", + displayName: "test-extension", + version: "1.0.0", + description: "Test description", + authorName: "John Doe", + }, + undefined, // longDescription + { + authorEmail: "", + authorUrl: "", + }, + { + homepage: "", + documentation: "", + support: "", + }, + { + icon: "", + screenshots: [], + }, + { + serverType: "node", + entryPoint: "server/index.js", + mcp_config: { + command: "node", + args: ["${__dirname}/server/index.js"], + env: {}, + }, + }, + [], // tools + false, // toolsGenerated + [], // prompts + false, // promptsGenerated + undefined, // compatibility + {}, // userConfig + { + keywords: "", + license: "", + }, + ); + + expect(manifest).toEqual({ + dxt_version: "0.1", + name: "test-extension", + version: "1.0.0", + description: "Test description", + author: { + name: "John Doe", + }, + server: { + type: "node", + entry_point: "server/index.js", + mcp_config: { + command: "node", + args: ["${__dirname}/server/index.js"], + env: {}, + }, + }, + }); + }); + + it("should include optional fields when provided", () => { + const manifest = buildManifest( + { + name: "test-extension", + displayName: "Test Extension", + version: "1.0.0", + description: "Test description", + authorName: "John Doe", + }, + "This is a detailed long description with more information.", // longDescription + { + authorEmail: "john@example.com", + authorUrl: "https://example.com", + }, + { + homepage: "https://homepage.example.com", + documentation: "https://docs.example.com", + support: "https://support.example.com", + }, + { + icon: "icon.png", + screenshots: ["screen1.png", "screen2.png"], + }, + { + serverType: "python", + entryPoint: "server/main.py", + mcp_config: { + command: "python", + args: ["server/main.py"], + env: { PYTHONPATH: "server/lib" }, + }, + }, + [ + { name: "tool1", description: "Tool 1 description" }, + { name: "tool2" }, + ], // tools + false, // toolsGenerated + [ + { + name: "analyze_code", + description: "Code analysis prompt", + text: "Analyze the following code...", + }, + ], // prompts + false, // promptsGenerated + { + claude_desktop: ">=0.4.0", + platforms: ["darwin", "linux"], + runtimes: { python: ">=3.8,<4.0" }, + }, // compatibility + { + api_key: { + type: "string", + title: "API Key", + description: "Your API key", + required: true, + sensitive: true, + }, + }, // userConfig + { + keywords: "test, extension, mcp", + license: "MIT", + repository: { type: "git", url: "https://github.com/user/repo" }, + }, + ); + + expect(manifest).toEqual({ + dxt_version: "0.1", + name: "test-extension", + display_name: "Test Extension", + version: "1.0.0", + description: "Test description", + long_description: + "This is a detailed long description with more information.", + author: { + name: "John Doe", + email: "john@example.com", + url: "https://example.com", + }, + homepage: "https://homepage.example.com", + documentation: "https://docs.example.com", + support: "https://support.example.com", + icon: "icon.png", + screenshots: ["screen1.png", "screen2.png"], + server: { + type: "python", + entry_point: "server/main.py", + mcp_config: { + command: "python", + args: ["server/main.py"], + env: { PYTHONPATH: "server/lib" }, + }, + }, + tools: [ + { name: "tool1", description: "Tool 1 description" }, + { name: "tool2" }, + ], + prompts: [ + { + name: "analyze_code", + description: "Code analysis prompt", + text: "Analyze the following code...", + }, + ], + compatibility: { + claude_desktop: ">=0.4.0", + platforms: ["darwin", "linux"], + runtimes: { python: ">=3.8,<4.0" }, + }, + user_config: { + api_key: { + type: "string", + title: "API Key", + description: "Your API key", + required: true, + sensitive: true, + }, + }, + keywords: ["test", "extension", "mcp"], + license: "MIT", + repository: { type: "git", url: "https://github.com/user/repo" }, + }); + }); + }); +}); diff --git a/test/invalid-manifest.json b/test/invalid-manifest.json new file mode 100644 index 0000000..21a2013 --- /dev/null +++ b/test/invalid-manifest.json @@ -0,0 +1,13 @@ +{ + "dxt_version": "1.0", + "name": "test-extension", + "version": "1.0.0", + "description": "A test DXT extension", + "author": { + "email": "not-a-valid-email" + }, + "server": { + "type": "invalid-type", + "entry_point": "server/index.js" + } +} diff --git a/test/schemas.test.ts b/test/schemas.test.ts new file mode 100644 index 0000000..a80ff7b --- /dev/null +++ b/test/schemas.test.ts @@ -0,0 +1,150 @@ +import { readFileSync } from "fs"; +import { join } from "path"; + +import { DxtManifestSchema } from "../src/schemas"; + +describe("DxtManifestSchema", () => { + it("should validate a valid manifest", () => { + const manifestPath = join(__dirname, "valid-manifest.json"); + const manifestContent = readFileSync(manifestPath, "utf-8"); + const manifestData = JSON.parse(manifestContent); + + const result = DxtManifestSchema.safeParse(manifestData); + + expect(result.success).toBe(true); + if (result.success) { + expect(result.data.name).toBe("test-extension"); + expect(result.data.server.type).toBe("node"); + } + }); + + it("should reject an invalid manifest", () => { + const manifestPath = join(__dirname, "invalid-manifest.json"); + const manifestContent = readFileSync(manifestPath, "utf-8"); + const manifestData = JSON.parse(manifestContent); + + const result = DxtManifestSchema.safeParse(manifestData); + + expect(result.success).toBe(false); + if (!result.success) { + const errors = result.error.issues.map((issue) => issue.path.join(".")); + expect(errors).toContain("author.name"); + expect(errors).toContain("author.email"); + expect(errors).toContain("server.type"); + expect(errors).toContain("server.mcp_config"); + } + }); + + it("should validate manifest with all optional fields", () => { + const fullManifest = { + dxt_version: "1.0", + name: "full-extension", + display_name: "Full Featured Extension", + version: "2.0.0", + description: "An extension with all features", + long_description: "This is a detailed description of the extension", + author: { + name: "Test Author", + email: "test@example.com", + url: "https://example.com", + }, + repository: { + type: "git", + url: "https://github.com/example/extension", + }, + homepage: "https://example.com/extension", + documentation: "https://docs.example.com", + support: "https://support.example.com", + icon: "icon.png", + screenshots: ["screenshot1.png", "screenshot2.png"], + server: { + type: "python", + entry_point: "main.py", + mcp_config: { + command: "python", + args: ["main.py"], + env: { PYTHONPATH: "." }, + }, + runtime_requirements: { + python: ">=3.8", + }, + }, + tools: [ + { + name: "my_tool", + description: "A useful tool", + input_schema: { type: "object" }, + }, + ], + keywords: ["test", "example"], + license: "MIT", + compatibility: { + claude_desktop: ">=1.0.0", + platforms: ["darwin", "win32"], + runtimes: { + python: ">=3.8", + node: ">=16.0.0", + }, + }, + settings: { + configurable: true, + schema: { + type: "object", + properties: {}, + }, + }, + user_config: { + api_key: { + type: "string", + title: "API Key", + description: "Your API key", + required: true, + sensitive: true, + }, + max_results: { + type: "number", + title: "Max Results", + description: "Maximum number of results", + default: 10, + min: 1, + max: 100, + }, + }, + }; + + const result = DxtManifestSchema.safeParse(fullManifest); + + expect(result.success).toBe(true); + if (result.success) { + expect(result.data.display_name).toBe("Full Featured Extension"); + expect(result.data.tools).toHaveLength(1); + expect(result.data.compatibility?.platforms).toContain("darwin"); + expect(result.data.user_config?.api_key.type).toBe("string"); + } + }); + + it("should validate server types correctly", () => { + const serverTypes = ["python", "node", "binary"]; + + serverTypes.forEach((type) => { + const manifest = { + dxt_version: "1.0", + name: "test", + version: "1.0.0", + description: "Test", + author: { name: "Test" }, + server: { + type, + entry_point: "main", + mcp_config: { + command: type === "binary" ? "./main" : type, + args: ["main"], + }, + }, + }; + + const result = DxtManifestSchema.safeParse(manifest); + expect(result.success).toBe(true); + }); + }); +}); diff --git a/test/sign.e2e.test.ts b/test/sign.e2e.test.ts new file mode 100755 index 0000000..999c039 --- /dev/null +++ b/test/sign.e2e.test.ts @@ -0,0 +1,467 @@ +/** + * End-to-end test for DXT signing and verification + * + * This test: + * 1. Creates a test DXT file + * 2. Generates a self-signed certificate for testing + * 3. Signs the DXT file + * 4. Verifies the signature + * 5. Tests various failure scenarios + */ + +import * as fs from "fs"; +import forge from "node-forge"; +import * as path from "path"; + +import { signDxtFile, unsignDxtFile, verifyDxtFile } from "../src/node/sign"; + +// Test directory +const TEST_DIR = path.join(__dirname, "test-output"); + +// Ensure test directory exists +if (!fs.existsSync(TEST_DIR)) { + fs.mkdirSync(TEST_DIR, { recursive: true }); +} + +// Test file paths +const TEST_DXT = path.join(TEST_DIR, "test.dxt"); +const SELF_SIGNED_CERT = path.join(TEST_DIR, "self-signed.crt"); +const SELF_SIGNED_KEY = path.join(TEST_DIR, "self-signed.key"); +const CA_CERT = path.join(TEST_DIR, "ca.crt"); +const CA_KEY = path.join(TEST_DIR, "ca.key"); +const SIGNED_CERT = path.join(TEST_DIR, "signed.crt"); +const SIGNED_KEY = path.join(TEST_DIR, "signed.key"); + +/** + * Generate a self-signed certificate for testing + */ +function generateSelfSignedCert() { + const keys = forge.pki.rsa.generateKeyPair(2048); + const cert = forge.pki.createCertificate(); + + cert.publicKey = keys.publicKey; + cert.serialNumber = "01"; + cert.validity.notBefore = new Date(); + cert.validity.notAfter = new Date(); + cert.validity.notAfter.setFullYear(cert.validity.notBefore.getFullYear() + 1); + + const attrs = [ + { name: "commonName", value: "Test DXT Publisher" }, + { name: "countryName", value: "US" }, + { name: "organizationName", value: "Test Org" }, + ]; + + cert.setSubject(attrs); + cert.setIssuer(attrs); + + // Add extensions + cert.setExtensions([ + { + name: "basicConstraints", + cA: false, + }, + { + name: "keyUsage", + keyCertSign: false, + digitalSignature: true, + nonRepudiation: true, + keyEncipherment: false, + dataEncipherment: false, + }, + { + name: "extKeyUsage", + codeSigning: true, + }, + ]); + + // Self-sign + cert.sign(keys.privateKey, forge.md.sha256.create()); + + // Write files + fs.writeFileSync(SELF_SIGNED_CERT, forge.pki.certificateToPem(cert)); + fs.writeFileSync(SELF_SIGNED_KEY, forge.pki.privateKeyToPem(keys.privateKey)); +} + +/** + * Generate a CA and signed certificate for testing + */ +function generateCASignedCert() { + // Generate CA + const caKeys = forge.pki.rsa.generateKeyPair(2048); + const caCert = forge.pki.createCertificate(); + + caCert.publicKey = caKeys.publicKey; + caCert.serialNumber = "01"; + caCert.validity.notBefore = new Date(); + caCert.validity.notAfter = new Date(); + caCert.validity.notAfter.setFullYear( + caCert.validity.notBefore.getFullYear() + 10, + ); + + const caAttrs = [ + { name: "commonName", value: "Test CA" }, + { name: "countryName", value: "US" }, + { name: "organizationName", value: "Test CA Org" }, + ]; + + caCert.setSubject(caAttrs); + caCert.setIssuer(caAttrs); + + caCert.setExtensions([ + { + name: "basicConstraints", + cA: true, + }, + { + name: "keyUsage", + keyCertSign: true, + digitalSignature: true, + cRLSign: true, + }, + ]); + + caCert.sign(caKeys.privateKey, forge.md.sha256.create()); + + // Generate signed certificate + const keys = forge.pki.rsa.generateKeyPair(2048); + const cert = forge.pki.createCertificate(); + + cert.publicKey = keys.publicKey; + cert.serialNumber = "02"; + cert.validity.notBefore = new Date(); + cert.validity.notAfter = new Date(); + cert.validity.notAfter.setFullYear(cert.validity.notBefore.getFullYear() + 1); + + const attrs = [ + { name: "commonName", value: "Test Publisher (CA Signed)" }, + { name: "countryName", value: "US" }, + { name: "organizationName", value: "Test Publisher Org" }, + ]; + + cert.setSubject(attrs); + cert.setIssuer(caCert.subject.attributes); + + cert.setExtensions([ + { + name: "basicConstraints", + cA: false, + }, + { + name: "keyUsage", + digitalSignature: true, + nonRepudiation: true, + }, + { + name: "extKeyUsage", + codeSigning: true, + }, + ]); + + // Sign with CA + cert.sign(caKeys.privateKey, forge.md.sha256.create()); + + // Write files + fs.writeFileSync(CA_CERT, forge.pki.certificateToPem(caCert)); + fs.writeFileSync(CA_KEY, forge.pki.privateKeyToPem(caKeys.privateKey)); + fs.writeFileSync(SIGNED_CERT, forge.pki.certificateToPem(cert)); + fs.writeFileSync(SIGNED_KEY, forge.pki.privateKeyToPem(keys.privateKey)); +} + +/** + * Create a test DXT file (just a simple ZIP) + */ +function createTestDxt() { + // Create a simple ZIP file content + // This is a minimal valid ZIP with one file + const zipContent = Buffer.from([ + 0x50, + 0x4b, + 0x03, + 0x04, // Local file header signature + 0x14, + 0x00, // Version needed + 0x00, + 0x00, // Flags + 0x00, + 0x00, // Compression method (stored) + 0x00, + 0x00, // Last mod time + 0x00, + 0x00, // Last mod date + 0x00, + 0x00, + 0x00, + 0x00, // CRC-32 + 0x0d, + 0x00, + 0x00, + 0x00, // Compressed size + 0x0d, + 0x00, + 0x00, + 0x00, // Uncompressed size + 0x0c, + 0x00, // Filename length + 0x00, + 0x00, // Extra field length + // Filename: "manifest.json" + 0x6d, + 0x61, + 0x6e, + 0x69, + 0x66, + 0x65, + 0x73, + 0x74, + 0x2e, + 0x6a, + 0x73, + 0x6f, + 0x6e, + // File content: '{"test":true}' + 0x7b, + 0x22, + 0x74, + 0x65, + 0x73, + 0x74, + 0x22, + 0x3a, + 0x74, + 0x72, + 0x75, + 0x65, + 0x7d, + // Central directory + 0x50, + 0x4b, + 0x01, + 0x02, // Central directory signature + 0x14, + 0x00, // Version made by + 0x14, + 0x00, // Version needed + 0x00, + 0x00, // Flags + 0x00, + 0x00, // Compression method + 0x00, + 0x00, // Last mod time + 0x00, + 0x00, // Last mod date + 0x00, + 0x00, + 0x00, + 0x00, // CRC-32 + 0x0d, + 0x00, + 0x00, + 0x00, // Compressed size + 0x0d, + 0x00, + 0x00, + 0x00, // Uncompressed size + 0x0c, + 0x00, // Filename length + 0x00, + 0x00, // Extra field length + 0x00, + 0x00, // File comment length + 0x00, + 0x00, // Disk number + 0x00, + 0x00, // Internal attributes + 0x00, + 0x00, + 0x00, + 0x00, // External attributes + 0x00, + 0x00, + 0x00, + 0x00, // Offset of local header + // Filename: "manifest.json" + 0x6d, + 0x61, + 0x6e, + 0x69, + 0x66, + 0x65, + 0x73, + 0x74, + 0x2e, + 0x6a, + 0x73, + 0x6f, + 0x6e, + // End of central directory + 0x50, + 0x4b, + 0x05, + 0x06, // End of central directory signature + 0x00, + 0x00, // Disk number + 0x00, + 0x00, // Start disk + 0x01, + 0x00, // Number of central directory records on this disk + 0x01, + 0x00, // Total number of central directory records + 0x3a, + 0x00, + 0x00, + 0x00, // Size of central directory + 0x34, + 0x00, + 0x00, + 0x00, // Offset of central directory + 0x00, + 0x00, // Comment length + ]); + + fs.writeFileSync(TEST_DXT, zipContent); +} + +/** + * Test signing with self-signed certificate + */ +async function testSelfSignedSigning() { + // Create a copy for this test + const testFile = path.join(TEST_DIR, "test-self-signed.dxt"); + fs.copyFileSync(TEST_DXT, testFile); + + // Sign the file + expect(() => + signDxtFile(testFile, SELF_SIGNED_CERT, SELF_SIGNED_KEY), + ).not.toThrow(); + + // Verify the signature + const result = await verifyDxtFile(testFile); + + // Self-signed certs may not be trusted by OS, so we accept either status + expect(["self-signed", "unsigned"]).toContain(result.status); + + // Clean up + fs.unlinkSync(testFile); +} + +/** + * Test signing with CA-signed certificate + */ +async function testCASignedSigning() { + // Create a copy for this test + const testFile = path.join(TEST_DIR, "test-ca-signed.dxt"); + fs.copyFileSync(TEST_DXT, testFile); + + // Sign the file with intermediate + expect(() => + signDxtFile(testFile, SIGNED_CERT, SIGNED_KEY, [CA_CERT]), + ).not.toThrow(); + + // Verify the signature + const result = await verifyDxtFile(testFile); + + // CA-signed status depends on whether test CA is trusted by OS + expect(["signed", "unsigned"]).toContain(result.status); + + // Clean up + fs.unlinkSync(testFile); +} + +/** + * Test tampering detection + */ +async function testTamperingDetection() { + // Create a copy and sign it + const testFile = path.join(TEST_DIR, "test-tampered.dxt"); + fs.copyFileSync(TEST_DXT, testFile); + signDxtFile(testFile, SELF_SIGNED_CERT, SELF_SIGNED_KEY); + + // Read the signed file + const signedContent = fs.readFileSync(testFile); + + // Tamper with the content (change a byte in the ZIP portion) + const tamperedContent = Buffer.from(signedContent); + tamperedContent[10] = (tamperedContent[10] + 1) % 256; + fs.writeFileSync(testFile, tamperedContent); + + // Try to verify - should fail + const result = await verifyDxtFile(testFile); + expect(result.status).toBe("unsigned"); + + // Clean up + fs.unlinkSync(testFile); +} + +/** + * Test unsigned file verification + */ +async function testUnsignedFile() { + const result = await verifyDxtFile(TEST_DXT); + expect(result.status).toBe("unsigned"); +} + +/** + * Test signature removal + */ +async function testSignatureRemoval() { + // Create a copy and sign it + const testFile = path.join(TEST_DIR, "test-remove-sig.dxt"); + fs.copyFileSync(TEST_DXT, testFile); + signDxtFile(testFile, SELF_SIGNED_CERT, SELF_SIGNED_KEY); + + // Verify it's signed (or at least has signature data) + await verifyDxtFile(testFile); + + // Remove signature + expect(() => unsignDxtFile(testFile)).not.toThrow(); + + // Verify it's unsigned + const afterResult = await verifyDxtFile(testFile); + expect(afterResult.status).toBe("unsigned"); + + // Clean up + fs.unlinkSync(testFile); +} + +describe("DXT Signing E2E Tests", () => { + beforeAll(() => { + // Ensure test directory exists + if (!fs.existsSync(TEST_DIR)) { + fs.mkdirSync(TEST_DIR, { recursive: true }); + } + + // Setup + generateSelfSignedCert(); + generateCASignedCert(); + createTestDxt(); + }); + + afterAll(() => { + // Cleanup + try { + fs.rmSync(TEST_DIR, { recursive: true, force: true }); + } catch (e) { + // Ignore cleanup errors + } + }); + + it("should sign and verify with self-signed certificate", async () => { + await testSelfSignedSigning(); + }); + + it("should sign and verify with CA-signed certificate", async () => { + await testCASignedSigning(); + }); + + it("should detect tampering", async () => { + await testTamperingDetection(); + }); + + it("should identify unsigned files", async () => { + await testUnsignedFile(); + }); + + it("should remove signatures", async () => { + await testSignatureRemoval(); + }); +}); diff --git a/test/valid-manifest.json b/test/valid-manifest.json new file mode 100644 index 0000000..a472aa6 --- /dev/null +++ b/test/valid-manifest.json @@ -0,0 +1,19 @@ +{ + "dxt_version": "1.0", + "name": "test-extension", + "display_name": "Test Extension", + "version": "1.0.0", + "description": "A test DXT extension", + "author": { + "name": "Test Author", + "email": "test@example.com" + }, + "server": { + "type": "node", + "entry_point": "server/index.js", + "mcp_config": { + "command": "node", + "args": ["${__dirname}/server/index.js"] + } + } +} diff --git a/tsconfig.json b/tsconfig.json new file mode 100644 index 0000000..c7cf40d --- /dev/null +++ b/tsconfig.json @@ -0,0 +1,36 @@ +{ + "$schema": "https://json.schemastore.org/tsconfig", + "display": "Default", + "compilerOptions": { + "target": "es2024", + "lib": ["ES2023"], + + "module": "es2022", + "moduleResolution": "node", + "esModuleInterop": true, + + // Path settings + "rootDir": "./src", + "outDir": "./dist", + + // Type checking + "strict": true, + "skipLibCheck": true, + "forceConsistentCasingInFileNames": true, + + // Emit settings + "declaration": true, + "noEmit": false, + "inlineSources": false, + "isolatedModules": false, + + // Other settings + "allowJs": true, + "resolveJsonModule": true, + "incremental": true, + "preserveWatchOutput": true, + "types": ["node", "jest"] + }, + "include": ["src/**/*.ts", "src/*.ts"], + "exclude": ["node_modules", "dist"] +} diff --git a/tsconfig.test.json b/tsconfig.test.json new file mode 100644 index 0000000..f85ef0c --- /dev/null +++ b/tsconfig.test.json @@ -0,0 +1,9 @@ +{ + "extends": "./tsconfig.json", + "compilerOptions": { + "noEmit": true, + "module": "es2022", + "moduleResolution": "node" + }, + "include": ["src/**/*.ts", "test/**/*.ts"] +} diff --git a/yarn.lock b/yarn.lock new file mode 100644 index 0000000..4a94d3c --- /dev/null +++ b/yarn.lock @@ -0,0 +1,4051 @@ +# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY. +# yarn lockfile v1 + + +"@ampproject/remapping@^2.2.0": + version "2.3.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@ampproject/remapping/-/remapping-2.3.0.tgz#ed441b6fa600072520ce18b43d2c8cc8caecc7f4" + integrity sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw== + dependencies: + "@jridgewell/gen-mapping" "^0.3.5" + "@jridgewell/trace-mapping" "^0.3.24" + +"@babel/code-frame@^7.0.0", "@babel/code-frame@^7.12.13", "@babel/code-frame@^7.27.1": + version "7.27.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@babel/code-frame/-/code-frame-7.27.1.tgz#200f715e66d52a23b221a9435534a91cc13ad5be" + integrity sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg== + dependencies: + "@babel/helper-validator-identifier" "^7.27.1" + js-tokens "^4.0.0" + picocolors "^1.1.1" + +"@babel/compat-data@^7.27.2": + version "7.27.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@babel/compat-data/-/compat-data-7.27.2.tgz#4183f9e642fd84e74e3eea7ffa93a412e3b102c9" + integrity sha512-TUtMJYRPyUb/9aU8f3K0mjmjf6M9N5Woshn2CS6nqJSeJtTtQcpLUXjGt9vbF8ZGff0El99sWkLgzwW3VXnxZQ== + +"@babel/core@^7.11.6", "@babel/core@^7.12.3", "@babel/core@^7.23.9": + version "7.27.4" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@babel/core/-/core-7.27.4.tgz#cc1fc55d0ce140a1828d1dd2a2eba285adbfb3ce" + integrity sha512-bXYxrXFubeYdvB0NhD/NBB3Qi6aZeV20GOWVI47t2dkecCEoneR4NPVcb7abpXDEvejgrUfFtG6vG/zxAKmg+g== + dependencies: + "@ampproject/remapping" "^2.2.0" + "@babel/code-frame" "^7.27.1" + "@babel/generator" "^7.27.3" + "@babel/helper-compilation-targets" "^7.27.2" + "@babel/helper-module-transforms" "^7.27.3" + "@babel/helpers" "^7.27.4" + "@babel/parser" "^7.27.4" + "@babel/template" "^7.27.2" + "@babel/traverse" "^7.27.4" + "@babel/types" "^7.27.3" + convert-source-map "^2.0.0" + debug "^4.1.0" + gensync "^1.0.0-beta.2" + json5 "^2.2.3" + semver "^6.3.1" + +"@babel/generator@^7.27.3", "@babel/generator@^7.7.2": + version "7.27.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@babel/generator/-/generator-7.27.3.tgz#ef1c0f7cfe3b5fc8cbb9f6cc69f93441a68edefc" + integrity sha512-xnlJYj5zepml8NXtjkG0WquFUv8RskFqyFcVgTBp5k+NaA/8uw/K+OSVf8AMGw5e9HKP2ETd5xpK5MLZQD6b4Q== + dependencies: + "@babel/parser" "^7.27.3" + "@babel/types" "^7.27.3" + "@jridgewell/gen-mapping" "^0.3.5" + "@jridgewell/trace-mapping" "^0.3.25" + jsesc "^3.0.2" + +"@babel/helper-compilation-targets@^7.27.2": + version "7.27.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@babel/helper-compilation-targets/-/helper-compilation-targets-7.27.2.tgz#46a0f6efab808d51d29ce96858dd10ce8732733d" + integrity sha512-2+1thGUUWWjLTYTHZWK1n8Yga0ijBz1XAhUXcKy81rd5g6yh7hGqMp45v7cadSbEHc9G3OTv45SyneRN3ps4DQ== + dependencies: + "@babel/compat-data" "^7.27.2" + "@babel/helper-validator-option" "^7.27.1" + browserslist "^4.24.0" + lru-cache "^5.1.1" + semver "^6.3.1" + +"@babel/helper-module-imports@^7.27.1": + version "7.27.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@babel/helper-module-imports/-/helper-module-imports-7.27.1.tgz#7ef769a323e2655e126673bb6d2d6913bbead204" + integrity sha512-0gSFWUPNXNopqtIPQvlD5WgXYI5GY2kP2cCvoT8kczjbfcfuIljTbcWrulD1CIPIX2gt1wghbDy08yE1p+/r3w== + dependencies: + "@babel/traverse" "^7.27.1" + "@babel/types" "^7.27.1" + +"@babel/helper-module-transforms@^7.27.3": + version "7.27.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@babel/helper-module-transforms/-/helper-module-transforms-7.27.3.tgz#db0bbcfba5802f9ef7870705a7ef8788508ede02" + integrity sha512-dSOvYwvyLsWBeIRyOeHXp5vPj5l1I011r52FM1+r1jCERv+aFXYk4whgQccYEGYxK2H3ZAIA8nuPkQ0HaUo3qg== + dependencies: + "@babel/helper-module-imports" "^7.27.1" + "@babel/helper-validator-identifier" "^7.27.1" + "@babel/traverse" "^7.27.3" + +"@babel/helper-plugin-utils@^7.0.0", "@babel/helper-plugin-utils@^7.10.4", "@babel/helper-plugin-utils@^7.12.13", "@babel/helper-plugin-utils@^7.14.5", "@babel/helper-plugin-utils@^7.24.7", "@babel/helper-plugin-utils@^7.25.9", "@babel/helper-plugin-utils@^7.8.0": + version "7.27.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@babel/helper-plugin-utils/-/helper-plugin-utils-7.27.1.tgz#ddb2f876534ff8013e6c2b299bf4d39b3c51d44c" + integrity sha512-1gn1Up5YXka3YYAHGKpbideQ5Yjf1tDa9qYcgysz+cNCXukyLl6DjPXhD3VRwSb8c0J9tA4b2+rHEZtc6R0tlw== + +"@babel/helper-string-parser@^7.27.1": + version "7.27.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz#54da796097ab19ce67ed9f88b47bb2ec49367687" + integrity sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA== + +"@babel/helper-validator-identifier@^7.27.1": + version "7.27.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@babel/helper-validator-identifier/-/helper-validator-identifier-7.27.1.tgz#a7054dcc145a967dd4dc8fee845a57c1316c9df8" + integrity sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow== + +"@babel/helper-validator-option@^7.27.1": + version "7.27.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz#fa52f5b1e7db1ab049445b421c4471303897702f" + integrity sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg== + +"@babel/helpers@7.27.1", "@babel/helpers@^7.27.4": + version "7.27.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@babel/helpers/-/helpers-7.27.1.tgz#ffc27013038607cdba3288e692c3611c06a18aa4" + integrity sha512-FCvFTm0sWV8Fxhpp2McP5/W53GPllQ9QeQ7SiqGWjMf/LVG07lFa5+pgK05IRhVwtvafT22KF+ZSnM9I545CvQ== + dependencies: + "@babel/template" "^7.27.1" + "@babel/types" "^7.27.1" + +"@babel/parser@7.27.3", "@babel/parser@^7.1.0", "@babel/parser@^7.14.7", "@babel/parser@^7.20.7", "@babel/parser@^7.23.9", "@babel/parser@^7.27.2", "@babel/parser@^7.27.3", "@babel/parser@^7.27.4": + version "7.27.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@babel/parser/-/parser-7.27.3.tgz#1b7533f0d908ad2ac545c4d05cbe2fb6dc8cfaaf" + integrity sha512-xyYxRj6+tLNDTWi0KCBcZ9V7yg3/lwL9DWh9Uwh/RIVlIfFidggcgxKX3GCXwCiswwcGRawBKbEg2LG/Y8eJhw== + dependencies: + "@babel/types" "^7.27.3" + +"@babel/plugin-syntax-async-generators@^7.8.4": + version "7.8.4" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@babel/plugin-syntax-async-generators/7.8.4/plugin-syntax-async-generators-7.8.4.tgz#a983fb1aeb2ec3f6ed042a210f640e90e786fe0d" + integrity sha1-qYP7Gusuw/btBCohD2QOkOeG/g0= + dependencies: + "@babel/helper-plugin-utils" "^7.8.0" + +"@babel/plugin-syntax-bigint@^7.8.3": + version "7.8.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@babel/plugin-syntax-bigint/7.8.3/plugin-syntax-bigint-7.8.3.tgz#4c9a6f669f5d0cdf1b90a1671e9a146be5300cea" + integrity sha1-TJpvZp9dDN8bkKFnHpoUa+UwDOo= + dependencies: + "@babel/helper-plugin-utils" "^7.8.0" + +"@babel/plugin-syntax-class-properties@^7.12.13": + version "7.12.13" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@babel/plugin-syntax-class-properties/7.12.13/plugin-syntax-class-properties-7.12.13.tgz#b5c987274c4a3a82b89714796931a6b53544ae10" + integrity sha1-tcmHJ0xKOoK4lxR5aTGmtTVErhA= + dependencies: + "@babel/helper-plugin-utils" "^7.12.13" + +"@babel/plugin-syntax-class-static-block@^7.14.5": + version "7.14.5" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@babel/plugin-syntax-class-static-block/7.14.5/plugin-syntax-class-static-block-7.14.5.tgz#195df89b146b4b78b3bf897fd7a257c84659d406" + integrity sha1-GV34mxRrS3izv4l/16JXyEZZ1AY= + dependencies: + "@babel/helper-plugin-utils" "^7.14.5" + +"@babel/plugin-syntax-import-attributes@^7.24.7": + version "7.24.7" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@babel/plugin-syntax-import-attributes/-/plugin-syntax-import-attributes-7.24.7.tgz#b4f9ea95a79e6912480c4b626739f86a076624ca" + integrity sha512-hbX+lKKeUMGihnK8nvKqmXBInriT3GVjzXKFriV3YC6APGxMbP8RZNFwy91+hocLXq90Mta+HshoB31802bb8A== + dependencies: + "@babel/helper-plugin-utils" "^7.24.7" + +"@babel/plugin-syntax-import-meta@^7.10.4": + version "7.10.4" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@babel/plugin-syntax-import-meta/7.10.4/plugin-syntax-import-meta-7.10.4.tgz#ee601348c370fa334d2207be158777496521fd51" + integrity sha1-7mATSMNw+jNNIge+FYd3SWUh/VE= + dependencies: + "@babel/helper-plugin-utils" "^7.10.4" + +"@babel/plugin-syntax-json-strings@^7.8.3": + version "7.8.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@babel/plugin-syntax-json-strings/7.8.3/plugin-syntax-json-strings-7.8.3.tgz#01ca21b668cd8218c9e640cb6dd88c5412b2c96a" + integrity sha1-AcohtmjNghjJ5kDLbdiMVBKyyWo= + dependencies: + "@babel/helper-plugin-utils" "^7.8.0" + +"@babel/plugin-syntax-jsx@^7.7.2": + version "7.25.9" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.25.9.tgz#a34313a178ea56f1951599b929c1ceacee719290" + integrity sha512-ld6oezHQMZsZfp6pWtbjaNDF2tiiCYYDqQszHt5VV437lewP9aSi2Of99CK0D0XB21k7FLgnLcmQKyKzynfeAA== + dependencies: + "@babel/helper-plugin-utils" "^7.25.9" + +"@babel/plugin-syntax-logical-assignment-operators@^7.10.4": + version "7.10.4" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@babel/plugin-syntax-logical-assignment-operators/7.10.4/plugin-syntax-logical-assignment-operators-7.10.4.tgz#ca91ef46303530448b906652bac2e9fe9941f699" + integrity sha1-ypHvRjA1MESLkGZSusLp/plB9pk= + dependencies: + "@babel/helper-plugin-utils" "^7.10.4" + +"@babel/plugin-syntax-nullish-coalescing-operator@^7.8.3": + version "7.8.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@babel/plugin-syntax-nullish-coalescing-operator/7.8.3/plugin-syntax-nullish-coalescing-operator-7.8.3.tgz#167ed70368886081f74b5c36c65a88c03b66d1a9" + integrity sha1-Fn7XA2iIYIH3S1w2xlqIwDtm0ak= + dependencies: + "@babel/helper-plugin-utils" "^7.8.0" + +"@babel/plugin-syntax-numeric-separator@^7.10.4": + version "7.10.4" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@babel/plugin-syntax-numeric-separator/7.10.4/plugin-syntax-numeric-separator-7.10.4.tgz#b9b070b3e33570cd9fd07ba7fa91c0dd37b9af97" + integrity sha1-ubBws+M1cM2f0Hun+pHA3Te5r5c= + dependencies: + "@babel/helper-plugin-utils" "^7.10.4" + +"@babel/plugin-syntax-object-rest-spread@^7.8.3": + version "7.8.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@babel/plugin-syntax-object-rest-spread/7.8.3/plugin-syntax-object-rest-spread-7.8.3.tgz#60e225edcbd98a640332a2e72dd3e66f1af55871" + integrity sha1-YOIl7cvZimQDMqLnLdPmbxr1WHE= + dependencies: + "@babel/helper-plugin-utils" "^7.8.0" + +"@babel/plugin-syntax-optional-catch-binding@^7.8.3": + version "7.8.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@babel/plugin-syntax-optional-catch-binding/7.8.3/plugin-syntax-optional-catch-binding-7.8.3.tgz#6111a265bcfb020eb9efd0fdfd7d26402b9ed6c1" + integrity sha1-YRGiZbz7Ag6579D9/X0mQCue1sE= + dependencies: + "@babel/helper-plugin-utils" "^7.8.0" + +"@babel/plugin-syntax-optional-chaining@^7.8.3": + version "7.8.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@babel/plugin-syntax-optional-chaining/7.8.3/plugin-syntax-optional-chaining-7.8.3.tgz#4f69c2ab95167e0180cd5336613f8c5788f7d48a" + integrity sha1-T2nCq5UWfgGAzVM2YT+MV4j31Io= + dependencies: + "@babel/helper-plugin-utils" "^7.8.0" + +"@babel/plugin-syntax-private-property-in-object@^7.14.5": + version "7.14.5" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@babel/plugin-syntax-private-property-in-object/7.14.5/plugin-syntax-private-property-in-object-7.14.5.tgz#0dc6671ec0ea22b6e94a1114f857970cd39de1ad" + integrity sha1-DcZnHsDqIrbpShEU+FeXDNOd4a0= + dependencies: + "@babel/helper-plugin-utils" "^7.14.5" + +"@babel/plugin-syntax-top-level-await@^7.14.5": + version "7.14.5" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@babel/plugin-syntax-top-level-await/7.14.5/plugin-syntax-top-level-await-7.14.5.tgz#c1cfdadc35a646240001f06138247b741c34d94c" + integrity sha1-wc/a3DWmRiQAAfBhOCR7dBw02Uw= + dependencies: + "@babel/helper-plugin-utils" "^7.14.5" + +"@babel/plugin-syntax-typescript@^7.7.2": + version "7.25.9" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.25.9.tgz#67dda2b74da43727cf21d46cf9afef23f4365399" + integrity sha512-hjMgRy5hb8uJJjUcdWunWVcoi9bGpJp8p5Ol1229PoN6aytsLwNMgmdftO23wnCLMfVmTwZDWMPNq/D1SY60JQ== + dependencies: + "@babel/helper-plugin-utils" "^7.25.9" + +"@babel/template@^7.27.1", "@babel/template@^7.27.2", "@babel/template@^7.3.3": + version "7.27.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@babel/template/-/template-7.27.2.tgz#fa78ceed3c4e7b63ebf6cb39e5852fca45f6809d" + integrity sha512-LPDZ85aEJyYSd18/DkjNh4/y1ntkE5KwUHWTiqgRxruuZL2F1yuHligVHLvcHY2vMHXttKFpJn6LwfI7cw7ODw== + dependencies: + "@babel/code-frame" "^7.27.1" + "@babel/parser" "^7.27.2" + "@babel/types" "^7.27.1" + +"@babel/traverse@^7.27.1", "@babel/traverse@^7.27.3", "@babel/traverse@^7.27.4": + version "7.27.4" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@babel/traverse/-/traverse-7.27.4.tgz#b0045ac7023c8472c3d35effd7cc9ebd638da6ea" + integrity sha512-oNcu2QbHqts9BtOWJosOVJapWjBDSxGCpFvikNR5TGDYDQf3JwpIoMzIKrvfoti93cLfPJEG4tH9SPVeyCGgdA== + dependencies: + "@babel/code-frame" "^7.27.1" + "@babel/generator" "^7.27.3" + "@babel/parser" "^7.27.4" + "@babel/template" "^7.27.2" + "@babel/types" "^7.27.3" + debug "^4.3.1" + globals "^11.1.0" + +"@babel/types@^7.0.0", "@babel/types@^7.20.7", "@babel/types@^7.27.1", "@babel/types@^7.27.3", "@babel/types@^7.3.3": + version "7.27.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@babel/types/-/types-7.27.3.tgz#c0257bedf33aad6aad1f406d35c44758321eb3ec" + integrity sha512-Y1GkI4ktrtvmawoSq+4FCVHNryea6uR+qUQy0AGxLSsjCX0nVmkYQMBLHDkXZuo5hGx7eYdnIaslsdBFm7zbUw== + dependencies: + "@babel/helper-string-parser" "^7.27.1" + "@babel/helper-validator-identifier" "^7.27.1" + +"@bcoe/v8-coverage@^0.2.3": + version "0.2.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@bcoe/v8-coverage/0.2.3/v8-coverage-0.2.3.tgz#75a2e8b51cb758a7553d6804a5932d7aace75c39" + integrity sha1-daLotRy3WKdVPWgEpZMteqznXDk= + +"@eslint-community/eslint-utils@^4.2.0": + version "4.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@eslint-community/eslint-utils/-/eslint-utils-4.7.0.tgz#607084630c6c033992a082de6e6fbc1a8b52175a" + integrity sha512-dyybb3AcajC7uha6CvhdVRJqaKyn7w2YKqKyAN37NKYgZT36w+iRb0Dymmc5qEJ549c/S31cMMSFd75bteCpCw== + dependencies: + eslint-visitor-keys "^3.4.3" + +"@eslint-community/regexpp@^4.4.0", "@eslint-community/regexpp@^4.6.1": + version "4.12.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@eslint-community/regexpp/-/regexpp-4.12.1.tgz#cfc6cffe39df390a3841cde2abccf92eaa7ae0e0" + integrity sha512-CCZCDJuduB9OUkFkY2IgppNZMi2lBQgD2qzwXkEia16cge2pijY/aXi96CJMquDMn3nJdlPV1A5KrJEXwfLNzQ== + +"@eslint/eslintrc@^2.1.4": + version "2.1.4" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@eslint/eslintrc/2.1.4/eslintrc-2.1.4.tgz#388a269f0f25c1b6adc317b5a2c55714894c70ad" + integrity sha1-OIomnw8lwbatwxe1osVXFIlMcK0= + dependencies: + ajv "^6.12.4" + debug "^4.3.2" + espree "^9.6.0" + globals "^13.19.0" + ignore "^5.2.0" + import-fresh "^3.2.1" + js-yaml "^4.1.0" + minimatch "^3.1.2" + strip-json-comments "^3.1.1" + +"@eslint/js@8.57.1": + version "8.57.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@eslint/js/-/js-8.57.1.tgz#de633db3ec2ef6a3c89e2f19038063e8a122e2c2" + integrity sha512-d9zaMRSTIKDLhctzH12MtXvJKSSUhaHcjV+2Z+GK+EEY7XKpP5yR4x+N3TAcHTcu963nIr+TMcCb4DBCYX1z6Q== + +"@humanwhocodes/config-array@^0.13.0": + version "0.13.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@humanwhocodes/config-array/-/config-array-0.13.0.tgz#fb907624df3256d04b9aa2df50d7aa97ec648748" + integrity sha512-DZLEEqFWQFiyK6h5YIeynKx7JlvCYWL0cImfSRXZ9l4Sg2efkFGTuFf6vzXjK1cq6IYkU+Eg/JizXw+TD2vRNw== + dependencies: + "@humanwhocodes/object-schema" "^2.0.3" + debug "^4.3.1" + minimatch "^3.0.5" + +"@humanwhocodes/module-importer@^1.0.1": + version "1.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz#af5b2691a22b44be847b0ca81641c5fb6ad0172c" + integrity sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA== + +"@humanwhocodes/object-schema@^2.0.3": + version "2.0.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@humanwhocodes/object-schema/2.0.3/object-schema-2.0.3.tgz#4a2868d75d6d6963e423bcf90b7fd1be343409d3" + integrity sha1-Siho111taWPkI7z5C3/RvjQ0CdM= + +"@inquirer/checkbox@^3.0.1": + version "3.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@inquirer/checkbox/-/checkbox-3.0.1.tgz#0a57f704265f78c36e17f07e421b98efb4b9867b" + integrity sha512-0hm2nrToWUdD6/UHnel/UKGdk1//ke5zGUpHIvk5ZWmaKezlGxZkOJXNSWsdxO/rEqTkbB3lNC2J6nBElV2aAQ== + dependencies: + "@inquirer/core" "^9.2.1" + "@inquirer/figures" "^1.0.6" + "@inquirer/type" "^2.0.0" + ansi-escapes "^4.3.2" + yoctocolors-cjs "^2.1.2" + +"@inquirer/confirm@^4.0.1": + version "4.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@inquirer/confirm/-/confirm-4.0.1.tgz#9106d6bffa0b2fdd0e4f60319b6f04f2e06e6e25" + integrity sha512-46yL28o2NJ9doViqOy0VDcoTzng7rAb6yPQKU7VDLqkmbCaH4JqK4yk4XqlzNWy9PVC5pG1ZUXPBQv+VqnYs2w== + dependencies: + "@inquirer/core" "^9.2.1" + "@inquirer/type" "^2.0.0" + +"@inquirer/core@^9.2.1": + version "9.2.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@inquirer/core/-/core-9.2.1.tgz#677c49dee399c9063f31e0c93f0f37bddc67add1" + integrity sha512-F2VBt7W/mwqEU4bL0RnHNZmC/OxzNx9cOYxHqnXX3MP6ruYvZUZAW9imgN9+h/uBT/oP8Gh888J2OZSbjSeWcg== + dependencies: + "@inquirer/figures" "^1.0.6" + "@inquirer/type" "^2.0.0" + "@types/mute-stream" "^0.0.4" + "@types/node" "^22.5.5" + "@types/wrap-ansi" "^3.0.0" + ansi-escapes "^4.3.2" + cli-width "^4.1.0" + mute-stream "^1.0.0" + signal-exit "^4.1.0" + strip-ansi "^6.0.1" + wrap-ansi "^6.2.0" + yoctocolors-cjs "^2.1.2" + +"@inquirer/editor@^3.0.1": + version "3.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@inquirer/editor/-/editor-3.0.1.tgz#d109f21e050af6b960725388cb1c04214ed7c7bc" + integrity sha512-VA96GPFaSOVudjKFraokEEmUQg/Lub6OXvbIEZU1SDCmBzRkHGhxoFAVaF30nyiB4m5cEbDgiI2QRacXZ2hw9Q== + dependencies: + "@inquirer/core" "^9.2.1" + "@inquirer/type" "^2.0.0" + external-editor "^3.1.0" + +"@inquirer/expand@^3.0.1": + version "3.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@inquirer/expand/-/expand-3.0.1.tgz#aed9183cac4d12811be47a4a895ea8e82a17e22c" + integrity sha512-ToG8d6RIbnVpbdPdiN7BCxZGiHOTomOX94C2FaT5KOHupV40tKEDozp12res6cMIfRKrXLJyexAZhWVHgbALSQ== + dependencies: + "@inquirer/core" "^9.2.1" + "@inquirer/type" "^2.0.0" + yoctocolors-cjs "^2.1.2" + +"@inquirer/figures@^1.0.6": + version "1.0.11" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@inquirer/figures/-/figures-1.0.11.tgz#4744e6db95288fea1dead779554859710a959a21" + integrity sha512-eOg92lvrn/aRUqbxRyvpEWnrvRuTYRifixHkYVpJiygTgVSBIHDqLh0SrMQXkafvULg3ck11V7xvR+zcgvpHFw== + +"@inquirer/input@^3.0.1": + version "3.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@inquirer/input/-/input-3.0.1.tgz#de63d49e516487388508d42049deb70f2cb5f28e" + integrity sha512-BDuPBmpvi8eMCxqC5iacloWqv+5tQSJlUafYWUe31ow1BVXjW2a5qe3dh4X/Z25Wp22RwvcaLCc2siHobEOfzg== + dependencies: + "@inquirer/core" "^9.2.1" + "@inquirer/type" "^2.0.0" + +"@inquirer/number@^2.0.1": + version "2.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@inquirer/number/-/number-2.0.1.tgz#b9863080d02ab7dc2e56e16433d83abea0f2a980" + integrity sha512-QpR8jPhRjSmlr/mD2cw3IR8HRO7lSVOnqUvQa8scv1Lsr3xoAMMworcYW3J13z3ppjBFBD2ef1Ci6AE5Qn8goQ== + dependencies: + "@inquirer/core" "^9.2.1" + "@inquirer/type" "^2.0.0" + +"@inquirer/password@^3.0.1": + version "3.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@inquirer/password/-/password-3.0.1.tgz#2a9a9143591088336bbd573bcb05d5bf080dbf87" + integrity sha512-haoeEPUisD1NeE2IanLOiFr4wcTXGWrBOyAyPZi1FfLJuXOzNmxCJPgUrGYKVh+Y8hfGJenIfz5Wb/DkE9KkMQ== + dependencies: + "@inquirer/core" "^9.2.1" + "@inquirer/type" "^2.0.0" + ansi-escapes "^4.3.2" + +"@inquirer/prompts@^6.0.1": + version "6.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@inquirer/prompts/-/prompts-6.0.1.tgz#43f5c0ed35c5ebfe52f1d43d46da2d363d950071" + integrity sha512-yl43JD/86CIj3Mz5mvvLJqAOfIup7ncxfJ0Btnl0/v5TouVUyeEdcpknfgc+yMevS/48oH9WAkkw93m7otLb/A== + dependencies: + "@inquirer/checkbox" "^3.0.1" + "@inquirer/confirm" "^4.0.1" + "@inquirer/editor" "^3.0.1" + "@inquirer/expand" "^3.0.1" + "@inquirer/input" "^3.0.1" + "@inquirer/number" "^2.0.1" + "@inquirer/password" "^3.0.1" + "@inquirer/rawlist" "^3.0.1" + "@inquirer/search" "^2.0.1" + "@inquirer/select" "^3.0.1" + +"@inquirer/rawlist@^3.0.1": + version "3.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@inquirer/rawlist/-/rawlist-3.0.1.tgz#729def358419cc929045f264131878ed379e0af3" + integrity sha512-VgRtFIwZInUzTiPLSfDXK5jLrnpkuSOh1ctfaoygKAdPqjcjKYmGh6sCY1pb0aGnCGsmhUxoqLDUAU0ud+lGXQ== + dependencies: + "@inquirer/core" "^9.2.1" + "@inquirer/type" "^2.0.0" + yoctocolors-cjs "^2.1.2" + +"@inquirer/search@^2.0.1": + version "2.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@inquirer/search/-/search-2.0.1.tgz#69b774a0a826de2e27b48981d01bc5ad81e73721" + integrity sha512-r5hBKZk3g5MkIzLVoSgE4evypGqtOannnB3PKTG9NRZxyFRKcfzrdxXXPcoJQsxJPzvdSU2Rn7pB7lw0GCmGAg== + dependencies: + "@inquirer/core" "^9.2.1" + "@inquirer/figures" "^1.0.6" + "@inquirer/type" "^2.0.0" + yoctocolors-cjs "^2.1.2" + +"@inquirer/select@^3.0.1": + version "3.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@inquirer/select/-/select-3.0.1.tgz#1df9ed27fb85a5f526d559ac5ce7cc4e9dc4e7ec" + integrity sha512-lUDGUxPhdWMkN/fHy1Lk7pF3nK1fh/gqeyWXmctefhxLYxlDsc7vsPBEpxrfVGDsVdyYJsiJoD4bJ1b623cV1Q== + dependencies: + "@inquirer/core" "^9.2.1" + "@inquirer/figures" "^1.0.6" + "@inquirer/type" "^2.0.0" + ansi-escapes "^4.3.2" + yoctocolors-cjs "^2.1.2" + +"@inquirer/type@^2.0.0": + version "2.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@inquirer/type/-/type-2.0.0.tgz#08fa513dca2cb6264fe1b0a2fabade051444e3f6" + integrity sha512-XvJRx+2KR3YXyYtPUUy+qd9i7p+GO9Ko6VIIpWlBrpWwXDv8WLFeHTxz35CfQFUiBMLXlGHhGzys7lqit9gWag== + dependencies: + mute-stream "^1.0.0" + +"@istanbuljs/load-nyc-config@^1.0.0": + version "1.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@istanbuljs/load-nyc-config/1.1.0/load-nyc-config-1.1.0.tgz#fd3db1d59ecf7cf121e80650bb86712f9b55eced" + integrity sha1-/T2x1Z7PfPEh6AZQu4ZxL5tV7O0= + dependencies: + camelcase "^5.3.1" + find-up "^4.1.0" + get-package-type "^0.1.0" + js-yaml "^3.13.1" + resolve-from "^5.0.0" + +"@istanbuljs/schema@^0.1.2", "@istanbuljs/schema@^0.1.3": + version "0.1.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@istanbuljs/schema/0.1.3/schema-0.1.3.tgz#e45e384e4b8ec16bce2fd903af78450f6bf7ec98" + integrity sha1-5F44TkuOwWvOL9kDr3hFD2v37Jg= + +"@jest/console@^29.7.0": + version "29.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@jest/console/29.7.0/console-29.7.0.tgz#cd4822dbdb84529265c5a2bdb529a3c9cc950ffc" + integrity sha1-zUgi29uEUpJlxaK9tSmjycyVD/w= + dependencies: + "@jest/types" "^29.6.3" + "@types/node" "*" + chalk "^4.0.0" + jest-message-util "^29.7.0" + jest-util "^29.7.0" + slash "^3.0.0" + +"@jest/core@^29.7.0": + version "29.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@jest/core/29.7.0/core-29.7.0.tgz#b6cccc239f30ff36609658c5a5e2291757ce448f" + integrity sha1-tszMI58w/zZglljFpeIpF1fORI8= + dependencies: + "@jest/console" "^29.7.0" + "@jest/reporters" "^29.7.0" + "@jest/test-result" "^29.7.0" + "@jest/transform" "^29.7.0" + "@jest/types" "^29.6.3" + "@types/node" "*" + ansi-escapes "^4.2.1" + chalk "^4.0.0" + ci-info "^3.2.0" + exit "^0.1.2" + graceful-fs "^4.2.9" + jest-changed-files "^29.7.0" + jest-config "^29.7.0" + jest-haste-map "^29.7.0" + jest-message-util "^29.7.0" + jest-regex-util "^29.6.3" + jest-resolve "^29.7.0" + jest-resolve-dependencies "^29.7.0" + jest-runner "^29.7.0" + jest-runtime "^29.7.0" + jest-snapshot "^29.7.0" + jest-util "^29.7.0" + jest-validate "^29.7.0" + jest-watcher "^29.7.0" + micromatch "^4.0.4" + pretty-format "^29.7.0" + slash "^3.0.0" + strip-ansi "^6.0.0" + +"@jest/environment@^29.7.0": + version "29.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@jest/environment/29.7.0/environment-29.7.0.tgz#24d61f54ff1f786f3cd4073b4b94416383baf2a7" + integrity sha1-JNYfVP8feG881Ac7S5RBY4O68qc= + dependencies: + "@jest/fake-timers" "^29.7.0" + "@jest/types" "^29.6.3" + "@types/node" "*" + jest-mock "^29.7.0" + +"@jest/expect-utils@^29.7.0": + version "29.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@jest/expect-utils/29.7.0/expect-utils-29.7.0.tgz#023efe5d26a8a70f21677d0a1afc0f0a44e3a1c6" + integrity sha1-Aj7+XSaopw8hZ30KGvwPCkTjocY= + dependencies: + jest-get-type "^29.6.3" + +"@jest/expect@^29.7.0": + version "29.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@jest/expect/29.7.0/expect-29.7.0.tgz#76a3edb0cb753b70dfbfe23283510d3d45432bf2" + integrity sha1-dqPtsMt1O3Dfv+Iyg1ENPUVDK/I= + dependencies: + expect "^29.7.0" + jest-snapshot "^29.7.0" + +"@jest/fake-timers@^29.7.0": + version "29.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@jest/fake-timers/29.7.0/fake-timers-29.7.0.tgz#fd91bf1fffb16d7d0d24a426ab1a47a49881a565" + integrity sha1-/ZG/H/+xbX0NJKQmqxpHpJiBpWU= + dependencies: + "@jest/types" "^29.6.3" + "@sinonjs/fake-timers" "^10.0.2" + "@types/node" "*" + jest-message-util "^29.7.0" + jest-mock "^29.7.0" + jest-util "^29.7.0" + +"@jest/globals@^29.7.0": + version "29.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@jest/globals/29.7.0/globals-29.7.0.tgz#8d9290f9ec47ff772607fa864ca1d5a2efae1d4d" + integrity sha1-jZKQ+exH/3cmB/qGTKHVou+uHU0= + dependencies: + "@jest/environment" "^29.7.0" + "@jest/expect" "^29.7.0" + "@jest/types" "^29.6.3" + jest-mock "^29.7.0" + +"@jest/reporters@^29.7.0": + version "29.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@jest/reporters/29.7.0/reporters-29.7.0.tgz#04b262ecb3b8faa83b0b3d321623972393e8f4c7" + integrity sha1-BLJi7LO4+qg7Cz0yFiOXI5Po9Mc= + dependencies: + "@bcoe/v8-coverage" "^0.2.3" + "@jest/console" "^29.7.0" + "@jest/test-result" "^29.7.0" + "@jest/transform" "^29.7.0" + "@jest/types" "^29.6.3" + "@jridgewell/trace-mapping" "^0.3.18" + "@types/node" "*" + chalk "^4.0.0" + collect-v8-coverage "^1.0.0" + exit "^0.1.2" + glob "^7.1.3" + graceful-fs "^4.2.9" + istanbul-lib-coverage "^3.0.0" + istanbul-lib-instrument "^6.0.0" + istanbul-lib-report "^3.0.0" + istanbul-lib-source-maps "^4.0.0" + istanbul-reports "^3.1.3" + jest-message-util "^29.7.0" + jest-util "^29.7.0" + jest-worker "^29.7.0" + slash "^3.0.0" + string-length "^4.0.1" + strip-ansi "^6.0.0" + v8-to-istanbul "^9.0.1" + +"@jest/schemas@^29.6.3": + version "29.6.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@jest/schemas/-/schemas-29.6.3.tgz#430b5ce8a4e0044a7e3819663305a7b3091c8e03" + integrity sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA== + dependencies: + "@sinclair/typebox" "^0.27.8" + +"@jest/source-map@^29.6.3": + version "29.6.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@jest/source-map/29.6.3/source-map-29.6.3.tgz#d90ba772095cf37a34a5eb9413f1b562a08554c4" + integrity sha1-2Quncglc83o0peuUE/G1YqCFVMQ= + dependencies: + "@jridgewell/trace-mapping" "^0.3.18" + callsites "^3.0.0" + graceful-fs "^4.2.9" + +"@jest/test-result@^29.7.0": + version "29.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@jest/test-result/29.7.0/test-result-29.7.0.tgz#8db9a80aa1a097bb2262572686734baed9b1657c" + integrity sha1-jbmoCqGgl7siYlcmhnNLrtmxZXw= + dependencies: + "@jest/console" "^29.7.0" + "@jest/types" "^29.6.3" + "@types/istanbul-lib-coverage" "^2.0.0" + collect-v8-coverage "^1.0.0" + +"@jest/test-sequencer@^29.7.0": + version "29.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@jest/test-sequencer/29.7.0/test-sequencer-29.7.0.tgz#6cef977ce1d39834a3aea887a1726628a6f072ce" + integrity sha1-bO+XfOHTmDSjrqiHoXJmKKbwcs4= + dependencies: + "@jest/test-result" "^29.7.0" + graceful-fs "^4.2.9" + jest-haste-map "^29.7.0" + slash "^3.0.0" + +"@jest/transform@^29.7.0": + version "29.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@jest/transform/29.7.0/transform-29.7.0.tgz#df2dd9c346c7d7768b8a06639994640c642e284c" + integrity sha1-3y3Zw0bH13aLigZjmZRkDGQuKEw= + dependencies: + "@babel/core" "^7.11.6" + "@jest/types" "^29.6.3" + "@jridgewell/trace-mapping" "^0.3.18" + babel-plugin-istanbul "^6.1.1" + chalk "^4.0.0" + convert-source-map "^2.0.0" + fast-json-stable-stringify "^2.1.0" + graceful-fs "^4.2.9" + jest-haste-map "^29.7.0" + jest-regex-util "^29.6.3" + jest-util "^29.7.0" + micromatch "^4.0.4" + pirates "^4.0.4" + slash "^3.0.0" + write-file-atomic "^4.0.2" + +"@jest/types@^29.6.3": + version "29.6.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@jest/types/-/types-29.6.3.tgz#1131f8cf634e7e84c5e77bab12f052af585fba59" + integrity sha512-u3UPsIilWKOM3F9CXtrG8LEJmNxwoCQC/XVj4IKYXvvpx7QIi/Kg1LI5uDmDpKlac62NUtX7eLjRh+jVZcLOzw== + dependencies: + "@jest/schemas" "^29.6.3" + "@types/istanbul-lib-coverage" "^2.0.0" + "@types/istanbul-reports" "^3.0.0" + "@types/node" "*" + "@types/yargs" "^17.0.8" + chalk "^4.0.0" + +"@jridgewell/gen-mapping@^0.3.5": + version "0.3.8" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@jridgewell/gen-mapping/-/gen-mapping-0.3.8.tgz#4f0e06362e01362f823d348f1872b08f666d8142" + integrity sha512-imAbBGkb+ebQyxKgzv5Hu2nmROxoDOXHh80evxdoXNOrvAnVx7zimzc1Oo5h9RlfV4vPXaE2iM5pOFbvOCClWA== + dependencies: + "@jridgewell/set-array" "^1.2.1" + "@jridgewell/sourcemap-codec" "^1.4.10" + "@jridgewell/trace-mapping" "^0.3.24" + +"@jridgewell/resolve-uri@^3.1.0": + version "3.1.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz#7a0ee601f60f99a20c7c7c5ff0c80388c1189bd6" + integrity sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw== + +"@jridgewell/set-array@^1.2.1": + version "1.2.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@jridgewell/set-array/-/set-array-1.2.1.tgz#558fb6472ed16a4c850b889530e6b36438c49280" + integrity sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A== + +"@jridgewell/sourcemap-codec@^1.4.10", "@jridgewell/sourcemap-codec@^1.4.14": + version "1.5.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.0.tgz#3188bcb273a414b0d215fd22a58540b989b9409a" + integrity sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ== + +"@jridgewell/trace-mapping@^0.3.12", "@jridgewell/trace-mapping@^0.3.18", "@jridgewell/trace-mapping@^0.3.24", "@jridgewell/trace-mapping@^0.3.25": + version "0.3.25" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@jridgewell/trace-mapping/-/trace-mapping-0.3.25.tgz#15f190e98895f3fc23276ee14bc76b675c2e50f0" + integrity sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ== + dependencies: + "@jridgewell/resolve-uri" "^3.1.0" + "@jridgewell/sourcemap-codec" "^1.4.14" + +"@nodelib/fs.scandir@2.1.5": + version "2.1.5" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz#7619c2eb21b25483f6d167548b4cfd5a7488c3d5" + integrity sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g== + dependencies: + "@nodelib/fs.stat" "2.0.5" + run-parallel "^1.1.9" + +"@nodelib/fs.stat@2.0.5", "@nodelib/fs.stat@^2.0.2": + version "2.0.5" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz#5bd262af94e9d25bd1e71b05deed44876a222e8b" + integrity sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A== + +"@nodelib/fs.walk@^1.2.3", "@nodelib/fs.walk@^1.2.8": + version "1.2.8" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz#e95737e8bb6746ddedf69c556953494f196fe69a" + integrity sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg== + dependencies: + "@nodelib/fs.scandir" "2.1.5" + fastq "^1.6.0" + +"@pkgr/core@^0.2.3": + version "0.2.4" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@pkgr/core/-/core-0.2.4.tgz#d897170a2b0ba51f78a099edccd968f7b103387c" + integrity sha512-ROFF39F6ZrnzSUEmQQZUar0Jt4xVoP9WnDRdWwF4NNcXs3xBTLgBUDoOwW141y1jP+S8nahIbdxbFC7IShw9Iw== + +"@rtsao/scc@^1.1.0": + version "1.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@rtsao/scc/-/scc-1.1.0.tgz#927dd2fae9bc3361403ac2c7a00c32ddce9ad7e8" + integrity sha512-zt6OdqaDoOnJ1ZYsCYGt9YmWzDXl4vQdKTyJev62gFhRGKdx7mcT54V9KIjg+d2wi9EXsPvAPKe7i7WjfVWB8g== + +"@sinclair/typebox@^0.27.8": + version "0.27.8" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@sinclair/typebox/0.27.8/typebox-0.27.8.tgz#6667fac16c436b5434a387a34dedb013198f6e6e" + integrity sha1-Zmf6wWxDa1Q0o4ejTe2wExmPbm4= + +"@sinonjs/commons@^3.0.0": + version "3.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@sinonjs/commons/3.0.1/commons-3.0.1.tgz#1029357e44ca901a615585f6d27738dbc89084cd" + integrity sha1-ECk1fkTKkBphVYX20nc428iQhM0= + dependencies: + type-detect "4.0.8" + +"@sinonjs/fake-timers@^10.0.2": + version "10.3.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@sinonjs/fake-timers/10.3.0/fake-timers-10.3.0.tgz#55fdff1ecab9f354019129daf4df0dd4d923ea66" + integrity sha1-Vf3/Hsq581QBkSna9N8N1Nkj6mY= + dependencies: + "@sinonjs/commons" "^3.0.0" + +"@types/babel__core@^7.1.14": + version "7.20.5" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@types/babel__core/-/babel__core-7.20.5.tgz#3df15f27ba85319caa07ba08d0721889bb39c017" + integrity sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA== + dependencies: + "@babel/parser" "^7.20.7" + "@babel/types" "^7.20.7" + "@types/babel__generator" "*" + "@types/babel__template" "*" + "@types/babel__traverse" "*" + +"@types/babel__generator@*": + version "7.6.8" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@types/babel__generator/7.6.8/babel__generator-7.6.8.tgz#f836c61f48b1346e7d2b0d93c6dacc5b9535d3ab" + integrity sha1-+DbGH0ixNG59Kw2TxtrMW5U106s= + dependencies: + "@babel/types" "^7.0.0" + +"@types/babel__template@*": + version "7.4.4" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@types/babel__template/7.4.4/babel__template-7.4.4.tgz#5672513701c1b2199bc6dad636a9d7491586766f" + integrity sha1-VnJRNwHBshmbxtrWNqnXSRWGdm8= + dependencies: + "@babel/parser" "^7.1.0" + "@babel/types" "^7.0.0" + +"@types/babel__traverse@*", "@types/babel__traverse@^7.0.6": + version "7.20.7" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@types/babel__traverse/-/babel__traverse-7.20.7.tgz#968cdc2366ec3da159f61166428ee40f370e56c2" + integrity sha512-dkO5fhS7+/oos4ciWxyEyjWe48zmG6wbCheo/G2ZnHx4fs3EU6YC6UM8rk56gAjNJ9P3MTH2jo5jb92/K6wbng== + dependencies: + "@babel/types" "^7.20.7" + +"@types/graceful-fs@^4.1.3": + version "4.1.9" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@types/graceful-fs/-/graceful-fs-4.1.9.tgz#2a06bc0f68a20ab37b3e36aa238be6abdf49e8b4" + integrity sha512-olP3sd1qOEe5dXTSaFvQG+02VdRXcdytWLAZsAq1PecU8uqQAhkrnbli7DagjtXKW/Bl7YJbUsa8MPcuc8LHEQ== + dependencies: + "@types/node" "*" + +"@types/istanbul-lib-coverage@*", "@types/istanbul-lib-coverage@^2.0.0", "@types/istanbul-lib-coverage@^2.0.1": + version "2.0.6" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.6.tgz#7739c232a1fee9b4d3ce8985f314c0c6d33549d7" + integrity sha512-2QF/t/auWm0lsy8XtKVPG19v3sSOQlJe/YHZgfjb/KBBHOGSV+J2q/S671rcq9uTBrLAXmZpqJiaQbMT+zNU1w== + +"@types/istanbul-lib-report@*": + version "3.0.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@types/istanbul-lib-report/3.0.3/istanbul-lib-report-3.0.3.tgz#53047614ae72e19fc0401d872de3ae2b4ce350bf" + integrity sha1-UwR2FK5y4Z/AQB2HLeOuK0zjUL8= + dependencies: + "@types/istanbul-lib-coverage" "*" + +"@types/istanbul-reports@^3.0.0": + version "3.0.4" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@types/istanbul-reports/-/istanbul-reports-3.0.4.tgz#0f03e3d2f670fbdac586e34b433783070cc16f54" + integrity sha512-pk2B1NWalF9toCRu6gjBzR69syFjP4Od8WRAX+0mmf9lAjCRicLOWc+ZrxZHx/0XRjotgkF9t6iaMJ+aXcOdZQ== + dependencies: + "@types/istanbul-lib-report" "*" + +"@types/jest@^29.5.14": + version "29.5.14" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@types/jest/-/jest-29.5.14.tgz#2b910912fa1d6856cadcd0c1f95af7df1d6049e5" + integrity sha512-ZN+4sdnLUbo8EVvVc2ao0GFW6oVrQRPn4K2lglySj7APvSrgzxHiNNK99us4WDMi57xxA2yggblIAMNhXOotLQ== + dependencies: + expect "^29.0.0" + pretty-format "^29.0.0" + +"@types/json-schema@^7.0.9": + version "7.0.15" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@types/json-schema/-/json-schema-7.0.15.tgz#596a1747233694d50f6ad8a7869fcb6f56cf5841" + integrity sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA== + +"@types/json5@^0.0.29": + version "0.0.29" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@types/json5/0.0.29/json5-0.0.29.tgz#ee28707ae94e11d2b827bcbe5270bcea7f3e71ee" + integrity sha1-7ihweulOEdK4J7y+UnC86n8+ce4= + +"@types/mute-stream@^0.0.4": + version "0.0.4" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@types/mute-stream/-/mute-stream-0.0.4.tgz#77208e56a08767af6c5e1237be8888e2f255c478" + integrity sha512-CPM9nzrCPPJHQNA9keH9CVkVI+WR5kMa+7XEs5jcGQ0VoAGnLv242w8lIVgwAEfmE4oufJRaTc9PNLQl0ioAow== + dependencies: + "@types/node" "*" + +"@types/node-forge@1.3.11": + version "1.3.11" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@types/node-forge/-/node-forge-1.3.11.tgz#0972ea538ddb0f4d9c2fa0ec5db5724773a604da" + integrity sha512-FQx220y22OKNTqaByeBGqHWYz4cl94tpcxeFdvBo3wjG6XPBuZ0BNgNZRV5J5TFmmcsJ4IzsLkmGRiQbnYsBEQ== + dependencies: + "@types/node" "*" + +"@types/node@*", "@types/node@^22.15.3", "@types/node@^22.5.5": + version "22.15.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@types/node/-/node-22.15.3.tgz#b7fb9396a8ec5b5dfb1345d8ac2502060e9af68b" + integrity sha512-lX7HFZeHf4QG/J7tBZqrCAXwz9J5RD56Y6MpP0eJkka8p+K0RY/yBTW7CYFJ4VGCclxqOLKmiGP5juQc6MKgcw== + dependencies: + undici-types "~6.21.0" + +"@types/semver@^7.3.12": + version "7.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@types/semver/-/semver-7.7.0.tgz#64c441bdae033b378b6eef7d0c3d77c329b9378e" + integrity sha512-k107IF4+Xr7UHjwDc7Cfd6PRQfbdkiRabXGRjo07b4WyPahFBZCZ1sE+BNxYIJPPg73UkfOsVOLwqVc/6ETrIA== + +"@types/stack-utils@^2.0.0": + version "2.0.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@types/stack-utils/2.0.3/stack-utils-2.0.3.tgz#6209321eb2c1712a7e7466422b8cb1fc0d9dd5d8" + integrity sha1-YgkyHrLBcSp+dGZCK4yx/A2d1dg= + +"@types/wrap-ansi@^3.0.0": + version "3.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@types/wrap-ansi/-/wrap-ansi-3.0.0.tgz#18b97a972f94f60a679fd5c796d96421b9abb9fd" + integrity sha512-ltIpx+kM7g/MLRZfkbL7EsCEjfzCcScLpkg37eXEtx5kmrAKBkTJwd1GIAjDSL8wTpM6Hzn5YO4pSb91BEwu1g== + +"@types/yargs-parser@*": + version "21.0.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@types/yargs-parser/21.0.3/yargs-parser-21.0.3.tgz#815e30b786d2e8f0dcd85fd5bcf5e1a04d008f15" + integrity sha1-gV4wt4bS6PDc2F/VvPXhoE0AjxU= + +"@types/yargs@^17.0.8": + version "17.0.33" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@types/yargs/-/yargs-17.0.33.tgz#8c32303da83eec050a84b3c7ae7b9f922d13e32d" + integrity sha512-WpxBCKWPLr4xSsHgz511rFJAM+wS28w2zEO1QDNY5zM/S8ok70NNfztH0xwhqKyaK0OHCbN98LDAZuy1ctxDkA== + dependencies: + "@types/yargs-parser" "*" + +"@typescript-eslint/eslint-plugin@^5.62.0": + version "5.62.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@typescript-eslint/eslint-plugin/5.62.0/eslint-plugin-5.62.0.tgz#aeef0328d172b9e37d9bab6dbc13b87ed88977db" + integrity sha1-ru8DKNFyueN9m6ttvBO4ftiJd9s= + dependencies: + "@eslint-community/regexpp" "^4.4.0" + "@typescript-eslint/scope-manager" "5.62.0" + "@typescript-eslint/type-utils" "5.62.0" + "@typescript-eslint/utils" "5.62.0" + debug "^4.3.4" + graphemer "^1.4.0" + ignore "^5.2.0" + natural-compare-lite "^1.4.0" + semver "^7.3.7" + tsutils "^3.21.0" + +"@typescript-eslint/parser@^5.62.0": + version "5.62.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@typescript-eslint/parser/5.62.0/parser-5.62.0.tgz#1b63d082d849a2fcae8a569248fbe2ee1b8a56c7" + integrity sha1-G2PQgthJovyuilaSSPvi7huKVsc= + dependencies: + "@typescript-eslint/scope-manager" "5.62.0" + "@typescript-eslint/types" "5.62.0" + "@typescript-eslint/typescript-estree" "5.62.0" + debug "^4.3.4" + +"@typescript-eslint/scope-manager@5.62.0": + version "5.62.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@typescript-eslint/scope-manager/5.62.0/scope-manager-5.62.0.tgz#d9457ccc6a0b8d6b37d0eb252a23022478c5460c" + integrity sha1-2UV8zGoLjWs30OslKiMCJHjFRgw= + dependencies: + "@typescript-eslint/types" "5.62.0" + "@typescript-eslint/visitor-keys" "5.62.0" + +"@typescript-eslint/type-utils@5.62.0": + version "5.62.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@typescript-eslint/type-utils/5.62.0/type-utils-5.62.0.tgz#286f0389c41681376cdad96b309cedd17d70346a" + integrity sha1-KG8DicQWgTds2tlrMJzt0X1wNGo= + dependencies: + "@typescript-eslint/typescript-estree" "5.62.0" + "@typescript-eslint/utils" "5.62.0" + debug "^4.3.4" + tsutils "^3.21.0" + +"@typescript-eslint/types@5.62.0": + version "5.62.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@typescript-eslint/types/5.62.0/types-5.62.0.tgz#258607e60effa309f067608931c3df6fed41fd2f" + integrity sha1-JYYH5g7/ownwZ2CJMcPfb+1B/S8= + +"@typescript-eslint/typescript-estree@5.62.0": + version "5.62.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@typescript-eslint/typescript-estree/5.62.0/typescript-estree-5.62.0.tgz#7d17794b77fabcac615d6a48fb143330d962eb9b" + integrity sha1-fRd5S3f6vKxhXWpI+xQzMNli65s= + dependencies: + "@typescript-eslint/types" "5.62.0" + "@typescript-eslint/visitor-keys" "5.62.0" + debug "^4.3.4" + globby "^11.1.0" + is-glob "^4.0.3" + semver "^7.3.7" + tsutils "^3.21.0" + +"@typescript-eslint/utils@5.62.0": + version "5.62.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@typescript-eslint/utils/5.62.0/utils-5.62.0.tgz#141e809c71636e4a75daa39faed2fb5f4b10df86" + integrity sha1-FB6AnHFjbkp12qOfrtL7X0sQ34Y= + dependencies: + "@eslint-community/eslint-utils" "^4.2.0" + "@types/json-schema" "^7.0.9" + "@types/semver" "^7.3.12" + "@typescript-eslint/scope-manager" "5.62.0" + "@typescript-eslint/types" "5.62.0" + "@typescript-eslint/typescript-estree" "5.62.0" + eslint-scope "^5.1.1" + semver "^7.3.7" + +"@typescript-eslint/visitor-keys@5.62.0": + version "5.62.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@typescript-eslint/visitor-keys/5.62.0/visitor-keys-5.62.0.tgz#2174011917ce582875954ffe2f6912d5931e353e" + integrity sha1-IXQBGRfOWCh1lU/+L2kS1ZMeNT4= + dependencies: + "@typescript-eslint/types" "5.62.0" + eslint-visitor-keys "^3.3.0" + +"@ungap/structured-clone@^1.2.0": + version "1.3.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/@ungap/structured-clone/-/structured-clone-1.3.0.tgz#d06bbb384ebcf6c505fde1c3d0ed4ddffe0aaff8" + integrity sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g== + +acorn-jsx@^5.3.2: + version "5.3.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/acorn-jsx/-/acorn-jsx-5.3.2.tgz#7ed5bb55908b3b2f1bc55c6af1653bada7f07937" + integrity sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ== + +acorn@^8.9.0: + version "8.14.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/acorn/-/acorn-8.14.1.tgz#721d5dc10f7d5b5609a891773d47731796935dfb" + integrity sha512-OvQ/2pUDKmgfCg++xsTX1wGxfTaszcHVcTctW4UJB4hibJx2HXxxO5UmVgyjMa+ZDsiaf5wWLXYpRWMmBI0QHg== + +ajv@^6.12.4: + version "6.12.6" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/ajv/-/ajv-6.12.6.tgz#baf5a62e802b07d977034586f8c3baf5adf26df4" + integrity sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g== + dependencies: + fast-deep-equal "^3.1.1" + fast-json-stable-stringify "^2.0.0" + json-schema-traverse "^0.4.1" + uri-js "^4.2.2" + +ansi-escapes@^4.2.1, ansi-escapes@^4.3.2: + version "4.3.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/ansi-escapes/-/ansi-escapes-4.3.2.tgz#6b2291d1db7d98b6521d5f1efa42d0f3a9feb65e" + integrity sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ== + dependencies: + type-fest "^0.21.3" + +ansi-regex@^5.0.1: + version "5.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/ansi-regex/-/ansi-regex-5.0.1.tgz#082cb2c89c9fe8659a311a53bd6a4dc5301db304" + integrity sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ== + +ansi-styles@^4.0.0, ansi-styles@^4.1.0: + version "4.3.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/ansi-styles/-/ansi-styles-4.3.0.tgz#edd803628ae71c04c85ae7a0906edad34b648937" + integrity sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg== + dependencies: + color-convert "^2.0.1" + +ansi-styles@^5.0.0: + version "5.2.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/ansi-styles/-/ansi-styles-5.2.0.tgz#07449690ad45777d1924ac2abb2fc8895dba836b" + integrity sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA== + +anymatch@^3.0.3: + version "3.1.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/anymatch/-/anymatch-3.1.3.tgz#790c58b19ba1720a84205b57c618d5ad8524973e" + integrity sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw== + dependencies: + normalize-path "^3.0.0" + picomatch "^2.0.4" + +argparse@^1.0.7: + version "1.0.10" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/argparse/-/argparse-1.0.10.tgz#bcd6791ea5ae09725e17e5ad988134cd40b3d911" + integrity sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg== + dependencies: + sprintf-js "~1.0.2" + +argparse@^2.0.1: + version "2.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/argparse/-/argparse-2.0.1.tgz#246f50f3ca78a3240f6c997e8a9bd1eac49e4b38" + integrity sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q== + +array-buffer-byte-length@^1.0.1, array-buffer-byte-length@^1.0.2: + version "1.0.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/array-buffer-byte-length/-/array-buffer-byte-length-1.0.2.tgz#384d12a37295aec3769ab022ad323a18a51ccf8b" + integrity sha512-LHE+8BuR7RYGDKvnrmcuSq3tDcKv9OFEXQt/HpbZhY7V6h0zlUXutnAD82GiFx9rdieCMjkvtcsPqBwgUl1Iiw== + dependencies: + call-bound "^1.0.3" + is-array-buffer "^3.0.5" + +array-includes@^3.1.8: + version "3.1.8" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/array-includes/3.1.8/array-includes-3.1.8.tgz#5e370cbe172fdd5dd6530c1d4aadda25281ba97d" + integrity sha1-XjcMvhcv3V3WUwwdSq3aJSgbqX0= + dependencies: + call-bind "^1.0.7" + define-properties "^1.2.1" + es-abstract "^1.23.2" + es-object-atoms "^1.0.0" + get-intrinsic "^1.2.4" + is-string "^1.0.7" + +array-union@^2.1.0: + version "2.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/array-union/2.1.0/array-union-2.1.0.tgz#b798420adbeb1de828d84acd8a2e23d3efe85e8d" + integrity sha1-t5hCCtvrHego2ErNii4j0+/oXo0= + +array.prototype.findlastindex@^1.2.5: + version "1.2.5" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/array.prototype.findlastindex/1.2.5/array.prototype.findlastindex-1.2.5.tgz#8c35a755c72908719453f87145ca011e39334d0d" + integrity sha1-jDWnVccpCHGUU/hxRcoBHjkzTQ0= + dependencies: + call-bind "^1.0.7" + define-properties "^1.2.1" + es-abstract "^1.23.2" + es-errors "^1.3.0" + es-object-atoms "^1.0.0" + es-shim-unscopables "^1.0.2" + +array.prototype.flat@^1.3.2: + version "1.3.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/array.prototype.flat/1.3.2/array.prototype.flat-1.3.2.tgz#1476217df8cff17d72ee8f3ba06738db5b387d18" + integrity sha1-FHYhffjP8X1y7o87oGc421s4fRg= + dependencies: + call-bind "^1.0.2" + define-properties "^1.2.0" + es-abstract "^1.22.1" + es-shim-unscopables "^1.0.0" + +array.prototype.flatmap@^1.3.2: + version "1.3.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/array.prototype.flatmap/-/array.prototype.flatmap-1.3.3.tgz#712cc792ae70370ae40586264629e33aab5dd38b" + integrity sha512-Y7Wt51eKJSyi80hFrJCePGGNo5ktJCslFuboqJsbf57CCPcm5zztluPlc4/aD8sWsKvlwatezpV4U1efk8kpjg== + dependencies: + call-bind "^1.0.8" + define-properties "^1.2.1" + es-abstract "^1.23.5" + es-shim-unscopables "^1.0.2" + +arraybuffer.prototype.slice@^1.0.4: + version "1.0.4" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/arraybuffer.prototype.slice/-/arraybuffer.prototype.slice-1.0.4.tgz#9d760d84dbdd06d0cbf92c8849615a1a7ab3183c" + integrity sha512-BNoCY6SXXPQ7gF2opIP4GBE+Xw7U+pHMYKuzjgCN3GwiaIR09UUeKfheyIry77QtrCBlC0KK0q5/TER/tYh3PQ== + dependencies: + array-buffer-byte-length "^1.0.1" + call-bind "^1.0.8" + define-properties "^1.2.1" + es-abstract "^1.23.5" + es-errors "^1.3.0" + get-intrinsic "^1.2.6" + is-array-buffer "^3.0.4" + +async@^3.2.3: + version "3.2.6" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/async/-/async-3.2.6.tgz#1b0728e14929d51b85b449b7f06e27c1145e38ce" + integrity sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA== + +available-typed-arrays@^1.0.7: + version "1.0.7" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/available-typed-arrays/1.0.7/available-typed-arrays-1.0.7.tgz#a5cc375d6a03c2efc87a553f3e0b1522def14846" + integrity sha1-pcw3XWoDwu/IelU/PgsVIt7xSEY= + dependencies: + possible-typed-array-names "^1.0.0" + +babel-jest@^29.7.0: + version "29.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/babel-jest/29.7.0/babel-jest-29.7.0.tgz#f4369919225b684c56085998ac63dbd05be020d5" + integrity sha1-9DaZGSJbaExWCFmYrGPb0FvgINU= + dependencies: + "@jest/transform" "^29.7.0" + "@types/babel__core" "^7.1.14" + babel-plugin-istanbul "^6.1.1" + babel-preset-jest "^29.6.3" + chalk "^4.0.0" + graceful-fs "^4.2.9" + slash "^3.0.0" + +babel-plugin-istanbul@^6.1.1: + version "6.1.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/babel-plugin-istanbul/6.1.1/babel-plugin-istanbul-6.1.1.tgz#fa88ec59232fd9b4e36dbbc540a8ec9a9b47da73" + integrity sha1-+ojsWSMv2bTjbbvFQKjsmptH2nM= + dependencies: + "@babel/helper-plugin-utils" "^7.0.0" + "@istanbuljs/load-nyc-config" "^1.0.0" + "@istanbuljs/schema" "^0.1.2" + istanbul-lib-instrument "^5.0.4" + test-exclude "^6.0.0" + +babel-plugin-jest-hoist@^29.6.3: + version "29.6.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/babel-plugin-jest-hoist/29.6.3/babel-plugin-jest-hoist-29.6.3.tgz#aadbe943464182a8922c3c927c3067ff40d24626" + integrity sha1-qtvpQ0ZBgqiSLDySfDBn/0DSRiY= + dependencies: + "@babel/template" "^7.3.3" + "@babel/types" "^7.3.3" + "@types/babel__core" "^7.1.14" + "@types/babel__traverse" "^7.0.6" + +babel-preset-current-node-syntax@^1.0.0: + version "1.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/babel-preset-current-node-syntax/-/babel-preset-current-node-syntax-1.1.0.tgz#9a929eafece419612ef4ae4f60b1862ebad8ef30" + integrity sha512-ldYss8SbBlWva1bs28q78Ju5Zq1F+8BrqBZZ0VFhLBvhh6lCpC2o3gDJi/5DRLs9FgYZCnmPYIVFU4lRXCkyUw== + dependencies: + "@babel/plugin-syntax-async-generators" "^7.8.4" + "@babel/plugin-syntax-bigint" "^7.8.3" + "@babel/plugin-syntax-class-properties" "^7.12.13" + "@babel/plugin-syntax-class-static-block" "^7.14.5" + "@babel/plugin-syntax-import-attributes" "^7.24.7" + "@babel/plugin-syntax-import-meta" "^7.10.4" + "@babel/plugin-syntax-json-strings" "^7.8.3" + "@babel/plugin-syntax-logical-assignment-operators" "^7.10.4" + "@babel/plugin-syntax-nullish-coalescing-operator" "^7.8.3" + "@babel/plugin-syntax-numeric-separator" "^7.10.4" + "@babel/plugin-syntax-object-rest-spread" "^7.8.3" + "@babel/plugin-syntax-optional-catch-binding" "^7.8.3" + "@babel/plugin-syntax-optional-chaining" "^7.8.3" + "@babel/plugin-syntax-private-property-in-object" "^7.14.5" + "@babel/plugin-syntax-top-level-await" "^7.14.5" + +babel-preset-jest@^29.6.3: + version "29.6.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/babel-preset-jest/29.6.3/babel-preset-jest-29.6.3.tgz#fa05fa510e7d493896d7b0dd2033601c840f171c" + integrity sha1-+gX6UQ59STiW17DdIDNgHIQPFxw= + dependencies: + babel-plugin-jest-hoist "^29.6.3" + babel-preset-current-node-syntax "^1.0.0" + +balanced-match@^1.0.0: + version "1.0.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/balanced-match/-/balanced-match-1.0.2.tgz#e83e3a7e3f300b34cb9d87f615fa0cbf357690ee" + integrity sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw== + +brace-expansion@^1.1.7: + version "1.1.11" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/brace-expansion/-/brace-expansion-1.1.11.tgz#3c7fcbf529d87226f3d2f52b966ff5271eb441dd" + integrity sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA== + dependencies: + balanced-match "^1.0.0" + concat-map "0.0.1" + +brace-expansion@^2.0.1: + version "2.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/brace-expansion/-/brace-expansion-2.0.1.tgz#1edc459e0f0c548486ecf9fc99f2221364b9a0ae" + integrity sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA== + dependencies: + balanced-match "^1.0.0" + +braces@^3.0.3: + version "3.0.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/braces/-/braces-3.0.3.tgz#490332f40919452272d55a8480adc0c441358789" + integrity sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA== + dependencies: + fill-range "^7.1.1" + +browserslist@^4.24.0: + version "4.25.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/browserslist/-/browserslist-4.25.0.tgz#986aa9c6d87916885da2b50d8eb577ac8d133b2c" + integrity sha512-PJ8gYKeS5e/whHBh8xrwYK+dAvEj7JXtz6uTucnMRB8OiGTsKccFekoRrjajPBHV8oOY+2tI4uxeceSimKwMFA== + dependencies: + caniuse-lite "^1.0.30001718" + electron-to-chromium "^1.5.160" + node-releases "^2.0.19" + update-browserslist-db "^1.1.3" + +bs-logger@^0.2.6: + version "0.2.6" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/bs-logger/-/bs-logger-0.2.6.tgz#eb7d365307a72cf974cc6cda76b68354ad336bd8" + integrity sha512-pd8DCoxmbgc7hyPKOvxtqNcjYoOsABPQdcCUjGp3d42VR2CX1ORhk2A87oqqu5R1kk+76nsxZupkmyd+MVtCog== + dependencies: + fast-json-stable-stringify "2.x" + +bser@2.1.1: + version "2.1.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/bser/-/bser-2.1.1.tgz#e6787da20ece9d07998533cfd9de6f5c38f4bc05" + integrity sha512-gQxTNE/GAfIIrmHLUE3oJyp5FO6HRBfhjnw4/wMmA63ZGDJnWBmgY/lyQBpnDUkGmAhbSe39tx2d/iTOAfglwQ== + dependencies: + node-int64 "^0.4.0" + +buffer-from@^1.0.0: + version "1.1.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/buffer-from/1.1.2/buffer-from-1.1.2.tgz#2b146a6fd72e80b4f55d255f35ed59a3a9a41bd5" + integrity sha1-KxRqb9cugLT1XSVfNe1Zo6mkG9U= + +call-bind-apply-helpers@^1.0.0, call-bind-apply-helpers@^1.0.1, call-bind-apply-helpers@^1.0.2: + version "1.0.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz#4b5428c222be985d79c3d82657479dbe0b59b2d6" + integrity sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ== + dependencies: + es-errors "^1.3.0" + function-bind "^1.1.2" + +call-bind@^1.0.2, call-bind@^1.0.7, call-bind@^1.0.8: + version "1.0.8" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/call-bind/-/call-bind-1.0.8.tgz#0736a9660f537e3388826f440d5ec45f744eaa4c" + integrity sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww== + dependencies: + call-bind-apply-helpers "^1.0.0" + es-define-property "^1.0.0" + get-intrinsic "^1.2.4" + set-function-length "^1.2.2" + +call-bound@^1.0.2, call-bound@^1.0.3, call-bound@^1.0.4: + version "1.0.4" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/call-bound/-/call-bound-1.0.4.tgz#238de935d2a2a692928c538c7ccfa91067fd062a" + integrity sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg== + dependencies: + call-bind-apply-helpers "^1.0.2" + get-intrinsic "^1.3.0" + +callsites@^3.0.0: + version "3.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/callsites/-/callsites-3.1.0.tgz#b3630abd8943432f54b3f0519238e33cd7df2f73" + integrity sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ== + +camelcase@^5.3.1: + version "5.3.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/camelcase/5.3.1/camelcase-5.3.1.tgz#e3c9b31569e106811df242f715725a1f4c494320" + integrity sha1-48mzFWnhBoEd8kL3FXJaH0xJQyA= + +camelcase@^6.2.0: + version "6.3.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/camelcase/-/camelcase-6.3.0.tgz#5685b95eb209ac9c0c177467778c9c84df58ba9a" + integrity sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA== + +caniuse-lite@^1.0.30001718: + version "1.0.30001720" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/caniuse-lite/-/caniuse-lite-1.0.30001720.tgz#c138cb6026d362be9d8d7b0e4bcd0183a850edfd" + integrity sha512-Ec/2yV2nNPwb4DnTANEV99ZWwm3ZWfdlfkQbWSDDt+PsXEVYwlhPH8tdMaPunYTKKmz7AnHi2oNEi1GcmKCD8g== + +chalk@^4.0.0, chalk@^4.0.2: + version "4.1.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/chalk/-/chalk-4.1.2.tgz#aac4e2b7734a740867aeb16bf02aad556a1e7a01" + integrity sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA== + dependencies: + ansi-styles "^4.1.0" + supports-color "^7.1.0" + +char-regex@^1.0.2: + version "1.0.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/char-regex/1.0.2/char-regex-1.0.2.tgz#d744358226217f981ed58f479b1d6bcc29545dcf" + integrity sha1-10Q1giYhf5ge1Y9Hmx1rzClUXc8= + +chardet@^0.7.0: + version "0.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/chardet/0.7.0/chardet-0.7.0.tgz#90094849f0937f2eedc2425d0d28a9e5f0cbad9e" + integrity sha1-kAlISfCTfy7twkJdDSip5fDLrZ4= + +ci-info@^3.2.0: + version "3.9.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/ci-info/-/ci-info-3.9.0.tgz#4279a62028a7b1f262f3473fc9605f5e218c59b4" + integrity sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ== + +cjs-module-lexer@^1.0.0: + version "1.4.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/cjs-module-lexer/-/cjs-module-lexer-1.4.3.tgz#0f79731eb8cfe1ec72acd4066efac9d61991b00d" + integrity sha512-9z8TZaGM1pfswYeXrUpzPrkx8UnWYdhJclsiYMm6x/w5+nN+8Tf/LnAgfLGQCm59qAOxU8WwHEq2vNwF6i4j+Q== + +cli-width@^4.1.0: + version "4.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/cli-width/-/cli-width-4.1.0.tgz#42daac41d3c254ef38ad8ac037672130173691c5" + integrity sha512-ouuZd4/dm2Sw5Gmqy6bGyNNNe1qt9RpmxveLSO7KcgsTnU7RXfsw+/bukWGo1abgBiMAic068rclZsO4IWmmxQ== + +cliui@^8.0.1: + version "8.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/cliui/-/cliui-8.0.1.tgz#0c04b075db02cbfe60dc8e6cf2f5486b1a3608aa" + integrity sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ== + dependencies: + string-width "^4.2.0" + strip-ansi "^6.0.1" + wrap-ansi "^7.0.0" + +co@^4.6.0: + version "4.6.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/co/4.6.0/co-4.6.0.tgz#6ea6bdf3d853ae54ccb8e47bfa0bf3f9031fb184" + integrity sha1-bqa989hTrlTMuOR7+gvz+QMfsYQ= + +collect-v8-coverage@^1.0.0: + version "1.0.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/collect-v8-coverage/1.0.2/collect-v8-coverage-1.0.2.tgz#c0b29bcd33bcd0779a1344c2136051e6afd3d9e9" + integrity sha1-wLKbzTO80HeaE0TCE2BR5q/T2ek= + +color-convert@^2.0.1: + version "2.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/color-convert/-/color-convert-2.0.1.tgz#72d3a68d598c9bdb3af2ad1e84f21d896abd4de3" + integrity sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ== + dependencies: + color-name "~1.1.4" + +color-name@~1.1.4: + version "1.1.4" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/color-name/-/color-name-1.1.4.tgz#c2a09a87acbde69543de6f63fa3995c826c536a2" + integrity sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA== + +commander@^13.1.0: + version "13.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/commander/-/commander-13.1.0.tgz#776167db68c78f38dcce1f9b8d7b8b9a488abf46" + integrity sha512-/rFeCpNJQbhSZjGVwO9RFV3xPqbnERS8MmIQzCtD/zl6gpJuV/bMLuN92oG3F7d8oDEHHRrujSXNUr8fpjntKw== + +concat-map@0.0.1: + version "0.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b" + integrity sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg== + +convert-source-map@^2.0.0: + version "2.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/convert-source-map/-/convert-source-map-2.0.0.tgz#4b560f649fc4e918dd0ab75cf4961e8bc882d82a" + integrity sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg== + +create-jest@^29.7.0: + version "29.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/create-jest/29.7.0/create-jest-29.7.0.tgz#a355c5b3cb1e1af02ba177fe7afd7feee49a5320" + integrity sha1-o1XFs8seGvAroXf+ev1/7uSaUyA= + dependencies: + "@jest/types" "^29.6.3" + chalk "^4.0.0" + exit "^0.1.2" + graceful-fs "^4.2.9" + jest-config "^29.7.0" + jest-util "^29.7.0" + prompts "^2.0.1" + +cross-spawn@^7.0.2, cross-spawn@^7.0.3: + version "7.0.6" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/cross-spawn/-/cross-spawn-7.0.6.tgz#8a58fe78f00dcd70c370451759dfbfaf03e8ee9f" + integrity sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA== + dependencies: + path-key "^3.1.0" + shebang-command "^2.0.0" + which "^2.0.1" + +data-view-buffer@^1.0.2: + version "1.0.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/data-view-buffer/-/data-view-buffer-1.0.2.tgz#211a03ba95ecaf7798a8c7198d79536211f88570" + integrity sha512-EmKO5V3OLXh1rtK2wgXRansaK1/mtVdTUEiEI0W8RkvgT05kfxaH29PliLnpLP73yYO6142Q72QNa8Wx/A5CqQ== + dependencies: + call-bound "^1.0.3" + es-errors "^1.3.0" + is-data-view "^1.0.2" + +data-view-byte-length@^1.0.2: + version "1.0.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/data-view-byte-length/-/data-view-byte-length-1.0.2.tgz#9e80f7ca52453ce3e93d25a35318767ea7704735" + integrity sha512-tuhGbE6CfTM9+5ANGf+oQb72Ky/0+s3xKUpHvShfiz2RxMFgFPjsXuRLBVMtvMs15awe45SRb83D6wH4ew6wlQ== + dependencies: + call-bound "^1.0.3" + es-errors "^1.3.0" + is-data-view "^1.0.2" + +data-view-byte-offset@^1.0.1: + version "1.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/data-view-byte-offset/-/data-view-byte-offset-1.0.1.tgz#068307f9b71ab76dbbe10291389e020856606191" + integrity sha512-BS8PfmtDGnrgYdOonGZQdLZslWIeCGFP9tpan0hi1Co2Zr2NKADsvGYA8XxuG/4UWgJ6Cjtv+YJnB6MM69QGlQ== + dependencies: + call-bound "^1.0.2" + es-errors "^1.3.0" + is-data-view "^1.0.1" + +debug@^3.2.7: + version "3.2.7" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/debug/3.2.7/debug-3.2.7.tgz#72580b7e9145fb39b6676f9c5e5fb100b934179a" + integrity sha1-clgLfpFF+zm2Z2+cXl+xALk0F5o= + dependencies: + ms "^2.1.1" + +debug@^4.1.0, debug@^4.1.1, debug@^4.3.1, debug@^4.3.2, debug@^4.3.4: + version "4.4.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/debug/-/debug-4.4.1.tgz#e5a8bc6cbc4c6cd3e64308b0693a3d4fa550189b" + integrity sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ== + dependencies: + ms "^2.1.3" + +dedent@^1.0.0: + version "1.6.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/dedent/-/dedent-1.6.0.tgz#79d52d6389b1ffa67d2bcef59ba51847a9d503b2" + integrity sha512-F1Z+5UCFpmQUzJa11agbyPVMbpgT/qA3/SKyJ1jyBgm7dUcUEa8v9JwDkerSQXfakBwFljIxhOJqGkjUwZ9FSA== + +deep-is@^0.1.3: + version "0.1.4" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/deep-is/-/deep-is-0.1.4.tgz#a6f2dce612fadd2ef1f519b73551f17e85199831" + integrity sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ== + +deepmerge@^4.2.2: + version "4.3.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/deepmerge/4.3.1/deepmerge-4.3.1.tgz#44b5f2147cd3b00d4b56137685966f26fd25dd4a" + integrity sha1-RLXyFHzTsA1LVhN2hZZvJv0l3Uo= + +define-data-property@^1.0.1, define-data-property@^1.1.4: + version "1.1.4" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/define-data-property/-/define-data-property-1.1.4.tgz#894dc141bb7d3060ae4366f6a0107e68fbe48c5e" + integrity sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A== + dependencies: + es-define-property "^1.0.0" + es-errors "^1.3.0" + gopd "^1.0.1" + +define-properties@^1.2.0, define-properties@^1.2.1: + version "1.2.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/define-properties/-/define-properties-1.2.1.tgz#10781cc616eb951a80a034bafcaa7377f6af2b6c" + integrity sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg== + dependencies: + define-data-property "^1.0.1" + has-property-descriptors "^1.0.0" + object-keys "^1.1.1" + +detect-newline@^3.0.0: + version "3.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/detect-newline/3.1.0/detect-newline-3.1.0.tgz#576f5dfc63ae1a192ff192d8ad3af6308991b651" + integrity sha1-V29d/GOuGhkv8ZLYrTr2MImRtlE= + +diff-sequences@^29.6.3: + version "29.6.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/diff-sequences/29.6.3/diff-sequences-29.6.3.tgz#4deaf894d11407c51efc8418012f9e70b84ea921" + integrity sha1-Ter4lNEUB8Ue/IQYAS+ecLhOqSE= + +dir-glob@^3.0.1: + version "3.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/dir-glob/3.0.1/dir-glob-3.0.1.tgz#56dbf73d992a4a93ba1584f4534063fd2e41717f" + integrity sha1-Vtv3PZkqSpO6FYT0U0Bj/S5BcX8= + dependencies: + path-type "^4.0.0" + +doctrine@^2.1.0: + version "2.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/doctrine/2.1.0/doctrine-2.1.0.tgz#5cd01fc101621b42c4cd7f5d1a66243716d3f39d" + integrity sha1-XNAfwQFiG0LEzX9dGmYkNxbT850= + dependencies: + esutils "^2.0.2" + +doctrine@^3.0.0: + version "3.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/doctrine/-/doctrine-3.0.0.tgz#addebead72a6574db783639dc87a121773973961" + integrity sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w== + dependencies: + esutils "^2.0.2" + +dunder-proto@^1.0.0, dunder-proto@^1.0.1: + version "1.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/dunder-proto/-/dunder-proto-1.0.1.tgz#d7ae667e1dc83482f8b70fd0f6eefc50da30f58a" + integrity sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A== + dependencies: + call-bind-apply-helpers "^1.0.1" + es-errors "^1.3.0" + gopd "^1.2.0" + +ejs@^3.1.10: + version "3.1.10" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/ejs/3.1.10/ejs-3.1.10.tgz#69ab8358b14e896f80cc39e62087b88500c3ac3b" + integrity sha1-aauDWLFOiW+AzDnmIIe4hQDDrDs= + dependencies: + jake "^10.8.5" + +electron-to-chromium@^1.5.160: + version "1.5.160" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/electron-to-chromium/-/electron-to-chromium-1.5.160.tgz#243fa46b82563dbce23812d73b196d5a21cba3eb" + integrity sha512-8yQk54/CoCQT8GX3zuxqPBwMAQuIr6dWI/qO8Aah/JAZwB5XmCbEElsqb1n4pzc2vpkTdfc/kbyNPJOjswfbgg== + +emittery@^0.13.1: + version "0.13.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/emittery/0.13.1/emittery-0.13.1.tgz#c04b8c3457490e0847ae51fced3af52d338e3dad" + integrity sha1-wEuMNFdJDghHrlH87Tr1LTOOPa0= + +emoji-regex@^8.0.0: + version "8.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/emoji-regex/-/emoji-regex-8.0.0.tgz#e818fd69ce5ccfcb404594f842963bf53164cc37" + integrity sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A== + +enhanced-resolve@^5.12.0: + version "5.18.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/enhanced-resolve/-/enhanced-resolve-5.18.1.tgz#728ab082f8b7b6836de51f1637aab5d3b9568faf" + integrity sha512-ZSW3ma5GkcQBIpwZTSRAI8N71Uuwgs93IezB7mf7R60tC8ZbJideoDNKjHn2O9KIlx6rkGTTEk1xUCK2E1Y2Yg== + dependencies: + graceful-fs "^4.2.4" + tapable "^2.2.0" + +error-ex@^1.3.1: + version "1.3.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/error-ex/-/error-ex-1.3.2.tgz#b4ac40648107fdcdcfae242f428bea8a14d4f1bf" + integrity sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g== + dependencies: + is-arrayish "^0.2.1" + +es-abstract@^1.22.1, es-abstract@^1.23.2, es-abstract@^1.23.5, es-abstract@^1.23.9: + version "1.23.9" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/es-abstract/-/es-abstract-1.23.9.tgz#5b45994b7de78dada5c1bebf1379646b32b9d606" + integrity sha512-py07lI0wjxAC/DcfK1S6G7iANonniZwTISvdPzk9hzeH0IZIshbuuFxLIU96OyF89Yb9hiqWn8M/bY83KY5vzA== + dependencies: + array-buffer-byte-length "^1.0.2" + arraybuffer.prototype.slice "^1.0.4" + available-typed-arrays "^1.0.7" + call-bind "^1.0.8" + call-bound "^1.0.3" + data-view-buffer "^1.0.2" + data-view-byte-length "^1.0.2" + data-view-byte-offset "^1.0.1" + es-define-property "^1.0.1" + es-errors "^1.3.0" + es-object-atoms "^1.0.0" + es-set-tostringtag "^2.1.0" + es-to-primitive "^1.3.0" + function.prototype.name "^1.1.8" + get-intrinsic "^1.2.7" + get-proto "^1.0.0" + get-symbol-description "^1.1.0" + globalthis "^1.0.4" + gopd "^1.2.0" + has-property-descriptors "^1.0.2" + has-proto "^1.2.0" + has-symbols "^1.1.0" + hasown "^2.0.2" + internal-slot "^1.1.0" + is-array-buffer "^3.0.5" + is-callable "^1.2.7" + is-data-view "^1.0.2" + is-regex "^1.2.1" + is-shared-array-buffer "^1.0.4" + is-string "^1.1.1" + is-typed-array "^1.1.15" + is-weakref "^1.1.0" + math-intrinsics "^1.1.0" + object-inspect "^1.13.3" + object-keys "^1.1.1" + object.assign "^4.1.7" + own-keys "^1.0.1" + regexp.prototype.flags "^1.5.3" + safe-array-concat "^1.1.3" + safe-push-apply "^1.0.0" + safe-regex-test "^1.1.0" + set-proto "^1.0.0" + string.prototype.trim "^1.2.10" + string.prototype.trimend "^1.0.9" + string.prototype.trimstart "^1.0.8" + typed-array-buffer "^1.0.3" + typed-array-byte-length "^1.0.3" + typed-array-byte-offset "^1.0.4" + typed-array-length "^1.0.7" + unbox-primitive "^1.1.0" + which-typed-array "^1.1.18" + +es-define-property@^1.0.0, es-define-property@^1.0.1: + version "1.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/es-define-property/-/es-define-property-1.0.1.tgz#983eb2f9a6724e9303f61addf011c72e09e0b0fa" + integrity sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g== + +es-errors@^1.3.0: + version "1.3.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/es-errors/-/es-errors-1.3.0.tgz#05f75a25dab98e4fb1dcd5e1472c0546d5057c8f" + integrity sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw== + +es-object-atoms@^1.0.0, es-object-atoms@^1.1.1: + version "1.1.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/es-object-atoms/-/es-object-atoms-1.1.1.tgz#1c4f2c4837327597ce69d2ca190a7fdd172338c1" + integrity sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA== + dependencies: + es-errors "^1.3.0" + +es-set-tostringtag@^2.1.0: + version "2.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz#f31dbbe0c183b00a6d26eb6325c810c0fd18bd4d" + integrity sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA== + dependencies: + es-errors "^1.3.0" + get-intrinsic "^1.2.6" + has-tostringtag "^1.0.2" + hasown "^2.0.2" + +es-shim-unscopables@^1.0.0, es-shim-unscopables@^1.0.2: + version "1.0.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/es-shim-unscopables/1.0.2/es-shim-unscopables-1.0.2.tgz#1f6942e71ecc7835ed1c8a83006d8771a63a3763" + integrity sha1-H2lC5x7MeDXtHIqDAG2HcaY6N2M= + dependencies: + hasown "^2.0.0" + +es-to-primitive@^1.3.0: + version "1.3.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/es-to-primitive/-/es-to-primitive-1.3.0.tgz#96c89c82cc49fd8794a24835ba3e1ff87f214e18" + integrity sha512-w+5mJ3GuFL+NjVtJlvydShqE1eN3h3PbI7/5LAsYJP/2qtuMXjfL2LpHSRqo4b4eSF5K/DH1JXKUAHSB2UW50g== + dependencies: + is-callable "^1.2.7" + is-date-object "^1.0.5" + is-symbol "^1.0.4" + +escalade@^3.1.1, escalade@^3.2.0: + version "3.2.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/escalade/-/escalade-3.2.0.tgz#011a3f69856ba189dffa7dc8fcce99d2a87903e5" + integrity sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA== + +escape-string-regexp@^2.0.0: + version "2.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/escape-string-regexp/2.0.0/escape-string-regexp-2.0.0.tgz#a30304e99daa32e23b2fd20f51babd07cffca344" + integrity sha1-owME6Z2qMuI7L9IPUbq9B8/8o0Q= + +escape-string-regexp@^4.0.0: + version "4.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz#14ba83a5d373e3d311e5afca29cf5bfad965bf34" + integrity sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA== + +eslint-config-prettier@^8.10.0: + version "8.10.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/eslint-config-prettier/8.10.0/eslint-config-prettier-8.10.0.tgz#3a06a662130807e2502fc3ff8b4143d8a0658e11" + integrity sha1-OgamYhMIB+JQL8P/i0FD2KBljhE= + +eslint-import-resolver-node@^0.3.9: + version "0.3.9" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/eslint-import-resolver-node/0.3.9/eslint-import-resolver-node-0.3.9.tgz#d4eaac52b8a2e7c3cd1903eb00f7e053356118ac" + integrity sha1-1OqsUrii58PNGQPrAPfgUzVhGKw= + dependencies: + debug "^3.2.7" + is-core-module "^2.13.0" + resolve "^1.22.4" + +eslint-import-resolver-typescript@^3.6.1: + version "3.6.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/eslint-import-resolver-typescript/3.6.1/eslint-import-resolver-typescript-3.6.1.tgz#7b983680edd3f1c5bce1a5829ae0bc2d57fe9efa" + integrity sha1-e5g2gO3T8cW84aWCmuC8LVf+nvo= + dependencies: + debug "^4.3.4" + enhanced-resolve "^5.12.0" + eslint-module-utils "^2.7.4" + fast-glob "^3.3.1" + get-tsconfig "^4.5.0" + is-core-module "^2.11.0" + is-glob "^4.0.3" + +eslint-module-utils@^2.12.0, eslint-module-utils@^2.7.4: + version "2.12.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/eslint-module-utils/-/eslint-module-utils-2.12.0.tgz#fe4cfb948d61f49203d7b08871982b65b9af0b0b" + integrity sha512-wALZ0HFoytlyh/1+4wuZ9FJCD/leWHQzzrxJ8+rebyReSLk7LApMyd3WJaLVoN+D5+WIdJyDK1c6JnE65V4Zyg== + dependencies: + debug "^3.2.7" + +eslint-plugin-import@^2.29.1: + version "2.31.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/eslint-plugin-import/-/eslint-plugin-import-2.31.0.tgz#310ce7e720ca1d9c0bb3f69adfd1c6bdd7d9e0e7" + integrity sha512-ixmkI62Rbc2/w8Vfxyh1jQRTdRTF52VxwRVHl/ykPAmqG+Nb7/kNn+byLP0LxPgI7zWA16Jt82SybJInmMia3A== + dependencies: + "@rtsao/scc" "^1.1.0" + array-includes "^3.1.8" + array.prototype.findlastindex "^1.2.5" + array.prototype.flat "^1.3.2" + array.prototype.flatmap "^1.3.2" + debug "^3.2.7" + doctrine "^2.1.0" + eslint-import-resolver-node "^0.3.9" + eslint-module-utils "^2.12.0" + hasown "^2.0.2" + is-core-module "^2.15.1" + is-glob "^4.0.3" + minimatch "^3.1.2" + object.fromentries "^2.0.8" + object.groupby "^1.0.3" + object.values "^1.2.0" + semver "^6.3.1" + string.prototype.trimend "^1.0.8" + tsconfig-paths "^3.15.0" + +eslint-plugin-prettier@^5.1.3: + version "5.2.6" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/eslint-plugin-prettier/-/eslint-plugin-prettier-5.2.6.tgz#be39e3bb23bb3eeb7e7df0927cdb46e4d7945096" + integrity sha512-mUcf7QG2Tjk7H055Jk0lGBjbgDnfrvqjhXh9t2xLMSCjZVcw9Rb1V6sVNXO0th3jgeO7zllWPTNRil3JW94TnQ== + dependencies: + prettier-linter-helpers "^1.0.0" + synckit "^0.11.0" + +eslint-plugin-simple-import-sort@^10.0.0: + version "10.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/eslint-plugin-simple-import-sort/10.0.0/eslint-plugin-simple-import-sort-10.0.0.tgz#cc4ceaa81ba73252427062705b64321946f61351" + integrity sha1-zEzqqBunMlJCcGJwW2QyGUb2E1E= + +eslint-scope@^5.1.1: + version "5.1.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/eslint-scope/5.1.1/eslint-scope-5.1.1.tgz#e786e59a66cb92b3f6c1fb0d508aab174848f48c" + integrity sha1-54blmmbLkrP2wfsNUIqrF0hI9Iw= + dependencies: + esrecurse "^4.3.0" + estraverse "^4.1.1" + +eslint-scope@^7.2.2: + version "7.2.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/eslint-scope/7.2.2/eslint-scope-7.2.2.tgz#deb4f92563390f32006894af62a22dba1c46423f" + integrity sha1-3rT5JWM5DzIAaJSvYqItuhxGQj8= + dependencies: + esrecurse "^4.3.0" + estraverse "^5.2.0" + +eslint-visitor-keys@^3.3.0, eslint-visitor-keys@^3.4.1, eslint-visitor-keys@^3.4.3: + version "3.4.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz#0cd72fe8550e3c2eae156a96a4dddcd1c8ac5800" + integrity sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag== + +eslint@^8.43.0: + version "8.57.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/eslint/-/eslint-8.57.1.tgz#7df109654aba7e3bbe5c8eae533c5e461d3c6ca9" + integrity sha512-ypowyDxpVSYpkXr9WPv2PAZCtNip1Mv5KTW0SCurXv/9iOpcrH9PaqUElksqEB6pChqHGDRCFTyrZlGhnLNGiA== + dependencies: + "@eslint-community/eslint-utils" "^4.2.0" + "@eslint-community/regexpp" "^4.6.1" + "@eslint/eslintrc" "^2.1.4" + "@eslint/js" "8.57.1" + "@humanwhocodes/config-array" "^0.13.0" + "@humanwhocodes/module-importer" "^1.0.1" + "@nodelib/fs.walk" "^1.2.8" + "@ungap/structured-clone" "^1.2.0" + ajv "^6.12.4" + chalk "^4.0.0" + cross-spawn "^7.0.2" + debug "^4.3.2" + doctrine "^3.0.0" + escape-string-regexp "^4.0.0" + eslint-scope "^7.2.2" + eslint-visitor-keys "^3.4.3" + espree "^9.6.1" + esquery "^1.4.2" + esutils "^2.0.2" + fast-deep-equal "^3.1.3" + file-entry-cache "^6.0.1" + find-up "^5.0.0" + glob-parent "^6.0.2" + globals "^13.19.0" + graphemer "^1.4.0" + ignore "^5.2.0" + imurmurhash "^0.1.4" + is-glob "^4.0.0" + is-path-inside "^3.0.3" + js-yaml "^4.1.0" + json-stable-stringify-without-jsonify "^1.0.1" + levn "^0.4.1" + lodash.merge "^4.6.2" + minimatch "^3.1.2" + natural-compare "^1.4.0" + optionator "^0.9.3" + strip-ansi "^6.0.1" + text-table "^0.2.0" + +espree@^9.6.0, espree@^9.6.1: + version "9.6.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/espree/9.6.1/espree-9.6.1.tgz#a2a17b8e434690a5432f2f8018ce71d331a48c6f" + integrity sha1-oqF7jkNGkKVDLy+AGM5x0zGkjG8= + dependencies: + acorn "^8.9.0" + acorn-jsx "^5.3.2" + eslint-visitor-keys "^3.4.1" + +esprima@^4.0.0: + version "4.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/esprima/-/esprima-4.0.1.tgz#13b04cdb3e6c5d19df91ab6987a8695619b0aa71" + integrity sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A== + +esquery@^1.4.2: + version "1.6.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/esquery/-/esquery-1.6.0.tgz#91419234f804d852a82dceec3e16cdc22cf9dae7" + integrity sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg== + dependencies: + estraverse "^5.1.0" + +esrecurse@^4.3.0: + version "4.3.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/esrecurse/-/esrecurse-4.3.0.tgz#7ad7964d679abb28bee72cec63758b1c5d2c9921" + integrity sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag== + dependencies: + estraverse "^5.2.0" + +estraverse@^4.1.1: + version "4.3.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/estraverse/4.3.0/estraverse-4.3.0.tgz#398ad3f3c5a24948be7725e83d11a7de28cdbd1d" + integrity sha1-OYrT88WiSUi+dyXoPRGn3ijNvR0= + +estraverse@^5.1.0, estraverse@^5.2.0: + version "5.3.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/estraverse/-/estraverse-5.3.0.tgz#2eea5290702f26ab8fe5370370ff86c965d21123" + integrity sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA== + +esutils@^2.0.2: + version "2.0.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/esutils/-/esutils-2.0.3.tgz#74d2eb4de0b8da1293711910d50775b9b710ef64" + integrity sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g== + +execa@^5.0.0: + version "5.1.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/execa/5.1.1/execa-5.1.1.tgz#f80ad9cbf4298f7bd1d4c9555c21e93741c411dd" + integrity sha1-+ArZy/Qpj3vR1MlVXCHpN0HEEd0= + dependencies: + cross-spawn "^7.0.3" + get-stream "^6.0.0" + human-signals "^2.1.0" + is-stream "^2.0.0" + merge-stream "^2.0.0" + npm-run-path "^4.0.1" + onetime "^5.1.2" + signal-exit "^3.0.3" + strip-final-newline "^2.0.0" + +exit@^0.1.2: + version "0.1.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/exit/0.1.2/exit-0.1.2.tgz#0632638f8d877cc82107d30a0fff1a17cba1cd0c" + integrity sha1-BjJjj42HfMghB9MKD/8aF8uhzQw= + +expect@^29.0.0, expect@^29.7.0: + version "29.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/expect/29.7.0/expect-29.7.0.tgz#578874590dcb3214514084c08115d8aee61e11bc" + integrity sha1-V4h0WQ3LMhRRQITAgRXYruYeEbw= + dependencies: + "@jest/expect-utils" "^29.7.0" + jest-get-type "^29.6.3" + jest-matcher-utils "^29.7.0" + jest-message-util "^29.7.0" + jest-util "^29.7.0" + +external-editor@^3.1.0: + version "3.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/external-editor/-/external-editor-3.1.0.tgz#cb03f740befae03ea4d283caed2741a83f335495" + integrity sha512-hMQ4CX1p1izmuLYyZqLMO/qGNw10wSv9QDCPfzXfyFrOaCSSoRfqE1Kf1s5an66J5JZC62NewG+mK49jOCtQew== + dependencies: + chardet "^0.7.0" + iconv-lite "^0.4.24" + tmp "^0.0.33" + +fast-deep-equal@^3.1.1, fast-deep-equal@^3.1.3: + version "3.1.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz#3a7d56b559d6cbc3eb512325244e619a65c6c525" + integrity sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q== + +fast-diff@^1.1.2: + version "1.3.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/fast-diff/1.3.0/fast-diff-1.3.0.tgz#ece407fa550a64d638536cd727e129c61616e0f0" + integrity sha1-7OQH+lUKZNY4U2zXJ+EpxhYW4PA= + +fast-glob@^3.2.9, fast-glob@^3.3.1: + version "3.3.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/fast-glob/-/fast-glob-3.3.3.tgz#d06d585ce8dba90a16b0505c543c3ccfb3aeb818" + integrity sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg== + dependencies: + "@nodelib/fs.stat" "^2.0.2" + "@nodelib/fs.walk" "^1.2.3" + glob-parent "^5.1.2" + merge2 "^1.3.0" + micromatch "^4.0.8" + +fast-json-stable-stringify@2.x, fast-json-stable-stringify@^2.0.0, fast-json-stable-stringify@^2.1.0: + version "2.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz#874bf69c6f404c2b5d99c481341399fd55892633" + integrity sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw== + +fast-levenshtein@^2.0.6: + version "2.0.6" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz#3d8a5c66883a16a30ca8643e851f19baa7797917" + integrity sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw== + +fastq@^1.6.0: + version "1.19.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/fastq/-/fastq-1.19.1.tgz#d50eaba803c8846a883c16492821ebcd2cda55f5" + integrity sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ== + dependencies: + reusify "^1.0.4" + +fb-watchman@^2.0.0: + version "2.0.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/fb-watchman/-/fb-watchman-2.0.2.tgz#e9524ee6b5c77e9e5001af0f85f3adbb8623255c" + integrity sha512-p5161BqbuCaSnB8jIbzQHOlpgsPmK5rJVDfDKO91Axs5NC1uu3HRQm6wt9cd9/+GtQQIO53JdGXXoyDpTAsgYA== + dependencies: + bser "2.1.1" + +fflate@^0.8.2: + version "0.8.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/fflate/-/fflate-0.8.2.tgz#fc8631f5347812ad6028bbe4a2308b2792aa1dea" + integrity sha512-cPJU47OaAoCbg0pBvzsgpTPhmhqI5eJjh/JIu8tPj5q+T7iLvW/JAYUqmE7KOB4R1ZyEhzBaIQpQpardBF5z8A== + +file-entry-cache@^6.0.1: + version "6.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/file-entry-cache/6.0.1/file-entry-cache-6.0.1.tgz#211b2dd9659cb0394b073e7323ac3c933d522027" + integrity sha1-IRst2WWcsDlLBz5zI6w8kz1SICc= + dependencies: + flat-cache "^3.0.4" + +filelist@^1.0.4: + version "1.0.4" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/filelist/1.0.4/filelist-1.0.4.tgz#f78978a1e944775ff9e62e744424f215e58352b5" + integrity sha1-94l4oelEd1/55i50RCTyFeWDUrU= + dependencies: + minimatch "^5.0.1" + +fill-range@^7.1.1: + version "7.1.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/fill-range/-/fill-range-7.1.1.tgz#44265d3cac07e3ea7dc247516380643754a05292" + integrity sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg== + dependencies: + to-regex-range "^5.0.1" + +find-up@^4.0.0, find-up@^4.1.0: + version "4.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/find-up/4.1.0/find-up-4.1.0.tgz#97afe7d6cdc0bc5928584b7c8d7b16e8a9aa5d19" + integrity sha1-l6/n1s3AvFkoWEt8jXsW6KmqXRk= + dependencies: + locate-path "^5.0.0" + path-exists "^4.0.0" + +find-up@^5.0.0: + version "5.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/find-up/-/find-up-5.0.0.tgz#4c92819ecb7083561e4f4a240a86be5198f536fc" + integrity sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng== + dependencies: + locate-path "^6.0.0" + path-exists "^4.0.0" + +flat-cache@^3.0.4: + version "3.2.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/flat-cache/3.2.0/flat-cache-3.2.0.tgz#2c0c2d5040c99b1632771a9d105725c0115363ee" + integrity sha1-LAwtUEDJmxYydxqdEFclwBFTY+4= + dependencies: + flatted "^3.2.9" + keyv "^4.5.3" + rimraf "^3.0.2" + +flatted@^3.2.9: + version "3.3.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/flatted/-/flatted-3.3.3.tgz#67c8fad95454a7c7abebf74bb78ee74a44023358" + integrity sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg== + +for-each@^0.3.3, for-each@^0.3.5: + version "0.3.5" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/for-each/-/for-each-0.3.5.tgz#d650688027826920feeb0af747ee7b9421a41d47" + integrity sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg== + dependencies: + is-callable "^1.2.7" + +fs.realpath@^1.0.0: + version "1.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/fs.realpath/-/fs.realpath-1.0.0.tgz#1504ad2523158caa40db4a2787cb01411994ea4f" + integrity sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw== + +fsevents@^2.3.2: + version "2.3.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/fsevents/-/fsevents-2.3.3.tgz#cac6407785d03675a2a5e1a5305c697b347d90d6" + integrity sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw== + +function-bind@^1.1.2: + version "1.1.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/function-bind/-/function-bind-1.1.2.tgz#2c02d864d97f3ea6c8830c464cbd11ab6eab7a1c" + integrity sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA== + +function.prototype.name@^1.1.6, function.prototype.name@^1.1.8: + version "1.1.8" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/function.prototype.name/-/function.prototype.name-1.1.8.tgz#e68e1df7b259a5c949eeef95cdbde53edffabb78" + integrity sha512-e5iwyodOHhbMr/yNrc7fDYG4qlbIvI5gajyzPnb5TCwyhjApznQh1BMFou9b30SevY43gCJKXycoCBjMbsuW0Q== + dependencies: + call-bind "^1.0.8" + call-bound "^1.0.3" + define-properties "^1.2.1" + functions-have-names "^1.2.3" + hasown "^2.0.2" + is-callable "^1.2.7" + +functions-have-names@^1.2.3: + version "1.2.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/functions-have-names/1.2.3/functions-have-names-1.2.3.tgz#0404fe4ee2ba2f607f0e0ec3c80bae994133b834" + integrity sha1-BAT+TuK6L2B/Dg7DyAuumUEzuDQ= + +gensync@^1.0.0-beta.2: + version "1.0.0-beta.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/gensync/-/gensync-1.0.0-beta.2.tgz#32a6ee76c3d7f52d46b2b1ae5d93fea8580a25e0" + integrity sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg== + +get-caller-file@^2.0.5: + version "2.0.5" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/get-caller-file/-/get-caller-file-2.0.5.tgz#4f94412a82db32f36e3b0b9741f8a97feb031f7e" + integrity sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg== + +get-intrinsic@^1.2.4, get-intrinsic@^1.2.5, get-intrinsic@^1.2.6, get-intrinsic@^1.2.7, get-intrinsic@^1.3.0: + version "1.3.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/get-intrinsic/-/get-intrinsic-1.3.0.tgz#743f0e3b6964a93a5491ed1bffaae054d7f98d01" + integrity sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ== + dependencies: + call-bind-apply-helpers "^1.0.2" + es-define-property "^1.0.1" + es-errors "^1.3.0" + es-object-atoms "^1.1.1" + function-bind "^1.1.2" + get-proto "^1.0.1" + gopd "^1.2.0" + has-symbols "^1.1.0" + hasown "^2.0.2" + math-intrinsics "^1.1.0" + +get-package-type@^0.1.0: + version "0.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/get-package-type/0.1.0/get-package-type-0.1.0.tgz#8de2d803cff44df3bc6c456e6668b36c3926e11a" + integrity sha1-jeLYA8/0TfO8bEVuZmizbDkm4Ro= + +get-proto@^1.0.0, get-proto@^1.0.1: + version "1.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/get-proto/-/get-proto-1.0.1.tgz#150b3f2743869ef3e851ec0c49d15b1d14d00ee1" + integrity sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g== + dependencies: + dunder-proto "^1.0.1" + es-object-atoms "^1.0.0" + +get-stream@^6.0.0: + version "6.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/get-stream/6.0.1/get-stream-6.0.1.tgz#a262d8eef67aced57c2852ad6167526a43cbf7b7" + integrity sha1-omLY7vZ6ztV8KFKtYWdSakPL97c= + +get-symbol-description@^1.1.0: + version "1.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/get-symbol-description/-/get-symbol-description-1.1.0.tgz#7bdd54e0befe8ffc9f3b4e203220d9f1e881b6ee" + integrity sha512-w9UMqWwJxHNOvoNzSJ2oPF5wvYcvP7jUvYzhp67yEhTi17ZDBBC1z9pTdGuzjD+EFIqLSYRweZjqfiPzQ06Ebg== + dependencies: + call-bound "^1.0.3" + es-errors "^1.3.0" + get-intrinsic "^1.2.6" + +get-tsconfig@^4.5.0: + version "4.10.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/get-tsconfig/-/get-tsconfig-4.10.0.tgz#403a682b373a823612475a4c2928c7326fc0f6bb" + integrity sha512-kGzZ3LWWQcGIAmg6iWvXn0ei6WDtV26wzHRMwDSzmAbcXrTEXxHy6IehI6/4eT6VRKyMP1eF1VqwrVUmE/LR7A== + dependencies: + resolve-pkg-maps "^1.0.0" + +glob-parent@^5.1.2: + version "5.1.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/glob-parent/-/glob-parent-5.1.2.tgz#869832c58034fe68a4093c17dc15e8340d8401c4" + integrity sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow== + dependencies: + is-glob "^4.0.1" + +glob-parent@^6.0.2: + version "6.0.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/glob-parent/-/glob-parent-6.0.2.tgz#6d237d99083950c79290f24c7642a3de9a28f9e3" + integrity sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A== + dependencies: + is-glob "^4.0.3" + +glob@^7.1.3, glob@^7.1.4: + version "7.2.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/glob/-/glob-7.2.3.tgz#b8df0fb802bbfa8e89bd1d938b4e16578ed44f2b" + integrity sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q== + dependencies: + fs.realpath "^1.0.0" + inflight "^1.0.4" + inherits "2" + minimatch "^3.1.1" + once "^1.3.0" + path-is-absolute "^1.0.0" + +globals@^11.1.0: + version "11.12.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/globals/-/globals-11.12.0.tgz#ab8795338868a0babd8525758018c2a7eb95c42e" + integrity sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA== + +globals@^13.19.0: + version "13.24.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/globals/-/globals-13.24.0.tgz#8432a19d78ce0c1e833949c36adb345400bb1171" + integrity sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ== + dependencies: + type-fest "^0.20.2" + +globalthis@^1.0.4: + version "1.0.4" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/globalthis/-/globalthis-1.0.4.tgz#7430ed3a975d97bfb59bcce41f5cabbafa651236" + integrity sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ== + dependencies: + define-properties "^1.2.1" + gopd "^1.0.1" + +globby@^11.1.0: + version "11.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/globby/11.1.0/globby-11.1.0.tgz#bd4be98bb042f83d796f7e3811991fbe82a0d34b" + integrity sha1-vUvpi7BC+D15b344EZkfvoKg00s= + dependencies: + array-union "^2.1.0" + dir-glob "^3.0.1" + fast-glob "^3.2.9" + ignore "^5.2.0" + merge2 "^1.4.1" + slash "^3.0.0" + +gopd@^1.0.1, gopd@^1.2.0: + version "1.2.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/gopd/-/gopd-1.2.0.tgz#89f56b8217bdbc8802bd299df6d7f1081d7e51a1" + integrity sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg== + +graceful-fs@^4.2.4, graceful-fs@^4.2.9: + version "4.2.11" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/graceful-fs/-/graceful-fs-4.2.11.tgz#4183e4e8bf08bb6e05bbb2f7d2e0c8f712ca40e3" + integrity sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ== + +graphemer@^1.4.0: + version "1.4.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/graphemer/1.4.0/graphemer-1.4.0.tgz#fb2f1d55e0e3a1849aeffc90c4fa0dd53a0e66c6" + integrity sha1-+y8dVeDjoYSa7/yQxPoN1ToOZsY= + +has-bigints@^1.0.2: + version "1.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/has-bigints/-/has-bigints-1.1.0.tgz#28607e965ac967e03cd2a2c70a2636a1edad49fe" + integrity sha512-R3pbpkcIqv2Pm3dUwgjclDRVmWpTJW2DcMzcIhEXEx1oh/CEMObMm3KLmRJOdvhM7o4uQBnwr8pzRK2sJWIqfg== + +has-flag@^4.0.0: + version "4.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/has-flag/-/has-flag-4.0.0.tgz#944771fd9c81c81265c4d6941860da06bb59479b" + integrity sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ== + +has-property-descriptors@^1.0.0, has-property-descriptors@^1.0.2: + version "1.0.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz#963ed7d071dc7bf5f084c5bfbe0d1b6222586854" + integrity sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg== + dependencies: + es-define-property "^1.0.0" + +has-proto@^1.2.0: + version "1.2.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/has-proto/-/has-proto-1.2.0.tgz#5de5a6eabd95fdffd9818b43055e8065e39fe9d5" + integrity sha512-KIL7eQPfHQRC8+XluaIw7BHUwwqL19bQn4hzNgdr+1wXoU0KKj6rufu47lhY7KbJR2C6T6+PfyN0Ea7wkSS+qQ== + dependencies: + dunder-proto "^1.0.0" + +has-symbols@^1.0.3, has-symbols@^1.1.0: + version "1.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/has-symbols/-/has-symbols-1.1.0.tgz#fc9c6a783a084951d0b971fe1018de813707a338" + integrity sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ== + +has-tostringtag@^1.0.0, has-tostringtag@^1.0.2: + version "1.0.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/has-tostringtag/-/has-tostringtag-1.0.2.tgz#2cdc42d40bef2e5b4eeab7c01a73c54ce7ab5abc" + integrity sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw== + dependencies: + has-symbols "^1.0.3" + +hasown@^2.0.0, hasown@^2.0.2: + version "2.0.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/hasown/-/hasown-2.0.2.tgz#003eaf91be7adc372e84ec59dc37252cedb80003" + integrity sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ== + dependencies: + function-bind "^1.1.2" + +html-escaper@^2.0.0: + version "2.0.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/html-escaper/2.0.2/html-escaper-2.0.2.tgz#dfd60027da36a36dfcbe236262c00a5822681453" + integrity sha1-39YAJ9o2o238viNiYsAKWCJoFFM= + +human-signals@^2.1.0: + version "2.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/human-signals/2.1.0/human-signals-2.1.0.tgz#dc91fcba42e4d06e4abaed33b3e7a3c02f514ea0" + integrity sha1-3JH8ukLk0G5Kuu0zs+ejwC9RTqA= + +iconv-lite@^0.4.24: + version "0.4.24" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/iconv-lite/0.4.24/iconv-lite-0.4.24.tgz#2022b4b25fbddc21d2f524974a474aafe733908b" + integrity sha1-ICK0sl+93CHS9SSXSkdKr+czkIs= + dependencies: + safer-buffer ">= 2.1.2 < 3" + +ignore@^5.2.0: + version "5.3.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/ignore/-/ignore-5.3.2.tgz#3cd40e729f3643fd87cb04e50bf0eb722bc596f5" + integrity sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g== + +import-fresh@^3.2.1: + version "3.3.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/import-fresh/-/import-fresh-3.3.1.tgz#9cecb56503c0ada1f2741dbbd6546e4b13b57ccf" + integrity sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ== + dependencies: + parent-module "^1.0.0" + resolve-from "^4.0.0" + +import-local@^3.0.2: + version "3.2.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/import-local/-/import-local-3.2.0.tgz#c3d5c745798c02a6f8b897726aba5100186ee260" + integrity sha512-2SPlun1JUPWoM6t3F0dw0FkCF/jWY8kttcY4f599GLTSjh2OCuuhdTkJQsEcZzBqbXZGKMK2OqW1oZsjtf/gQA== + dependencies: + pkg-dir "^4.2.0" + resolve-cwd "^3.0.0" + +imurmurhash@^0.1.4: + version "0.1.4" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/imurmurhash/-/imurmurhash-0.1.4.tgz#9218b9b2b928a238b13dc4fb6b6d576f231453ea" + integrity sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA== + +inflight@^1.0.4: + version "1.0.6" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/inflight/-/inflight-1.0.6.tgz#49bd6331d7d02d0c09bc910a1075ba8165b56df9" + integrity sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA== + dependencies: + once "^1.3.0" + wrappy "1" + +inherits@2: + version "2.0.4" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c" + integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ== + +internal-slot@^1.1.0: + version "1.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/internal-slot/-/internal-slot-1.1.0.tgz#1eac91762947d2f7056bc838d93e13b2e9604961" + integrity sha512-4gd7VpWNQNB4UKKCFFVcp1AVv+FMOgs9NKzjHKusc8jTMhd5eL1NqQqOpE0KzMds804/yHlglp3uxgluOqAPLw== + dependencies: + es-errors "^1.3.0" + hasown "^2.0.2" + side-channel "^1.1.0" + +is-array-buffer@^3.0.4, is-array-buffer@^3.0.5: + version "3.0.5" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/is-array-buffer/-/is-array-buffer-3.0.5.tgz#65742e1e687bd2cc666253068fd8707fe4d44280" + integrity sha512-DDfANUiiG2wC1qawP66qlTugJeL5HyzMpfr8lLK+jMQirGzNod0B12cFB/9q838Ru27sBwfw78/rdoU7RERz6A== + dependencies: + call-bind "^1.0.8" + call-bound "^1.0.3" + get-intrinsic "^1.2.6" + +is-arrayish@^0.2.1: + version "0.2.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/is-arrayish/0.2.1/is-arrayish-0.2.1.tgz#77c99840527aa8ecb1a8ba697b80645a7a926a9d" + integrity sha1-d8mYQFJ6qOyxqLppe4BkWnqSap0= + +is-async-function@^2.0.0: + version "2.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/is-async-function/2.0.0/is-async-function-2.0.0.tgz#8e4418efd3e5d3a6ebb0164c05ef5afb69aa9646" + integrity sha1-jkQY79Pl06brsBZMBe9a+2mqlkY= + dependencies: + has-tostringtag "^1.0.0" + +is-bigint@^1.1.0: + version "1.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/is-bigint/-/is-bigint-1.1.0.tgz#dda7a3445df57a42583db4228682eba7c4170672" + integrity sha512-n4ZT37wG78iz03xPRKJrHTdZbe3IicyucEtdRsV5yglwc3GyUfbAfpSeD0FJ41NbUNSt5wbhqfp1fS+BgnvDFQ== + dependencies: + has-bigints "^1.0.2" + +is-boolean-object@^1.2.1: + version "1.2.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/is-boolean-object/-/is-boolean-object-1.2.2.tgz#7067f47709809a393c71ff5bb3e135d8a9215d9e" + integrity sha512-wa56o2/ElJMYqjCjGkXri7it5FbebW5usLw/nPmCMs5DeZ7eziSYZhSmPRn0txqeW4LnAmQQU7FgqLpsEFKM4A== + dependencies: + call-bound "^1.0.3" + has-tostringtag "^1.0.2" + +is-callable@^1.2.7: + version "1.2.7" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/is-callable/1.2.7/is-callable-1.2.7.tgz#3bc2a85ea742d9e36205dcacdd72ca1fdc51b055" + integrity sha1-O8KoXqdC2eNiBdys3XLKH9xRsFU= + +is-core-module@^2.11.0, is-core-module@^2.13.0, is-core-module@^2.15.1, is-core-module@^2.16.0: + version "2.16.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/is-core-module/-/is-core-module-2.16.1.tgz#2a98801a849f43e2add644fbb6bc6229b19a4ef4" + integrity sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w== + dependencies: + hasown "^2.0.2" + +is-data-view@^1.0.1, is-data-view@^1.0.2: + version "1.0.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/is-data-view/-/is-data-view-1.0.2.tgz#bae0a41b9688986c2188dda6657e56b8f9e63b8e" + integrity sha512-RKtWF8pGmS87i2D6gqQu/l7EYRlVdfzemCJN/P3UOs//x1QE7mfhvzHIApBTRf7axvT6DMGwSwBXYCT0nfB9xw== + dependencies: + call-bound "^1.0.2" + get-intrinsic "^1.2.6" + is-typed-array "^1.1.13" + +is-date-object@^1.0.5, is-date-object@^1.1.0: + version "1.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/is-date-object/-/is-date-object-1.1.0.tgz#ad85541996fc7aa8b2729701d27b7319f95d82f7" + integrity sha512-PwwhEakHVKTdRNVOw+/Gyh0+MzlCl4R6qKvkhuvLtPMggI1WAHt9sOwZxQLSGpUaDnrdyDsomoRgNnCfKNSXXg== + dependencies: + call-bound "^1.0.2" + has-tostringtag "^1.0.2" + +is-extglob@^2.1.1: + version "2.1.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/is-extglob/-/is-extglob-2.1.1.tgz#a88c02535791f02ed37c76a1b9ea9773c833f8c2" + integrity sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ== + +is-finalizationregistry@^1.1.0: + version "1.1.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/is-finalizationregistry/-/is-finalizationregistry-1.1.1.tgz#eefdcdc6c94ddd0674d9c85887bf93f944a97c90" + integrity sha512-1pC6N8qWJbWoPtEjgcL2xyhQOP491EQjeUo3qTKcmV8YSDDJrOepfG8pcC7h/QgnQHYSv0mJ3Z/ZWxmatVrysg== + dependencies: + call-bound "^1.0.3" + +is-fullwidth-code-point@^3.0.0: + version "3.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz#f116f8064fe90b3f7844a38997c0b75051269f1d" + integrity sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg== + +is-generator-fn@^2.0.0: + version "2.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/is-generator-fn/2.1.0/is-generator-fn-2.1.0.tgz#7d140adc389aaf3011a8f2a2a4cfa6faadffb118" + integrity sha1-fRQK3DiarzARqPKipM+m+q3/sRg= + +is-generator-function@^1.0.10: + version "1.0.10" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/is-generator-function/1.0.10/is-generator-function-1.0.10.tgz#f1558baf1ac17e0deea7c0415c438351ff2b3c72" + integrity sha1-8VWLrxrBfg3up8BBXEODUf8rPHI= + dependencies: + has-tostringtag "^1.0.0" + +is-glob@^4.0.0, is-glob@^4.0.1, is-glob@^4.0.3: + version "4.0.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/is-glob/-/is-glob-4.0.3.tgz#64f61e42cbbb2eec2071a9dac0b28ba1e65d5084" + integrity sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg== + dependencies: + is-extglob "^2.1.1" + +is-map@^2.0.3: + version "2.0.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/is-map/2.0.3/is-map-2.0.3.tgz#ede96b7fe1e270b3c4465e3a465658764926d62e" + integrity sha1-7elrf+HicLPERl46RlZYdkkm1i4= + +is-number-object@^1.1.1: + version "1.1.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/is-number-object/-/is-number-object-1.1.1.tgz#144b21e95a1bc148205dcc2814a9134ec41b2541" + integrity sha512-lZhclumE1G6VYD8VHe35wFaIif+CTy5SJIi5+3y4psDgWu4wPDoBhF8NxUOinEc7pHgiTsT6MaBb92rKhhD+Xw== + dependencies: + call-bound "^1.0.3" + has-tostringtag "^1.0.2" + +is-number@^7.0.0: + version "7.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/is-number/-/is-number-7.0.0.tgz#7535345b896734d5f80c4d06c50955527a14f12b" + integrity sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng== + +is-path-inside@^3.0.3: + version "3.0.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/is-path-inside/3.0.3/is-path-inside-3.0.3.tgz#d231362e53a07ff2b0e0ea7fed049161ffd16283" + integrity sha1-0jE2LlOgf/Kw4Op/7QSRYf/RYoM= + +is-regex@^1.2.1: + version "1.2.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/is-regex/-/is-regex-1.2.1.tgz#76d70a3ed10ef9be48eb577887d74205bf0cad22" + integrity sha512-MjYsKHO5O7mCsmRGxWcLWheFqN9DJ/2TmngvjKXihe6efViPqc274+Fx/4fYj/r03+ESvBdTXK0V6tA3rgez1g== + dependencies: + call-bound "^1.0.2" + gopd "^1.2.0" + has-tostringtag "^1.0.2" + hasown "^2.0.2" + +is-set@^2.0.3: + version "2.0.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/is-set/2.0.3/is-set-2.0.3.tgz#8ab209ea424608141372ded6e0cb200ef1d9d01d" + integrity sha1-irIJ6kJGCBQTct7W4MsgDvHZ0B0= + +is-shared-array-buffer@^1.0.4: + version "1.0.4" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/is-shared-array-buffer/-/is-shared-array-buffer-1.0.4.tgz#9b67844bd9b7f246ba0708c3a93e34269c774f6f" + integrity sha512-ISWac8drv4ZGfwKl5slpHG9OwPNty4jOWPRIhBpxOoD+hqITiwuipOQ2bNthAzwA3B4fIjO4Nln74N0S9byq8A== + dependencies: + call-bound "^1.0.3" + +is-stream@^2.0.0: + version "2.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/is-stream/-/is-stream-2.0.1.tgz#fac1e3d53b97ad5a9d0ae9cef2389f5810a5c077" + integrity sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg== + +is-string@^1.0.7, is-string@^1.1.1: + version "1.1.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/is-string/-/is-string-1.1.1.tgz#92ea3f3d5c5b6e039ca8677e5ac8d07ea773cbb9" + integrity sha512-BtEeSsoaQjlSPBemMQIrY1MY0uM6vnS1g5fmufYOtnxLGUZM2178PKbhsk7Ffv58IX+ZtcvoGwccYsh0PglkAA== + dependencies: + call-bound "^1.0.3" + has-tostringtag "^1.0.2" + +is-symbol@^1.0.4, is-symbol@^1.1.1: + version "1.1.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/is-symbol/-/is-symbol-1.1.1.tgz#f47761279f532e2b05a7024a7506dbbedacd0634" + integrity sha512-9gGx6GTtCQM73BgmHQXfDmLtfjjTUDSyoxTCbp5WtoixAhfgsDirWIcVQ/IHpvI5Vgd5i/J5F7B9cN/WlVbC/w== + dependencies: + call-bound "^1.0.2" + has-symbols "^1.1.0" + safe-regex-test "^1.1.0" + +is-typed-array@^1.1.13, is-typed-array@^1.1.14, is-typed-array@^1.1.15: + version "1.1.15" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/is-typed-array/-/is-typed-array-1.1.15.tgz#4bfb4a45b61cee83a5a46fba778e4e8d59c0ce0b" + integrity sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ== + dependencies: + which-typed-array "^1.1.16" + +is-weakmap@^2.0.2: + version "2.0.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/is-weakmap/2.0.2/is-weakmap-2.0.2.tgz#bf72615d649dfe5f699079c54b83e47d1ae19cfd" + integrity sha1-v3JhXWSd/l9pkHnFS4PkfRrhnP0= + +is-weakref@^1.0.2, is-weakref@^1.1.0: + version "1.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/is-weakref/-/is-weakref-1.1.0.tgz#47e3472ae95a63fa9cf25660bcf0c181c39770ef" + integrity sha512-SXM8Nwyys6nT5WP6pltOwKytLV7FqQ4UiibxVmW+EIosHcmCqkkjViTb5SNssDlkCiEYRP1/pdWUKVvZBmsR2Q== + dependencies: + call-bound "^1.0.2" + +is-weakset@^2.0.3: + version "2.0.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/is-weakset/2.0.3/is-weakset-2.0.3.tgz#e801519df8c0c43e12ff2834eead84ec9e624007" + integrity sha1-6AFRnfjAxD4S/yg07q2E7J5iQAc= + dependencies: + call-bind "^1.0.7" + get-intrinsic "^1.2.4" + +isarray@^2.0.5: + version "2.0.5" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/isarray/2.0.5/isarray-2.0.5.tgz#8af1e4c1221244cc62459faf38940d4e644a5723" + integrity sha1-ivHkwSISRMxiRZ+vOJQNTmRKVyM= + +isexe@^2.0.0: + version "2.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/isexe/-/isexe-2.0.0.tgz#e8fbf374dc556ff8947a10dcb0572d633f2cfa10" + integrity sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw== + +istanbul-lib-coverage@^3.0.0, istanbul-lib-coverage@^3.2.0: + version "3.2.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/istanbul-lib-coverage/3.2.2/istanbul-lib-coverage-3.2.2.tgz#2d166c4b0644d43a39f04bf6c2edd1e585f31756" + integrity sha1-LRZsSwZE1Do58Ev2wu3R5YXzF1Y= + +istanbul-lib-instrument@^5.0.4: + version "5.2.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/istanbul-lib-instrument/5.2.1/istanbul-lib-instrument-5.2.1.tgz#d10c8885c2125574e1c231cacadf955675e1ce3d" + integrity sha1-0QyIhcISVXThwjHKyt+VVnXhzj0= + dependencies: + "@babel/core" "^7.12.3" + "@babel/parser" "^7.14.7" + "@istanbuljs/schema" "^0.1.2" + istanbul-lib-coverage "^3.2.0" + semver "^6.3.0" + +istanbul-lib-instrument@^6.0.0: + version "6.0.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/istanbul-lib-instrument/-/istanbul-lib-instrument-6.0.3.tgz#fa15401df6c15874bcb2105f773325d78c666765" + integrity sha512-Vtgk7L/R2JHyyGW07spoFlB8/lpjiOLTjMdms6AFMraYt3BaJauod/NGrfnVG/y4Ix1JEuMRPDPEj2ua+zz1/Q== + dependencies: + "@babel/core" "^7.23.9" + "@babel/parser" "^7.23.9" + "@istanbuljs/schema" "^0.1.3" + istanbul-lib-coverage "^3.2.0" + semver "^7.5.4" + +istanbul-lib-report@^3.0.0: + version "3.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/istanbul-lib-report/3.0.1/istanbul-lib-report-3.0.1.tgz#908305bac9a5bd175ac6a74489eafd0fc2445a7d" + integrity sha1-kIMFusmlvRdaxqdEier9D8JEWn0= + dependencies: + istanbul-lib-coverage "^3.0.0" + make-dir "^4.0.0" + supports-color "^7.1.0" + +istanbul-lib-source-maps@^4.0.0: + version "4.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/istanbul-lib-source-maps/4.0.1/istanbul-lib-source-maps-4.0.1.tgz#895f3a709fcfba34c6de5a42939022f3e4358551" + integrity sha1-iV86cJ/PujTG3lpCk5Ai8+Q1hVE= + dependencies: + debug "^4.1.1" + istanbul-lib-coverage "^3.0.0" + source-map "^0.6.1" + +istanbul-reports@^3.1.3: + version "3.1.7" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/istanbul-reports/3.1.7/istanbul-reports-3.1.7.tgz#daed12b9e1dca518e15c056e1e537e741280fa0b" + integrity sha1-2u0SueHcpRjhXAVuHlN+dBKA+gs= + dependencies: + html-escaper "^2.0.0" + istanbul-lib-report "^3.0.0" + +jake@^10.8.5: + version "10.9.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/jake/-/jake-10.9.2.tgz#6ae487e6a69afec3a5e167628996b59f35ae2b7f" + integrity sha512-2P4SQ0HrLQ+fw6llpLnOaGAvN2Zu6778SJMrCUwns4fOoG9ayrTiZk3VV8sCPkVZF8ab0zksVpS8FDY5pRCNBA== + dependencies: + async "^3.2.3" + chalk "^4.0.2" + filelist "^1.0.4" + minimatch "^3.1.2" + +jest-changed-files@^29.7.0: + version "29.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/jest-changed-files/29.7.0/jest-changed-files-29.7.0.tgz#1c06d07e77c78e1585d020424dedc10d6e17ac3a" + integrity sha1-HAbQfnfHjhWF0CBCTe3BDW4XrDo= + dependencies: + execa "^5.0.0" + jest-util "^29.7.0" + p-limit "^3.1.0" + +jest-circus@^29.7.0: + version "29.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/jest-circus/29.7.0/jest-circus-29.7.0.tgz#b6817a45fcc835d8b16d5962d0c026473ee3668a" + integrity sha1-toF6RfzINdixbVli0MAmRz7jZoo= + dependencies: + "@jest/environment" "^29.7.0" + "@jest/expect" "^29.7.0" + "@jest/test-result" "^29.7.0" + "@jest/types" "^29.6.3" + "@types/node" "*" + chalk "^4.0.0" + co "^4.6.0" + dedent "^1.0.0" + is-generator-fn "^2.0.0" + jest-each "^29.7.0" + jest-matcher-utils "^29.7.0" + jest-message-util "^29.7.0" + jest-runtime "^29.7.0" + jest-snapshot "^29.7.0" + jest-util "^29.7.0" + p-limit "^3.1.0" + pretty-format "^29.7.0" + pure-rand "^6.0.0" + slash "^3.0.0" + stack-utils "^2.0.3" + +jest-cli@^29.7.0: + version "29.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/jest-cli/29.7.0/jest-cli-29.7.0.tgz#5592c940798e0cae677eec169264f2d839a37995" + integrity sha1-VZLJQHmODK5nfuwWkmTy2DmjeZU= + dependencies: + "@jest/core" "^29.7.0" + "@jest/test-result" "^29.7.0" + "@jest/types" "^29.6.3" + chalk "^4.0.0" + create-jest "^29.7.0" + exit "^0.1.2" + import-local "^3.0.2" + jest-config "^29.7.0" + jest-util "^29.7.0" + jest-validate "^29.7.0" + yargs "^17.3.1" + +jest-config@^29.7.0: + version "29.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/jest-config/29.7.0/jest-config-29.7.0.tgz#bcbda8806dbcc01b1e316a46bb74085a84b0245f" + integrity sha1-vL2ogG28wBseMWpGu3QIWoSwJF8= + dependencies: + "@babel/core" "^7.11.6" + "@jest/test-sequencer" "^29.7.0" + "@jest/types" "^29.6.3" + babel-jest "^29.7.0" + chalk "^4.0.0" + ci-info "^3.2.0" + deepmerge "^4.2.2" + glob "^7.1.3" + graceful-fs "^4.2.9" + jest-circus "^29.7.0" + jest-environment-node "^29.7.0" + jest-get-type "^29.6.3" + jest-regex-util "^29.6.3" + jest-resolve "^29.7.0" + jest-runner "^29.7.0" + jest-util "^29.7.0" + jest-validate "^29.7.0" + micromatch "^4.0.4" + parse-json "^5.2.0" + pretty-format "^29.7.0" + slash "^3.0.0" + strip-json-comments "^3.1.1" + +jest-diff@^29.7.0: + version "29.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/jest-diff/29.7.0/jest-diff-29.7.0.tgz#017934a66ebb7ecf6f205e84699be10afd70458a" + integrity sha1-AXk0pm67fs9vIF6EaZvhCv1wRYo= + dependencies: + chalk "^4.0.0" + diff-sequences "^29.6.3" + jest-get-type "^29.6.3" + pretty-format "^29.7.0" + +jest-docblock@^29.7.0: + version "29.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/jest-docblock/29.7.0/jest-docblock-29.7.0.tgz#8fddb6adc3cdc955c93e2a87f61cfd350d5d119a" + integrity sha1-j922rcPNyVXJPiqH9hz9NQ1dEZo= + dependencies: + detect-newline "^3.0.0" + +jest-each@^29.7.0: + version "29.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/jest-each/29.7.0/jest-each-29.7.0.tgz#162a9b3f2328bdd991beaabffbb74745e56577d1" + integrity sha1-FiqbPyMovdmRvqq/+7dHReVld9E= + dependencies: + "@jest/types" "^29.6.3" + chalk "^4.0.0" + jest-get-type "^29.6.3" + jest-util "^29.7.0" + pretty-format "^29.7.0" + +jest-environment-node@^29.7.0: + version "29.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/jest-environment-node/29.7.0/jest-environment-node-29.7.0.tgz#0b93e111dda8ec120bc8300e6d1fb9576e164376" + integrity sha1-C5PhEd2o7BILyDAObR+5V24WQ3Y= + dependencies: + "@jest/environment" "^29.7.0" + "@jest/fake-timers" "^29.7.0" + "@jest/types" "^29.6.3" + "@types/node" "*" + jest-mock "^29.7.0" + jest-util "^29.7.0" + +jest-get-type@^29.6.3: + version "29.6.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/jest-get-type/-/jest-get-type-29.6.3.tgz#36f499fdcea197c1045a127319c0481723908fd1" + integrity sha512-zrteXnqYxfQh7l5FHyL38jL39di8H8rHoecLH3JNxH3BwOrBsNeabdap5e0I23lD4HHI8W5VFBZqG4Eaq5LNcw== + +jest-haste-map@^29.7.0: + version "29.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/jest-haste-map/-/jest-haste-map-29.7.0.tgz#3c2396524482f5a0506376e6c858c3bbcc17b104" + integrity sha512-fP8u2pyfqx0K1rGn1R9pyE0/KTn+G7PxktWidOBTqFPLYX0b9ksaMFkhK5vrS3DVun09pckLdlx90QthlW7AmA== + dependencies: + "@jest/types" "^29.6.3" + "@types/graceful-fs" "^4.1.3" + "@types/node" "*" + anymatch "^3.0.3" + fb-watchman "^2.0.0" + graceful-fs "^4.2.9" + jest-regex-util "^29.6.3" + jest-util "^29.7.0" + jest-worker "^29.7.0" + micromatch "^4.0.4" + walker "^1.0.8" + optionalDependencies: + fsevents "^2.3.2" + +jest-leak-detector@^29.7.0: + version "29.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/jest-leak-detector/29.7.0/jest-leak-detector-29.7.0.tgz#5b7ec0dadfdfec0ca383dc9aa016d36b5ea4c728" + integrity sha1-W37A2t/f7Ayjg9yaoBbTa16kxyg= + dependencies: + jest-get-type "^29.6.3" + pretty-format "^29.7.0" + +jest-matcher-utils@^29.7.0: + version "29.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/jest-matcher-utils/29.7.0/jest-matcher-utils-29.7.0.tgz#ae8fec79ff249fd592ce80e3ee474e83a6c44f12" + integrity sha1-ro/sef8kn9WSzoDj7kdOg6bETxI= + dependencies: + chalk "^4.0.0" + jest-diff "^29.7.0" + jest-get-type "^29.6.3" + pretty-format "^29.7.0" + +jest-message-util@^29.7.0: + version "29.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/jest-message-util/29.7.0/jest-message-util-29.7.0.tgz#8bc392e204e95dfe7564abbe72a404e28e51f7f3" + integrity sha1-i8OS4gTpXf51ZKu+cqQE4o5R9/M= + dependencies: + "@babel/code-frame" "^7.12.13" + "@jest/types" "^29.6.3" + "@types/stack-utils" "^2.0.0" + chalk "^4.0.0" + graceful-fs "^4.2.9" + micromatch "^4.0.4" + pretty-format "^29.7.0" + slash "^3.0.0" + stack-utils "^2.0.3" + +jest-mock@^29.7.0: + version "29.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/jest-mock/29.7.0/jest-mock-29.7.0.tgz#4e836cf60e99c6fcfabe9f99d017f3fdd50a6347" + integrity sha1-ToNs9g6Zxvz6vp+Z0Bfz/dUKY0c= + dependencies: + "@jest/types" "^29.6.3" + "@types/node" "*" + jest-util "^29.7.0" + +jest-pnp-resolver@^1.2.2: + version "1.2.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/jest-pnp-resolver/-/jest-pnp-resolver-1.2.3.tgz#930b1546164d4ad5937d5540e711d4d38d4cad2e" + integrity sha512-+3NpwQEnRoIBtx4fyhblQDPgJI0H1IEIkX7ShLUjPGA7TtUTvI1oiKi3SR4oBR0hQhQR80l4WAe5RrXBwWMA8w== + +jest-regex-util@^29.6.3: + version "29.6.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/jest-regex-util/-/jest-regex-util-29.6.3.tgz#4a556d9c776af68e1c5f48194f4d0327d24e8a52" + integrity sha512-KJJBsRCyyLNWCNBOvZyRDnAIfUiRJ8v+hOBQYGn8gDyF3UegwiP4gwRR3/SDa42g1YbVycTidUF3rKjyLFDWbg== + +jest-resolve-dependencies@^29.7.0: + version "29.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/jest-resolve-dependencies/29.7.0/jest-resolve-dependencies-29.7.0.tgz#1b04f2c095f37fc776ff40803dc92921b1e88428" + integrity sha1-GwTywJXzf8d2/0CAPckpIbHohCg= + dependencies: + jest-regex-util "^29.6.3" + jest-snapshot "^29.7.0" + +jest-resolve@^29.7.0: + version "29.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/jest-resolve/-/jest-resolve-29.7.0.tgz#64d6a8992dd26f635ab0c01e5eef4399c6bcbc30" + integrity sha512-IOVhZSrg+UvVAshDSDtHyFCCBUl/Q3AAJv8iZ6ZjnZ74xzvwuzLXid9IIIPgTnY62SJjfuupMKZsZQRsCvxEgA== + dependencies: + chalk "^4.0.0" + graceful-fs "^4.2.9" + jest-haste-map "^29.7.0" + jest-pnp-resolver "^1.2.2" + jest-util "^29.7.0" + jest-validate "^29.7.0" + resolve "^1.20.0" + resolve.exports "^2.0.0" + slash "^3.0.0" + +jest-runner@^29.7.0: + version "29.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/jest-runner/29.7.0/jest-runner-29.7.0.tgz#809af072d408a53dcfd2e849a4c976d3132f718e" + integrity sha1-gJrwctQIpT3P0uhJpMl20xMvcY4= + dependencies: + "@jest/console" "^29.7.0" + "@jest/environment" "^29.7.0" + "@jest/test-result" "^29.7.0" + "@jest/transform" "^29.7.0" + "@jest/types" "^29.6.3" + "@types/node" "*" + chalk "^4.0.0" + emittery "^0.13.1" + graceful-fs "^4.2.9" + jest-docblock "^29.7.0" + jest-environment-node "^29.7.0" + jest-haste-map "^29.7.0" + jest-leak-detector "^29.7.0" + jest-message-util "^29.7.0" + jest-resolve "^29.7.0" + jest-runtime "^29.7.0" + jest-util "^29.7.0" + jest-watcher "^29.7.0" + jest-worker "^29.7.0" + p-limit "^3.1.0" + source-map-support "0.5.13" + +jest-runtime@^29.7.0: + version "29.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/jest-runtime/29.7.0/jest-runtime-29.7.0.tgz#efecb3141cf7d3767a3a0cc8f7c9990587d3d817" + integrity sha1-7+yzFBz303Z6OgzI98mZBYfT2Bc= + dependencies: + "@jest/environment" "^29.7.0" + "@jest/fake-timers" "^29.7.0" + "@jest/globals" "^29.7.0" + "@jest/source-map" "^29.6.3" + "@jest/test-result" "^29.7.0" + "@jest/transform" "^29.7.0" + "@jest/types" "^29.6.3" + "@types/node" "*" + chalk "^4.0.0" + cjs-module-lexer "^1.0.0" + collect-v8-coverage "^1.0.0" + glob "^7.1.3" + graceful-fs "^4.2.9" + jest-haste-map "^29.7.0" + jest-message-util "^29.7.0" + jest-mock "^29.7.0" + jest-regex-util "^29.6.3" + jest-resolve "^29.7.0" + jest-snapshot "^29.7.0" + jest-util "^29.7.0" + slash "^3.0.0" + strip-bom "^4.0.0" + +jest-snapshot@^29.7.0: + version "29.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/jest-snapshot/29.7.0/jest-snapshot-29.7.0.tgz#c2c574c3f51865da1bb329036778a69bf88a6be5" + integrity sha1-wsV0w/UYZdobsykDZ3imm/iKa+U= + dependencies: + "@babel/core" "^7.11.6" + "@babel/generator" "^7.7.2" + "@babel/plugin-syntax-jsx" "^7.7.2" + "@babel/plugin-syntax-typescript" "^7.7.2" + "@babel/types" "^7.3.3" + "@jest/expect-utils" "^29.7.0" + "@jest/transform" "^29.7.0" + "@jest/types" "^29.6.3" + babel-preset-current-node-syntax "^1.0.0" + chalk "^4.0.0" + expect "^29.7.0" + graceful-fs "^4.2.9" + jest-diff "^29.7.0" + jest-get-type "^29.6.3" + jest-matcher-utils "^29.7.0" + jest-message-util "^29.7.0" + jest-util "^29.7.0" + natural-compare "^1.4.0" + pretty-format "^29.7.0" + semver "^7.5.3" + +jest-util@^29.0.0, jest-util@^29.7.0: + version "29.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/jest-util/-/jest-util-29.7.0.tgz#23c2b62bfb22be82b44de98055802ff3710fc0bc" + integrity sha512-z6EbKajIpqGKU56y5KBUgy1dt1ihhQJgWzUlZHArA/+X2ad7Cb5iF+AK1EWVL/Bo7Rz9uurpqw6SiBCefUbCGA== + dependencies: + "@jest/types" "^29.6.3" + "@types/node" "*" + chalk "^4.0.0" + ci-info "^3.2.0" + graceful-fs "^4.2.9" + picomatch "^2.2.3" + +jest-validate@^29.7.0: + version "29.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/jest-validate/-/jest-validate-29.7.0.tgz#7bf705511c64da591d46b15fce41400d52147d9c" + integrity sha512-ZB7wHqaRGVw/9hST/OuFUReG7M8vKeq0/J2egIGLdvjHCmYqGARhzXmtgi+gVeZ5uXFF219aOc3Ls2yLg27tkw== + dependencies: + "@jest/types" "^29.6.3" + camelcase "^6.2.0" + chalk "^4.0.0" + jest-get-type "^29.6.3" + leven "^3.1.0" + pretty-format "^29.7.0" + +jest-watcher@^29.7.0: + version "29.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/jest-watcher/29.7.0/jest-watcher-29.7.0.tgz#7810d30d619c3a62093223ce6bb359ca1b28a2f2" + integrity sha1-eBDTDWGcOmIJMiPOa7NZyhsoovI= + dependencies: + "@jest/test-result" "^29.7.0" + "@jest/types" "^29.6.3" + "@types/node" "*" + ansi-escapes "^4.2.1" + chalk "^4.0.0" + emittery "^0.13.1" + jest-util "^29.7.0" + string-length "^4.0.1" + +jest-worker@^29.7.0: + version "29.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/jest-worker/-/jest-worker-29.7.0.tgz#acad073acbbaeb7262bd5389e1bcf43e10058d4a" + integrity sha512-eIz2msL/EzL9UFTFFx7jBTkeZfku0yUAyZZZmJ93H2TYEiroIx2PQjEXcwYtYl8zXCxb+PAmA2hLIt/6ZEkPHw== + dependencies: + "@types/node" "*" + jest-util "^29.7.0" + merge-stream "^2.0.0" + supports-color "^8.0.0" + +jest@^29.7.0: + version "29.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/jest/-/jest-29.7.0.tgz#994676fc24177f088f1c5e3737f5697204ff2613" + integrity sha512-NIy3oAFp9shda19hy4HK0HRTWKtPJmGdnvywu01nOqNC2vZg+Z+fvJDxpMQA88eb2I9EcafcdjYgsDthnYTvGw== + dependencies: + "@jest/core" "^29.7.0" + "@jest/types" "^29.6.3" + import-local "^3.0.2" + jest-cli "^29.7.0" + +js-tokens@^4.0.0: + version "4.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/js-tokens/-/js-tokens-4.0.0.tgz#19203fb59991df98e3a287050d4647cdeaf32499" + integrity sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ== + +js-yaml@^3.13.1: + version "3.14.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/js-yaml/-/js-yaml-3.14.1.tgz#dae812fdb3825fa306609a8717383c50c36a0537" + integrity sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g== + dependencies: + argparse "^1.0.7" + esprima "^4.0.0" + +js-yaml@^4.1.0: + version "4.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/js-yaml/-/js-yaml-4.1.0.tgz#c1fb65f8f5017901cdd2c951864ba18458a10602" + integrity sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA== + dependencies: + argparse "^2.0.1" + +jsesc@^3.0.2: + version "3.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/jsesc/-/jsesc-3.1.0.tgz#74d335a234f67ed19907fdadfac7ccf9d409825d" + integrity sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA== + +json-buffer@3.0.1: + version "3.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/json-buffer/-/json-buffer-3.0.1.tgz#9338802a30d3b6605fbe0613e094008ca8c05a13" + integrity sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ== + +json-parse-even-better-errors@^2.3.0: + version "2.3.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz#7c47805a94319928e05777405dc12e1f7a4ee02d" + integrity sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w== + +json-schema-traverse@^0.4.1: + version "0.4.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/json-schema-traverse/0.4.1/json-schema-traverse-0.4.1.tgz#69f6a87d9513ab8bb8fe63bdb0979c448e684660" + integrity sha1-afaofZUTq4u4/mO9sJecRI5oRmA= + +json-stable-stringify-without-jsonify@^1.0.1: + version "1.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz#9db7b59496ad3f3cfef30a75142d2d930ad72651" + integrity sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw== + +json5@^1.0.2: + version "1.0.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/json5/1.0.2/json5-1.0.2.tgz#63d98d60f21b313b77c4d6da18bfa69d80e1d593" + integrity sha1-Y9mNYPIbMTt3xNbaGL+mnYDh1ZM= + dependencies: + minimist "^1.2.0" + +json5@^2.2.3: + version "2.2.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/json5/-/json5-2.2.3.tgz#78cd6f1a19bdc12b73db5ad0c61efd66c1e29283" + integrity sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg== + +keyv@^4.5.3: + version "4.5.4" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/keyv/-/keyv-4.5.4.tgz#a879a99e29452f942439f2a405e3af8b31d4de93" + integrity sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw== + dependencies: + json-buffer "3.0.1" + +kleur@^3.0.3: + version "3.0.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/kleur/3.0.3/kleur-3.0.3.tgz#a79c9ecc86ee1ce3fa6206d1216c501f147fc07e" + integrity sha1-p5yezIbuHOP6YgbRIWxQHxR/wH4= + +leven@^3.1.0: + version "3.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/leven/-/leven-3.1.0.tgz#77891de834064cccba82ae7842bb6b14a13ed7f2" + integrity sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A== + +levn@^0.4.1: + version "0.4.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/levn/-/levn-0.4.1.tgz#ae4562c007473b932a6200d403268dd2fffc6ade" + integrity sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ== + dependencies: + prelude-ls "^1.2.1" + type-check "~0.4.0" + +lines-and-columns@^1.1.6: + version "1.2.4" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/lines-and-columns/-/lines-and-columns-1.2.4.tgz#eca284f75d2965079309dc0ad9255abb2ebc1632" + integrity sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg== + +locate-path@^5.0.0: + version "5.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/locate-path/5.0.0/locate-path-5.0.0.tgz#1afba396afd676a6d42504d0a67a3a7eb9f62aa0" + integrity sha1-Gvujlq/WdqbUJQTQpno6frn2KqA= + dependencies: + p-locate "^4.1.0" + +locate-path@^6.0.0: + version "6.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/locate-path/-/locate-path-6.0.0.tgz#55321eb309febbc59c4801d931a72452a681d286" + integrity sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw== + dependencies: + p-locate "^5.0.0" + +lodash.memoize@^4.1.2: + version "4.1.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/lodash.memoize/-/lodash.memoize-4.1.2.tgz#bcc6c49a42a2840ed997f323eada5ecd182e0bfe" + integrity sha512-t7j+NzmgnQzTAYXcsHYLgimltOV1MXHtlOWf6GjL9Kj8GK5FInw5JotxvbOs+IvV1/Dzo04/fCGfLVs7aXb4Ag== + +lodash.merge@^4.6.2: + version "4.6.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/lodash.merge/-/lodash.merge-4.6.2.tgz#558aa53b43b661e1925a0afdfa36a9a1085fe57a" + integrity sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ== + +lru-cache@^5.1.1: + version "5.1.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/lru-cache/-/lru-cache-5.1.1.tgz#1da27e6710271947695daf6848e847f01d84b920" + integrity sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w== + dependencies: + yallist "^3.0.2" + +make-dir@^4.0.0: + version "4.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/make-dir/4.0.0/make-dir-4.0.0.tgz#c3c2307a771277cd9638305f915c29ae741b614e" + integrity sha1-w8IwencSd82WODBfkVwprnQbYU4= + dependencies: + semver "^7.5.3" + +make-error@^1.3.6: + version "1.3.6" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/make-error/-/make-error-1.3.6.tgz#2eb2e37ea9b67c4891f684a1394799af484cf7a2" + integrity sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw== + +makeerror@1.0.12: + version "1.0.12" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/makeerror/-/makeerror-1.0.12.tgz#3e5dd2079a82e812e983cc6610c4a2cb0eaa801a" + integrity sha512-JmqCvUhmt43madlpFzG4BQzG2Z3m6tvQDNKdClZnO3VbIudJYmxsT0FNJMeiB2+JTSlTQTSbU8QdesVmwJcmLg== + dependencies: + tmpl "1.0.5" + +math-intrinsics@^1.1.0: + version "1.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/math-intrinsics/-/math-intrinsics-1.1.0.tgz#a0dd74be81e2aa5c2f27e65ce283605ee4e2b7f9" + integrity sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g== + +merge-stream@^2.0.0: + version "2.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/merge-stream/-/merge-stream-2.0.0.tgz#52823629a14dd00c9770fb6ad47dc6310f2c1f60" + integrity sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w== + +merge2@^1.3.0, merge2@^1.4.1: + version "1.4.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/merge2/-/merge2-1.4.1.tgz#4368892f885e907455a6fd7dc55c0c9d404990ae" + integrity sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg== + +micromatch@^4.0.4, micromatch@^4.0.8: + version "4.0.8" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/micromatch/-/micromatch-4.0.8.tgz#d66fa18f3a47076789320b9b1af32bd86d9fa202" + integrity sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA== + dependencies: + braces "^3.0.3" + picomatch "^2.3.1" + +mimic-fn@^2.1.0: + version "2.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/mimic-fn/-/mimic-fn-2.1.0.tgz#7ed2c2ccccaf84d3ffcb7a69b57711fc2083401b" + integrity sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg== + +minimatch@^3.0.4, minimatch@^3.0.5, minimatch@^3.1.1, minimatch@^3.1.2: + version "3.1.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/minimatch/-/minimatch-3.1.2.tgz#19cd194bfd3e428f049a70817c038d89ab4be35b" + integrity sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw== + dependencies: + brace-expansion "^1.1.7" + +minimatch@^5.0.1: + version "5.1.6" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/minimatch/-/minimatch-5.1.6.tgz#1cfcb8cf5522ea69952cd2af95ae09477f122a96" + integrity sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g== + dependencies: + brace-expansion "^2.0.1" + +minimist@^1.2.0, minimist@^1.2.6: + version "1.2.8" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/minimist/-/minimist-1.2.8.tgz#c1a464e7693302e082a075cee0c057741ac4772c" + integrity sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA== + +ms@^2.1.1, ms@^2.1.3: + version "2.1.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/ms/-/ms-2.1.3.tgz#574c8138ce1d2b5861f0b44579dbadd60c6615b2" + integrity sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA== + +mute-stream@^1.0.0: + version "1.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/mute-stream/-/mute-stream-1.0.0.tgz#e31bd9fe62f0aed23520aa4324ea6671531e013e" + integrity sha512-avsJQhyd+680gKXyG/sQc0nXaC6rBkPOfyHYcFb9+hdkqQkR9bdnkJ0AMZhke0oesPqIO+mFFJ+IdBc7mst4IA== + +natural-compare-lite@^1.4.0: + version "1.4.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/natural-compare-lite/1.4.0/natural-compare-lite-1.4.0.tgz#17b09581988979fddafe0201e931ba933c96cbb4" + integrity sha1-F7CVgZiJef3a/gIB6TG6kzyWy7Q= + +natural-compare@^1.4.0: + version "1.4.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/natural-compare/-/natural-compare-1.4.0.tgz#4abebfeed7541f2c27acfb29bdbbd15c8d5ba4f7" + integrity sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw== + +node-forge@^1.3.1: + version "1.3.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/node-forge/1.3.1/node-forge-1.3.1.tgz#be8da2af243b2417d5f646a770663a92b7e9ded3" + integrity sha1-vo2iryQ7JBfV9kancGY6krfp3tM= + +node-int64@^0.4.0: + version "0.4.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/node-int64/-/node-int64-0.4.0.tgz#87a9065cdb355d3182d8f94ce11188b825c68a3b" + integrity sha512-O5lz91xSOeoXP6DulyHfllpq+Eg00MWitZIbtPfoSEvqIHdl5gfcY6hYzDWnj0qD5tz52PI08u9qUvSVeUBeHw== + +node-releases@^2.0.19: + version "2.0.19" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/node-releases/-/node-releases-2.0.19.tgz#9e445a52950951ec4d177d843af370b411caf314" + integrity sha512-xxOWJsBKtzAq7DY0J+DTzuz58K8e7sJbdgwkbMWQe8UYB6ekmsQ45q0M/tJDsGaZmbC+l7n57UV8Hl5tHxO9uw== + +normalize-path@^3.0.0: + version "3.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/normalize-path/-/normalize-path-3.0.0.tgz#0dcd69ff23a1c9b11fd0978316644a0388216a65" + integrity sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA== + +npm-run-path@^4.0.1: + version "4.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/npm-run-path/4.0.1/npm-run-path-4.0.1.tgz#b7ecd1e5ed53da8e37a55e1c2269e0b97ed748ea" + integrity sha1-t+zR5e1T2o43pV4cImnguX7XSOo= + dependencies: + path-key "^3.0.0" + +object-inspect@^1.13.3: + version "1.13.4" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/object-inspect/-/object-inspect-1.13.4.tgz#8375265e21bc20d0fa582c22e1b13485d6e00213" + integrity sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew== + +object-keys@^1.1.1: + version "1.1.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/object-keys/-/object-keys-1.1.1.tgz#1c47f272df277f3b1daf061677d9c82e2322c60e" + integrity sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA== + +object.assign@^4.1.7: + version "4.1.7" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/object.assign/-/object.assign-4.1.7.tgz#8c14ca1a424c6a561b0bb2a22f66f5049a945d3d" + integrity sha512-nK28WOo+QIjBkDduTINE4JkF/UJJKyf2EJxvJKfblDpyg0Q+pkOHNTL0Qwy6NP6FhE/EnzV73BxxqcJaXY9anw== + dependencies: + call-bind "^1.0.8" + call-bound "^1.0.3" + define-properties "^1.2.1" + es-object-atoms "^1.0.0" + has-symbols "^1.1.0" + object-keys "^1.1.1" + +object.fromentries@^2.0.8: + version "2.0.8" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/object.fromentries/2.0.8/object.fromentries-2.0.8.tgz#f7195d8a9b97bd95cbc1999ea939ecd1a2b00c65" + integrity sha1-9xldipuXvZXLwZmeqTns0aKwDGU= + dependencies: + call-bind "^1.0.7" + define-properties "^1.2.1" + es-abstract "^1.23.2" + es-object-atoms "^1.0.0" + +object.groupby@^1.0.3: + version "1.0.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/object.groupby/1.0.3/object.groupby-1.0.3.tgz#9b125c36238129f6f7b61954a1e7176148d5002e" + integrity sha1-mxJcNiOBKfb3thlUoecXYUjVAC4= + dependencies: + call-bind "^1.0.7" + define-properties "^1.2.1" + es-abstract "^1.23.2" + +object.values@^1.2.0: + version "1.2.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/object.values/-/object.values-1.2.1.tgz#deed520a50809ff7f75a7cfd4bc64c7a038c6216" + integrity sha512-gXah6aZrcUxjWg2zR2MwouP2eHlCBzdV4pygudehaKXSGW4v2AsRQUK+lwwXhii6KFZcunEnmSUoYp5CXibxtA== + dependencies: + call-bind "^1.0.8" + call-bound "^1.0.3" + define-properties "^1.2.1" + es-object-atoms "^1.0.0" + +once@^1.3.0: + version "1.4.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/once/-/once-1.4.0.tgz#583b1aa775961d4b113ac17d9c50baef9dd76bd1" + integrity sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w== + dependencies: + wrappy "1" + +onetime@^5.1.2: + version "5.1.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/onetime/-/onetime-5.1.2.tgz#d0e96ebb56b07476df1dd9c4806e5237985ca45e" + integrity sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg== + dependencies: + mimic-fn "^2.1.0" + +optionator@^0.9.3: + version "0.9.4" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/optionator/-/optionator-0.9.4.tgz#7ea1c1a5d91d764fb282139c88fe11e182a3a734" + integrity sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g== + dependencies: + deep-is "^0.1.3" + fast-levenshtein "^2.0.6" + levn "^0.4.1" + prelude-ls "^1.2.1" + type-check "^0.4.0" + word-wrap "^1.2.5" + +os-tmpdir@~1.0.2: + version "1.0.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/os-tmpdir/1.0.2/os-tmpdir-1.0.2.tgz#bbe67406c79aa85c5cfec766fe5734555dfa1274" + integrity sha1-u+Z0BseaqFxc/sdm/lc0VV36EnQ= + +own-keys@^1.0.1: + version "1.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/own-keys/-/own-keys-1.0.1.tgz#e4006910a2bf913585289676eebd6f390cf51358" + integrity sha512-qFOyK5PjiWZd+QQIh+1jhdb9LpxTF0qs7Pm8o5QHYZ0M3vKqSqzsZaEB6oWlxZ+q2sJBMI/Ktgd2N5ZwQoRHfg== + dependencies: + get-intrinsic "^1.2.6" + object-keys "^1.1.1" + safe-push-apply "^1.0.0" + +p-limit@^2.2.0: + version "2.3.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/p-limit/2.3.0/p-limit-2.3.0.tgz#3dd33c647a214fdfffd835933eb086da0dc21db1" + integrity sha1-PdM8ZHohT9//2DWTPrCG2g3CHbE= + dependencies: + p-try "^2.0.0" + +p-limit@^3.0.2, p-limit@^3.1.0: + version "3.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/p-limit/-/p-limit-3.1.0.tgz#e1daccbe78d0d1388ca18c64fea38e3e57e3706b" + integrity sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ== + dependencies: + yocto-queue "^0.1.0" + +p-locate@^4.1.0: + version "4.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/p-locate/4.1.0/p-locate-4.1.0.tgz#a3428bb7088b3a60292f66919278b7c297ad4f07" + integrity sha1-o0KLtwiLOmApL2aRkni3wpetTwc= + dependencies: + p-limit "^2.2.0" + +p-locate@^5.0.0: + version "5.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/p-locate/-/p-locate-5.0.0.tgz#83c8315c6785005e3bd021839411c9e110e6d834" + integrity sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw== + dependencies: + p-limit "^3.0.2" + +p-try@^2.0.0: + version "2.2.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/p-try/2.2.0/p-try-2.2.0.tgz#cb2868540e313d61de58fafbe35ce9004d5540e6" + integrity sha1-yyhoVA4xPWHeWPr741zpAE1VQOY= + +parent-module@^1.0.0: + version "1.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/parent-module/-/parent-module-1.0.1.tgz#691d2709e78c79fae3a156622452d00762caaaa2" + integrity sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g== + dependencies: + callsites "^3.0.0" + +parse-json@^5.2.0: + version "5.2.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/parse-json/-/parse-json-5.2.0.tgz#c76fc66dee54231c962b22bcc8a72cf2f99753cd" + integrity sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg== + dependencies: + "@babel/code-frame" "^7.0.0" + error-ex "^1.3.1" + json-parse-even-better-errors "^2.3.0" + lines-and-columns "^1.1.6" + +path-exists@^4.0.0: + version "4.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/path-exists/-/path-exists-4.0.0.tgz#513bdbe2d3b95d7762e8c1137efa195c6c61b5b3" + integrity sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w== + +path-is-absolute@^1.0.0: + version "1.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f" + integrity sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg== + +path-key@^3.0.0, path-key@^3.1.0: + version "3.1.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/path-key/-/path-key-3.1.1.tgz#581f6ade658cbba65a0d3380de7753295054f375" + integrity sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q== + +path-parse@^1.0.7: + version "1.0.7" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/path-parse/-/path-parse-1.0.7.tgz#fbc114b60ca42b30d9daf5858e4bd68bbedb6735" + integrity sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw== + +path-type@^4.0.0: + version "4.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/path-type/-/path-type-4.0.0.tgz#84ed01c0a7ba380afe09d90a8c180dcd9d03043b" + integrity sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw== + +picocolors@^1.1.1: + version "1.1.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/picocolors/-/picocolors-1.1.1.tgz#3d321af3eab939b083c8f929a1d12cda81c26b6b" + integrity sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA== + +picomatch@^2.0.4, picomatch@^2.2.3, picomatch@^2.3.1: + version "2.3.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/picomatch/-/picomatch-2.3.1.tgz#3ba3833733646d9d3e4995946c1365a67fb07a42" + integrity sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA== + +pirates@^4.0.4: + version "4.0.7" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/pirates/-/pirates-4.0.7.tgz#643b4a18c4257c8a65104b73f3049ce9a0a15e22" + integrity sha512-TfySrs/5nm8fQJDcBDuUng3VOUKsd7S+zqvbOTiGXHfxX4wK31ard+hoNuvkicM/2YFzlpDgABOevKSsB4G/FA== + +pkg-dir@^4.2.0: + version "4.2.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/pkg-dir/4.2.0/pkg-dir-4.2.0.tgz#f099133df7ede422e81d1d8448270eeb3e4261f3" + integrity sha1-8JkTPfft5CLoHR2ESCcO6z5CYfM= + dependencies: + find-up "^4.0.0" + +possible-typed-array-names@^1.0.0: + version "1.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/possible-typed-array-names/1.0.0/possible-typed-array-names-1.0.0.tgz#89bb63c6fada2c3e90adc4a647beeeb39cc7bf8f" + integrity sha1-ibtjxvraLD6QrcSmR77us5zHv48= + +prelude-ls@^1.2.1: + version "1.2.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/prelude-ls/-/prelude-ls-1.2.1.tgz#debc6489d7a6e6b0e7611888cec880337d316396" + integrity sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g== + +prettier-linter-helpers@^1.0.0: + version "1.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/prettier-linter-helpers/1.0.0/prettier-linter-helpers-1.0.0.tgz#d23d41fe1375646de2d0104d3454a3008802cf7b" + integrity sha1-0j1B/hN1ZG3i0BBNNFSjAIgCz3s= + dependencies: + fast-diff "^1.1.2" + +prettier@^3.3.3: + version "3.5.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/prettier/-/prettier-3.5.3.tgz#4fc2ce0d657e7a02e602549f053b239cb7dfe1b5" + integrity sha512-QQtaxnoDJeAkDvDKWCLiwIXkTgRhwYDEQCghU9Z6q03iyek/rxRh/2lC3HB7P8sWT2xC/y5JDctPLBIGzHKbhw== + +pretty-format@^29.0.0, pretty-format@^29.7.0: + version "29.7.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/pretty-format/-/pretty-format-29.7.0.tgz#ca42c758310f365bfa71a0bda0a807160b776812" + integrity sha512-Pdlw/oPxN+aXdmM9R00JVC9WVFoCLTKJvDVLgmJ+qAffBMxsV85l/Lu7sNx4zSzPyoL2euImuEwHhOXdEgNFZQ== + dependencies: + "@jest/schemas" "^29.6.3" + ansi-styles "^5.0.0" + react-is "^18.0.0" + +prompts@^2.0.1: + version "2.4.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/prompts/2.4.2/prompts-2.4.2.tgz#7b57e73b3a48029ad10ebd44f74b01722a4cb069" + integrity sha1-e1fnOzpIAprRDr1E90sBcipMsGk= + dependencies: + kleur "^3.0.3" + sisteransi "^1.0.5" + +punycode@^2.1.0: + version "2.3.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/punycode/-/punycode-2.3.1.tgz#027422e2faec0b25e1549c3e1bd8309b9133b6e5" + integrity sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg== + +pure-rand@^6.0.0: + version "6.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/pure-rand/6.1.0/pure-rand-6.1.0.tgz#d173cf23258231976ccbdb05247c9787957604f2" + integrity sha1-0XPPIyWCMZdsy9sFJHyXh5V2BPI= + +queue-microtask@^1.2.2: + version "1.2.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/queue-microtask/-/queue-microtask-1.2.3.tgz#4929228bbc724dfac43e0efb058caf7b6cfb6243" + integrity sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A== + +react-is@^18.0.0: + version "18.3.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/react-is/-/react-is-18.3.1.tgz#e83557dc12eae63a99e003a46388b1dcbb44db7e" + integrity sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg== + +reflect.getprototypeof@^1.0.6, reflect.getprototypeof@^1.0.9: + version "1.0.10" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/reflect.getprototypeof/-/reflect.getprototypeof-1.0.10.tgz#c629219e78a3316d8b604c765ef68996964e7bf9" + integrity sha512-00o4I+DVrefhv+nX0ulyi3biSHCPDe+yLv5o/p6d/UVlirijB8E16FtfwSAi4g3tcqrQ4lRAqQSoFEZJehYEcw== + dependencies: + call-bind "^1.0.8" + define-properties "^1.2.1" + es-abstract "^1.23.9" + es-errors "^1.3.0" + es-object-atoms "^1.0.0" + get-intrinsic "^1.2.7" + get-proto "^1.0.1" + which-builtin-type "^1.2.1" + +regexp.prototype.flags@^1.5.3: + version "1.5.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/regexp.prototype.flags/-/regexp.prototype.flags-1.5.3.tgz#b3ae40b1d2499b8350ab2c3fe6ef3845d3a96f42" + integrity sha512-vqlC04+RQoFalODCbCumG2xIOvapzVMHwsyIGM/SIE8fRhFFsXeH8/QQ+s0T0kDAhKc4k30s73/0ydkHQz6HlQ== + dependencies: + call-bind "^1.0.7" + define-properties "^1.2.1" + es-errors "^1.3.0" + set-function-name "^2.0.2" + +require-directory@^2.1.1: + version "2.1.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/require-directory/-/require-directory-2.1.1.tgz#8c64ad5fd30dab1c976e2344ffe7f792a6a6df42" + integrity sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q== + +resolve-cwd@^3.0.0: + version "3.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/resolve-cwd/3.0.0/resolve-cwd-3.0.0.tgz#0f0075f1bb2544766cf73ba6a6e2adfebcb13f2d" + integrity sha1-DwB18bslRHZs9zumpuKt/ryxPy0= + dependencies: + resolve-from "^5.0.0" + +resolve-from@^4.0.0: + version "4.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/resolve-from/-/resolve-from-4.0.0.tgz#4abcd852ad32dd7baabfe9b40e00a36db5f392e6" + integrity sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g== + +resolve-from@^5.0.0: + version "5.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/resolve-from/-/resolve-from-5.0.0.tgz#c35225843df8f776df21c57557bc087e9dfdfc69" + integrity sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw== + +resolve-pkg-maps@^1.0.0: + version "1.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/resolve-pkg-maps/1.0.0/resolve-pkg-maps-1.0.0.tgz#616b3dc2c57056b5588c31cdf4b3d64db133720f" + integrity sha1-YWs9wsVwVrVYjDHN9LPWTbEzcg8= + +resolve.exports@^2.0.0: + version "2.0.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/resolve.exports/-/resolve.exports-2.0.3.tgz#41955e6f1b4013b7586f873749a635dea07ebe3f" + integrity sha512-OcXjMsGdhL4XnbShKpAcSqPMzQoYkYyhbEaeSko47MjRP9NfEQMhZkXL1DoFlt9LWQn4YttrdnV6X2OiyzBi+A== + +resolve@^1.20.0, resolve@^1.22.4: + version "1.22.10" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/resolve/-/resolve-1.22.10.tgz#b663e83ffb09bbf2386944736baae803029b8b39" + integrity sha512-NPRy+/ncIMeDlTAsuqwKIiferiawhefFJtkNSW0qZJEqMEb+qBt/77B/jGeeek+F0uOeN05CDa6HXbbIgtVX4w== + dependencies: + is-core-module "^2.16.0" + path-parse "^1.0.7" + supports-preserve-symlinks-flag "^1.0.0" + +reusify@^1.0.4: + version "1.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/reusify/-/reusify-1.1.0.tgz#0fe13b9522e1473f51b558ee796e08f11f9b489f" + integrity sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw== + +rimraf@^3.0.2: + version "3.0.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/rimraf/3.0.2/rimraf-3.0.2.tgz#f1a5402ba6220ad52cc1282bac1ae3aa49fd061a" + integrity sha1-8aVAK6YiCtUswSgrrBrjqkn9Bho= + dependencies: + glob "^7.1.3" + +run-parallel@^1.1.9: + version "1.2.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/run-parallel/-/run-parallel-1.2.0.tgz#66d1368da7bdf921eb9d95bd1a9229e7f21a43ee" + integrity sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA== + dependencies: + queue-microtask "^1.2.2" + +safe-array-concat@^1.1.3: + version "1.1.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/safe-array-concat/-/safe-array-concat-1.1.3.tgz#c9e54ec4f603b0bbb8e7e5007a5ee7aecd1538c3" + integrity sha512-AURm5f0jYEOydBj7VQlVvDrjeFgthDdEF5H1dP+6mNpoXOMo1quQqJ4wvJDyRZ9+pO3kGWoOdmV08cSv2aJV6Q== + dependencies: + call-bind "^1.0.8" + call-bound "^1.0.2" + get-intrinsic "^1.2.6" + has-symbols "^1.1.0" + isarray "^2.0.5" + +safe-push-apply@^1.0.0: + version "1.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/safe-push-apply/-/safe-push-apply-1.0.0.tgz#01850e981c1602d398c85081f360e4e6d03d27f5" + integrity sha512-iKE9w/Z7xCzUMIZqdBsp6pEQvwuEebH4vdpjcDWnyzaI6yl6O9FHvVpmGelvEHNsoY6wGblkxR6Zty/h00WiSA== + dependencies: + es-errors "^1.3.0" + isarray "^2.0.5" + +safe-regex-test@^1.1.0: + version "1.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/safe-regex-test/-/safe-regex-test-1.1.0.tgz#7f87dfb67a3150782eaaf18583ff5d1711ac10c1" + integrity sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw== + dependencies: + call-bound "^1.0.2" + es-errors "^1.3.0" + is-regex "^1.2.1" + +"safer-buffer@>= 2.1.2 < 3": + version "2.1.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/safer-buffer/2.1.2/safer-buffer-2.1.2.tgz#44fa161b0187b9549dd84bb91802f9bd8385cd6a" + integrity sha1-RPoWGwGHuVSd2Eu5GAL5vYOFzWo= + +semver@^6.3.0, semver@^6.3.1: + version "6.3.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/semver/-/semver-6.3.1.tgz#556d2ef8689146e46dcea4bfdd095f3434dffcb4" + integrity sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA== + +semver@^7.3.7, semver@^7.5.3, semver@^7.5.4, semver@^7.7.1: + version "7.7.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/semver/-/semver-7.7.2.tgz#67d99fdcd35cec21e6f8b87a7fd515a33f982b58" + integrity sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA== + +set-function-length@^1.2.2: + version "1.2.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/set-function-length/1.2.2/set-function-length-1.2.2.tgz#aac72314198eaed975cf77b2c3b6b880695e5449" + integrity sha1-qscjFBmOrtl1z3eyw7a4gGleVEk= + dependencies: + define-data-property "^1.1.4" + es-errors "^1.3.0" + function-bind "^1.1.2" + get-intrinsic "^1.2.4" + gopd "^1.0.1" + has-property-descriptors "^1.0.2" + +set-function-name@^2.0.2: + version "2.0.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/set-function-name/2.0.2/set-function-name-2.0.2.tgz#16a705c5a0dc2f5e638ca96d8a8cd4e1c2b90985" + integrity sha1-FqcFxaDcL15jjKltiozU4cK5CYU= + dependencies: + define-data-property "^1.1.4" + es-errors "^1.3.0" + functions-have-names "^1.2.3" + has-property-descriptors "^1.0.2" + +set-proto@^1.0.0: + version "1.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/set-proto/-/set-proto-1.0.0.tgz#0760dbcff30b2d7e801fd6e19983e56da337565e" + integrity sha512-RJRdvCo6IAnPdsvP/7m6bsQqNnn1FCBX5ZNtFL98MmFF/4xAIJTIg1YbHW5DC2W5SKZanrC6i4HsJqlajw/dZw== + dependencies: + dunder-proto "^1.0.1" + es-errors "^1.3.0" + es-object-atoms "^1.0.0" + +shebang-command@^2.0.0: + version "2.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/shebang-command/-/shebang-command-2.0.0.tgz#ccd0af4f8835fbdc265b82461aaf0c36663f34ea" + integrity sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA== + dependencies: + shebang-regex "^3.0.0" + +shebang-regex@^3.0.0: + version "3.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/shebang-regex/-/shebang-regex-3.0.0.tgz#ae16f1644d873ecad843b0307b143362d4c42172" + integrity sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A== + +side-channel-list@^1.0.0: + version "1.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/side-channel-list/-/side-channel-list-1.0.0.tgz#10cb5984263115d3b7a0e336591e290a830af8ad" + integrity sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA== + dependencies: + es-errors "^1.3.0" + object-inspect "^1.13.3" + +side-channel-map@^1.0.1: + version "1.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/side-channel-map/-/side-channel-map-1.0.1.tgz#d6bb6b37902c6fef5174e5f533fab4c732a26f42" + integrity sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA== + dependencies: + call-bound "^1.0.2" + es-errors "^1.3.0" + get-intrinsic "^1.2.5" + object-inspect "^1.13.3" + +side-channel-weakmap@^1.0.2: + version "1.0.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz#11dda19d5368e40ce9ec2bdc1fb0ecbc0790ecea" + integrity sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A== + dependencies: + call-bound "^1.0.2" + es-errors "^1.3.0" + get-intrinsic "^1.2.5" + object-inspect "^1.13.3" + side-channel-map "^1.0.1" + +side-channel@^1.1.0: + version "1.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/side-channel/-/side-channel-1.1.0.tgz#c3fcff9c4da932784873335ec9765fa94ff66bc9" + integrity sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw== + dependencies: + es-errors "^1.3.0" + object-inspect "^1.13.3" + side-channel-list "^1.0.0" + side-channel-map "^1.0.1" + side-channel-weakmap "^1.0.2" + +signal-exit@^3.0.3, signal-exit@^3.0.7: + version "3.0.7" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/signal-exit/-/signal-exit-3.0.7.tgz#a9a1767f8af84155114eaabd73f99273c8f59ad9" + integrity sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ== + +signal-exit@^4.1.0: + version "4.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/signal-exit/-/signal-exit-4.1.0.tgz#952188c1cbd546070e2dd20d0f41c0ae0530cb04" + integrity sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw== + +sisteransi@^1.0.5: + version "1.0.5" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/sisteransi/1.0.5/sisteransi-1.0.5.tgz#134d681297756437cc05ca01370d3a7a571075ed" + integrity sha1-E01oEpd1ZDfMBcoBNw06elcQde0= + +slash@^3.0.0: + version "3.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/slash/-/slash-3.0.0.tgz#6539be870c165adbd5240220dbe361f1bc4d4634" + integrity sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q== + +source-map-support@0.5.13: + version "0.5.13" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/source-map-support/0.5.13/source-map-support-0.5.13.tgz#31b24a9c2e73c2de85066c0feb7d44767ed52932" + integrity sha1-MbJKnC5zwt6FBmwP631Edn7VKTI= + dependencies: + buffer-from "^1.0.0" + source-map "^0.6.0" + +source-map@^0.6.0, source-map@^0.6.1: + version "0.6.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/source-map/0.6.1/source-map-0.6.1.tgz#74722af32e9614e9c287a8d0bbde48b5e2f1a263" + integrity sha1-dHIq8y6WFOnCh6jQu95IteLxomM= + +sprintf-js@~1.0.2: + version "1.0.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/sprintf-js/-/sprintf-js-1.0.3.tgz#04e6926f662895354f3dd015203633b857297e2c" + integrity sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g== + +stack-utils@^2.0.3: + version "2.0.6" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/stack-utils/2.0.6/stack-utils-2.0.6.tgz#aaf0748169c02fc33c8232abccf933f54a1cc34f" + integrity sha1-qvB0gWnAL8M8gjKrzPkz9Uocw08= + dependencies: + escape-string-regexp "^2.0.0" + +string-length@^4.0.1: + version "4.0.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/string-length/4.0.2/string-length-4.0.2.tgz#a8a8dc7bd5c1a82b9b3c8b87e125f66871b6e57a" + integrity sha1-qKjce9XBqCubPIuH4SX2aHG25Xo= + dependencies: + char-regex "^1.0.2" + strip-ansi "^6.0.0" + +string-width@^4.1.0, string-width@^4.2.0, string-width@^4.2.3: + version "4.2.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/string-width/-/string-width-4.2.3.tgz#269c7117d27b05ad2e536830a8ec895ef9c6d010" + integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g== + dependencies: + emoji-regex "^8.0.0" + is-fullwidth-code-point "^3.0.0" + strip-ansi "^6.0.1" + +string.prototype.trim@^1.2.10: + version "1.2.10" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/string.prototype.trim/-/string.prototype.trim-1.2.10.tgz#40b2dd5ee94c959b4dcfb1d65ce72e90da480c81" + integrity sha512-Rs66F0P/1kedk5lyYyH9uBzuiI/kNRmwJAR9quK6VOtIpZ2G+hMZd+HQbbv25MgCA6gEffoMZYxlTod4WcdrKA== + dependencies: + call-bind "^1.0.8" + call-bound "^1.0.2" + define-data-property "^1.1.4" + define-properties "^1.2.1" + es-abstract "^1.23.5" + es-object-atoms "^1.0.0" + has-property-descriptors "^1.0.2" + +string.prototype.trimend@^1.0.8, string.prototype.trimend@^1.0.9: + version "1.0.9" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/string.prototype.trimend/-/string.prototype.trimend-1.0.9.tgz#62e2731272cd285041b36596054e9f66569b6942" + integrity sha512-G7Ok5C6E/j4SGfyLCloXTrngQIQU3PWtXGst3yM7Bea9FRURf1S42ZHlZZtsNque2FN2PoUhfZXYLNWwEr4dLQ== + dependencies: + call-bind "^1.0.8" + call-bound "^1.0.2" + define-properties "^1.2.1" + es-object-atoms "^1.0.0" + +string.prototype.trimstart@^1.0.8: + version "1.0.8" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/string.prototype.trimstart/1.0.8/string.prototype.trimstart-1.0.8.tgz#7ee834dda8c7c17eff3118472bb35bfedaa34dde" + integrity sha1-fug03ajHwX7/MRhHK7Nb/tqjTd4= + dependencies: + call-bind "^1.0.7" + define-properties "^1.2.1" + es-object-atoms "^1.0.0" + +strip-ansi@^6.0.0, strip-ansi@^6.0.1: + version "6.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/strip-ansi/-/strip-ansi-6.0.1.tgz#9e26c63d30f53443e9489495b2105d37b67a85d9" + integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A== + dependencies: + ansi-regex "^5.0.1" + +strip-bom@^3.0.0: + version "3.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/strip-bom/-/strip-bom-3.0.0.tgz#2334c18e9c759f7bdd56fdef7e9ae3d588e68ed3" + integrity sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA== + +strip-bom@^4.0.0: + version "4.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/strip-bom/4.0.0/strip-bom-4.0.0.tgz#9c3505c1db45bcedca3d9cf7a16f5c5aa3901878" + integrity sha1-nDUFwdtFvO3KPZz3oW9cWqOQGHg= + +strip-final-newline@^2.0.0: + version "2.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/strip-final-newline/2.0.0/strip-final-newline-2.0.0.tgz#89b852fb2fcbe936f6f4b3187afb0a12c1ab58ad" + integrity sha1-ibhS+y/L6Tb29LMYevsKEsGrWK0= + +strip-json-comments@^3.1.1: + version "3.1.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/strip-json-comments/-/strip-json-comments-3.1.1.tgz#31f1281b3832630434831c310c01cccda8cbe006" + integrity sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig== + +supports-color@^7.1.0: + version "7.2.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/supports-color/-/supports-color-7.2.0.tgz#1b7dcdcb32b8138801b3e478ba6a51caa89648da" + integrity sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw== + dependencies: + has-flag "^4.0.0" + +supports-color@^8.0.0: + version "8.1.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/supports-color/-/supports-color-8.1.1.tgz#cd6fc17e28500cff56c1b86c0a7fd4a54a73005c" + integrity sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q== + dependencies: + has-flag "^4.0.0" + +supports-preserve-symlinks-flag@^1.0.0: + version "1.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz#6eda4bd344a3c94aea376d4cc31bc77311039e09" + integrity sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w== + +synckit@^0.11.0: + version "0.11.4" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/synckit/-/synckit-0.11.4.tgz#48972326b59723fc15b8d159803cf8302b545d59" + integrity sha512-Q/XQKRaJiLiFIBNN+mndW7S/RHxvwzuZS6ZwmRzUBqJBv/5QIKCEwkBC8GBf8EQJKYnaFs0wOZbKTXBPj8L9oQ== + dependencies: + "@pkgr/core" "^0.2.3" + tslib "^2.8.1" + +tapable@^2.2.0: + version "2.2.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/tapable/-/tapable-2.2.2.tgz#ab4984340d30cb9989a490032f086dbb8b56d872" + integrity sha512-Re10+NauLTMCudc7T5WLFLAwDhQ0JWdrMK+9B2M8zR5hRExKmsRDCBA7/aV/pNJFltmBFO5BAMlQFi/vq3nKOg== + +test-exclude@^6.0.0: + version "6.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/test-exclude/6.0.0/test-exclude-6.0.0.tgz#04a8698661d805ea6fa293b6cb9e63ac044ef15e" + integrity sha1-BKhphmHYBepvopO2y55jrARO8V4= + dependencies: + "@istanbuljs/schema" "^0.1.2" + glob "^7.1.4" + minimatch "^3.0.4" + +text-table@^0.2.0: + version "0.2.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/text-table/0.2.0/text-table-0.2.0.tgz#7f5ee823ae805207c00af2df4a84ec3fcfa570b4" + integrity sha1-f17oI66AUgfACvLfSoTsP8+lcLQ= + +tmp@^0.0.33: + version "0.0.33" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/tmp/0.0.33/tmp-0.0.33.tgz#6d34335889768d21b2bcda0aa277ced3b1bfadf9" + integrity sha1-bTQzWIl2jSGyvNoKonfO07G/rfk= + dependencies: + os-tmpdir "~1.0.2" + +tmpl@1.0.5: + version "1.0.5" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/tmpl/-/tmpl-1.0.5.tgz#8683e0b902bb9c20c4f726e3c0b69f36518c07cc" + integrity sha512-3f0uOEAQwIqGuWW2MVzYg8fV/QNnc/IpuJNG837rLuczAaLVHslWHZQj4IGiEl5Hs3kkbhwL9Ab7Hrsmuj+Smw== + +to-regex-range@^5.0.1: + version "5.0.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/to-regex-range/-/to-regex-range-5.0.1.tgz#1648c44aae7c8d988a326018ed72f5b4dd0392e4" + integrity sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ== + dependencies: + is-number "^7.0.0" + +ts-jest@^29.3.2: + version "29.3.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/ts-jest/-/ts-jest-29.3.2.tgz#0576cdf0a507f811fe73dcd16d135ce89f8156cb" + integrity sha512-bJJkrWc6PjFVz5g2DGCNUo8z7oFEYaz1xP1NpeDU7KNLMWPpEyV8Chbpkn8xjzgRDpQhnGMyvyldoL7h8JXyug== + dependencies: + bs-logger "^0.2.6" + ejs "^3.1.10" + fast-json-stable-stringify "^2.1.0" + jest-util "^29.0.0" + json5 "^2.2.3" + lodash.memoize "^4.1.2" + make-error "^1.3.6" + semver "^7.7.1" + type-fest "^4.39.1" + yargs-parser "^21.1.1" + +tsconfig-paths@^3.15.0: + version "3.15.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/tsconfig-paths/3.15.0/tsconfig-paths-3.15.0.tgz#5299ec605e55b1abb23ec939ef15edaf483070d4" + integrity sha1-UpnsYF5VsauyPsk57xXtr0gwcNQ= + dependencies: + "@types/json5" "^0.0.29" + json5 "^1.0.2" + minimist "^1.2.6" + strip-bom "^3.0.0" + +tslib@^1.8.1: + version "1.14.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/tslib/-/tslib-1.14.1.tgz#cf2d38bdc34a134bcaf1091c41f6619e2f672d00" + integrity sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg== + +tslib@^2.8.1: + version "2.8.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/tslib/-/tslib-2.8.1.tgz#612efe4ed235d567e8aba5f2a5fab70280ade83f" + integrity sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w== + +tsutils@^3.21.0: + version "3.21.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/tsutils/3.21.0/tsutils-3.21.0.tgz#b48717d394cea6c1e096983eed58e9d61715b623" + integrity sha1-tIcX05TOpsHglpg+7Vjp1hcVtiM= + dependencies: + tslib "^1.8.1" + +type-check@^0.4.0, type-check@~0.4.0: + version "0.4.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/type-check/-/type-check-0.4.0.tgz#07b8203bfa7056c0657050e3ccd2c37730bab8f1" + integrity sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew== + dependencies: + prelude-ls "^1.2.1" + +type-detect@4.0.8: + version "4.0.8" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/type-detect/4.0.8/type-detect-4.0.8.tgz#7646fb5f18871cfbb7749e69bd39a6388eb7450c" + integrity sha1-dkb7XxiHHPu3dJ5pvTmmOI63RQw= + +type-fest@^0.20.2: + version "0.20.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/type-fest/0.20.2/type-fest-0.20.2.tgz#1bf207f4b28f91583666cb5fbd327887301cd5f4" + integrity sha1-G/IH9LKPkVg2ZstfvTJ4hzAc1fQ= + +type-fest@^0.21.3: + version "0.21.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/type-fest/-/type-fest-0.21.3.tgz#d260a24b0198436e133fa26a524a6d65fa3b2e37" + integrity sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w== + +type-fest@^4.39.1: + version "4.41.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/type-fest/-/type-fest-4.41.0.tgz#6ae1c8e5731273c2bf1f58ad39cbae2c91a46c58" + integrity sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA== + +typed-array-buffer@^1.0.3: + version "1.0.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/typed-array-buffer/-/typed-array-buffer-1.0.3.tgz#a72395450a4869ec033fd549371b47af3a2ee536" + integrity sha512-nAYYwfY3qnzX30IkA6AQZjVbtK6duGontcQm1WSG1MD94YLqK0515GNApXkoxKOWMusVssAHWLh9SeaoefYFGw== + dependencies: + call-bound "^1.0.3" + es-errors "^1.3.0" + is-typed-array "^1.1.14" + +typed-array-byte-length@^1.0.3: + version "1.0.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/typed-array-byte-length/-/typed-array-byte-length-1.0.3.tgz#8407a04f7d78684f3d252aa1a143d2b77b4160ce" + integrity sha512-BaXgOuIxz8n8pIq3e7Atg/7s+DpiYrxn4vdot3w9KbnBhcRQq6o3xemQdIfynqSeXeDrF32x+WvfzmOjPiY9lg== + dependencies: + call-bind "^1.0.8" + for-each "^0.3.3" + gopd "^1.2.0" + has-proto "^1.2.0" + is-typed-array "^1.1.14" + +typed-array-byte-offset@^1.0.4: + version "1.0.4" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/typed-array-byte-offset/-/typed-array-byte-offset-1.0.4.tgz#ae3698b8ec91a8ab945016108aef00d5bff12355" + integrity sha512-bTlAFB/FBYMcuX81gbL4OcpH5PmlFHqlCCpAl8AlEzMz5k53oNDvN8p1PNOWLEmI2x4orp3raOFB51tv9X+MFQ== + dependencies: + available-typed-arrays "^1.0.7" + call-bind "^1.0.8" + for-each "^0.3.3" + gopd "^1.2.0" + has-proto "^1.2.0" + is-typed-array "^1.1.15" + reflect.getprototypeof "^1.0.9" + +typed-array-length@^1.0.7: + version "1.0.7" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/typed-array-length/-/typed-array-length-1.0.7.tgz#ee4deff984b64be1e118b0de8c9c877d5ce73d3d" + integrity sha512-3KS2b+kL7fsuk/eJZ7EQdnEmQoaho/r6KUef7hxvltNA5DR8NAUM+8wJMbJyZ4G9/7i3v5zPBIMN5aybAh2/Jg== + dependencies: + call-bind "^1.0.7" + for-each "^0.3.3" + gopd "^1.0.1" + is-typed-array "^1.1.13" + possible-typed-array-names "^1.0.0" + reflect.getprototypeof "^1.0.6" + +typescript@^5.6.3: + version "5.8.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/typescript/-/typescript-5.8.3.tgz#92f8a3e5e3cf497356f4178c34cd65a7f5e8440e" + integrity sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ== + +unbox-primitive@^1.1.0: + version "1.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/unbox-primitive/-/unbox-primitive-1.1.0.tgz#8d9d2c9edeea8460c7f35033a88867944934d1e2" + integrity sha512-nWJ91DjeOkej/TA8pXQ3myruKpKEYgqvpw9lz4OPHj/NWFNluYrjbz9j01CJ8yKQd2g4jFoOkINCTW2I5LEEyw== + dependencies: + call-bound "^1.0.3" + has-bigints "^1.0.2" + has-symbols "^1.1.0" + which-boxed-primitive "^1.1.1" + +undici-types@~6.21.0: + version "6.21.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/undici-types/-/undici-types-6.21.0.tgz#691d00af3909be93a7faa13be61b3a5b50ef12cb" + integrity sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ== + +update-browserslist-db@^1.1.3: + version "1.1.3" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/update-browserslist-db/-/update-browserslist-db-1.1.3.tgz#348377dd245216f9e7060ff50b15a1b740b75420" + integrity sha512-UxhIZQ+QInVdunkDAaiazvvT/+fXL5Osr0JZlJulepYu6Jd7qJtDZjlur0emRlT71EN3ScPoE7gvsuIKKNavKw== + dependencies: + escalade "^3.2.0" + picocolors "^1.1.1" + +uri-js@^4.2.2: + version "4.4.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/uri-js/-/uri-js-4.4.1.tgz#9b1a52595225859e55f669d928f88c6c57f2a77e" + integrity sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg== + dependencies: + punycode "^2.1.0" + +v8-to-istanbul@^9.0.1: + version "9.3.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/v8-to-istanbul/-/v8-to-istanbul-9.3.0.tgz#b9572abfa62bd556c16d75fdebc1a411d5ff3175" + integrity sha512-kiGUalWN+rgBJ/1OHZsBtU4rXZOfj/7rKQxULKlIzwzQSvMJUUNgPwJEEh7gU6xEVxC0ahoOBvN2YI8GH6FNgA== + dependencies: + "@jridgewell/trace-mapping" "^0.3.12" + "@types/istanbul-lib-coverage" "^2.0.1" + convert-source-map "^2.0.0" + +walker@^1.0.8: + version "1.0.8" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/walker/-/walker-1.0.8.tgz#bd498db477afe573dc04185f011d3ab8a8d7653f" + integrity sha512-ts/8E8l5b7kY0vlWLewOkDXMmPdLcVV4GmOQLyxuSswIJsweeFZtAsMF7k1Nszz+TYBQrlYRmzOnr398y1JemQ== + dependencies: + makeerror "1.0.12" + +which-boxed-primitive@^1.1.0, which-boxed-primitive@^1.1.1: + version "1.1.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/which-boxed-primitive/-/which-boxed-primitive-1.1.1.tgz#d76ec27df7fa165f18d5808374a5fe23c29b176e" + integrity sha512-TbX3mj8n0odCBFVlY8AxkqcHASw3L60jIuF8jFP78az3C2YhmGvqbHBpAjTRH2/xqYunrJ9g1jSyjCjpoWzIAA== + dependencies: + is-bigint "^1.1.0" + is-boolean-object "^1.2.1" + is-number-object "^1.1.1" + is-string "^1.1.1" + is-symbol "^1.1.1" + +which-builtin-type@^1.2.1: + version "1.2.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/which-builtin-type/-/which-builtin-type-1.2.1.tgz#89183da1b4907ab089a6b02029cc5d8d6574270e" + integrity sha512-6iBczoX+kDQ7a3+YJBnh3T+KZRxM/iYNPXicqk66/Qfm1b93iu+yOImkg0zHbj5LNOcNv1TEADiZ0xa34B4q6Q== + dependencies: + call-bound "^1.0.2" + function.prototype.name "^1.1.6" + has-tostringtag "^1.0.2" + is-async-function "^2.0.0" + is-date-object "^1.1.0" + is-finalizationregistry "^1.1.0" + is-generator-function "^1.0.10" + is-regex "^1.2.1" + is-weakref "^1.0.2" + isarray "^2.0.5" + which-boxed-primitive "^1.1.0" + which-collection "^1.0.2" + which-typed-array "^1.1.16" + +which-collection@^1.0.2: + version "1.0.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/which-collection/1.0.2/which-collection-1.0.2.tgz#627ef76243920a107e7ce8e96191debe4b16c2a0" + integrity sha1-Yn73YkOSChB+fOjpYZHevksWwqA= + dependencies: + is-map "^2.0.3" + is-set "^2.0.3" + is-weakmap "^2.0.2" + is-weakset "^2.0.3" + +which-typed-array@^1.1.16, which-typed-array@^1.1.18: + version "1.1.19" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/which-typed-array/-/which-typed-array-1.1.19.tgz#df03842e870b6b88e117524a4b364b6fc689f956" + integrity sha512-rEvr90Bck4WZt9HHFC4DJMsjvu7x+r6bImz0/BrbWb7A2djJ8hnZMrWnHo9F8ssv0OMErasDhftrfROTyqSDrw== + dependencies: + available-typed-arrays "^1.0.7" + call-bind "^1.0.8" + call-bound "^1.0.4" + for-each "^0.3.5" + get-proto "^1.0.1" + gopd "^1.2.0" + has-tostringtag "^1.0.2" + +which@^2.0.1: + version "2.0.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/which/-/which-2.0.2.tgz#7c6a8dd0a636a0327e10b59c9286eee93f3f51b1" + integrity sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA== + dependencies: + isexe "^2.0.0" + +word-wrap@^1.2.5: + version "1.2.5" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/word-wrap/-/word-wrap-1.2.5.tgz#d2c45c6dd4fbce621a66f136cbe328afd0410b34" + integrity sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA== + +wrap-ansi@^6.2.0: + version "6.2.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/wrap-ansi/-/wrap-ansi-6.2.0.tgz#e9393ba07102e6c91a3b221478f0257cd2856e53" + integrity sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA== + dependencies: + ansi-styles "^4.0.0" + string-width "^4.1.0" + strip-ansi "^6.0.0" + +wrap-ansi@^7.0.0: + version "7.0.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/wrap-ansi/-/wrap-ansi-7.0.0.tgz#67e145cff510a6a6984bdf1152911d69d2eb9e43" + integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q== + dependencies: + ansi-styles "^4.0.0" + string-width "^4.1.0" + strip-ansi "^6.0.0" + +wrappy@1: + version "1.0.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/wrappy/1.0.2/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f" + integrity sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8= + +write-file-atomic@^4.0.2: + version "4.0.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/write-file-atomic/4.0.2/write-file-atomic-4.0.2.tgz#a9df01ae5b77858a027fd2e80768ee433555fcfd" + integrity sha1-qd8Brlt3hYoCf9LoB2juQzVV/P0= + dependencies: + imurmurhash "^0.1.4" + signal-exit "^3.0.7" + +y18n@^5.0.5: + version "5.0.8" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/y18n/-/y18n-5.0.8.tgz#7f4934d0f7ca8c56f95314939ddcd2dd91ce1d55" + integrity sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA== + +yallist@^3.0.2: + version "3.1.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/yallist/-/yallist-3.1.1.tgz#dbb7daf9bfd8bac9ab45ebf602b8cbad0d5d08fd" + integrity sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g== + +yargs-parser@^21.1.1: + version "21.1.1" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/yargs-parser/-/yargs-parser-21.1.1.tgz#9096bceebf990d21bb31fa9516e0ede294a77d35" + integrity sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw== + +yargs@^17.3.1: + version "17.7.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/yargs/-/yargs-17.7.2.tgz#991df39aca675a192b816e1e0363f9d75d2aa269" + integrity sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w== + dependencies: + cliui "^8.0.1" + escalade "^3.1.1" + get-caller-file "^2.0.5" + require-directory "^2.1.1" + string-width "^4.2.3" + y18n "^5.0.5" + yargs-parser "^21.1.1" + +yocto-queue@^0.1.0: + version "0.1.0" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/yocto-queue/-/yocto-queue-0.1.0.tgz#0294eb3dee05028d31ee1a5fa2c556a6aaf10a1b" + integrity sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q== + +yoctocolors-cjs@^2.1.2: + version "2.1.2" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/yoctocolors-cjs/-/yoctocolors-cjs-2.1.2.tgz#f4b905a840a37506813a7acaa28febe97767a242" + integrity sha512-cYVsTjKl8b+FrnidjibDWskAv7UKOfcwaVZdp/it9n1s9fU3IkgDbhdIRKCW4JDsAlECJY0ytoVPT3sK6kideA== + +zod@^3.24.4: + version "3.25.42" + resolved "https://artifactory.infra.ant.dev:443/artifactory/api/npm/npm-all/zod/-/zod-3.25.42.tgz#4818381b32f5120e7ea06decb1cde54a230cad2a" + integrity sha512-PcALTLskaucbeHc41tU/xfjfhcz8z0GdhhDcSgrCTmSazUuqnYqiXO63M0QUBVwpBlsLsNVn5qHSC5Dw3KZvaQ==