From 2879b71b7ab38d7fe21e278ccc7289d6ef5eb90a Mon Sep 17 00:00:00 2001 From: 1evi7eo Date: Sat, 24 Jan 2026 13:21:00 +0800 Subject: [PATCH 1/2] Initial Commit --- typescript/faucet-mcp/README.md | 211 ++++++++++++++++++++ typescript/faucet-mcp/index.js | 299 ++++++++++++++++++++++++++++ typescript/faucet-mcp/index.test.js | 277 ++++++++++++++++++++++++++ typescript/faucet-mcp/package.json | 41 ++++ 4 files changed, 828 insertions(+) create mode 100644 typescript/faucet-mcp/README.md create mode 100644 typescript/faucet-mcp/index.js create mode 100644 typescript/faucet-mcp/index.test.js create mode 100644 typescript/faucet-mcp/package.json diff --git a/typescript/faucet-mcp/README.md b/typescript/faucet-mcp/README.md new file mode 100644 index 0000000..d3b4287 --- /dev/null +++ b/typescript/faucet-mcp/README.md @@ -0,0 +1,211 @@ +# TBNB Faucet MCP Server (Node.js) + +A Node.js implementation of a Model Context Protocol (MCP) server that provides a faucet service for distributing testnet BNB tokens on the Binance Smart Chain testnet. + +## About + +This MCP server enables AI agents and other MCP clients to request and receive testnet BNB tokens by interacting with the BSC testnet blockchain. It follows the Anthropic MCP specification and can be integrated with any MCP-compatible client. + +## Prerequisites + +- Node.js 18.0 or higher +- npm or yarn package manager +- A BSC testnet wallet with TBNB for the faucet +- Access to BSC testnet RPC endpoint + +## Installation + +1. Navigate to the project directory: +```bash +cd faucet-mcp +``` + +2. Install dependencies: +```bash +npm install +``` + +## Configuration + +Set the following environment variables before running: + +- `FAUCET_PRIVATE_KEY`: The private key of your faucet wallet (required) +- `BSC_TESTNET_RPC`: BSC testnet RPC endpoint URL (optional, has default) + +Example: + +```bash +export FAUCET_PRIVATE_KEY="0x..." +export BSC_TESTNET_RPC="https://data-seed-prebsc-1-s1.binance.org:8545/" +``` + +Or create a `.env` file (not included in repo for security): + +``` +FAUCET_PRIVATE_KEY=0x... +BSC_TESTNET_RPC=https://data-seed-prebsc-1-s1.binance.org:8545/ +``` + +## Usage + +Run the server: + +```bash +node index.js +``` + +Or using npm: + +```bash +npm start +``` + +The server communicates via stdio, which is the standard transport for MCP servers. + +## Available Tools + +### send_tbnb + +Sends testnet BNB tokens to a recipient address. + +**Parameters:** +- `recipient` (string, required): BSC testnet address to receive tokens +- `amount` (number, optional): Amount of TBNB to send (default: 0.1, max: 1.0) + +**Returns:** +- Transaction hash +- Recipient address +- Amount sent +- Block number +- Transaction status + +### get_faucet_info + +Retrieves information about the faucet wallet. + +**Parameters:** None + +**Returns:** +- Faucet wallet address +- Current balance (Wei and TBNB) +- Network information +- RPC endpoint + +### get_balance + +Queries the TBNB balance of any BSC testnet address. + +**Parameters:** +- `address` (string, required): BSC testnet address to check + +**Returns:** +- Address (checksummed) +- Balance in Wei and TBNB +- Network name + +## MCP Client Integration + +To integrate this server with an MCP client, add it to your client configuration: + +```json +{ + "mcpServers": { + "tbnb-faucet": { + "command": "node", + "args": ["/absolute/path/to/index.js"], + "env": { + "FAUCET_PRIVATE_KEY": "0x...", + "BSC_TESTNET_RPC": "https://data-seed-prebsc-1-s1.binance.org:8545/" + } + } + } +} +``` + +## Network Configuration + +- **Network**: Binance Smart Chain Testnet +- **Chain ID**: 97 +- **Default RPC**: https://data-seed-prebsc-1-s1.binance.org:8545/ +- **Block Explorer**: https://testnet.bscscan.com + +## Error Handling + +The server includes comprehensive error handling: + +- Address validation (checksum and format) +- Amount validation (0 to 1.0 TBNB) +- Self-transfer prevention +- Network connectivity checks +- Transaction error reporting + +All errors are returned as structured JSON responses. + +## Security + +🔒 **Security Best Practices:** + +- Never commit your private key to version control +- Use environment variables or secure secret management systems +- This server is intended for testnet use only +- Consider implementing rate limiting for production deployments +- Monitor faucet balance and set up alerts + +## Troubleshooting + +### Common Issues + +**"Faucet wallet not configured"** +- Ensure `FAUCET_PRIVATE_KEY` environment variable is set +- Verify the private key is valid and starts with `0x` + +**Connection errors** +- Check your internet connection +- Verify the RPC endpoint is accessible +- Try an alternative BSC testnet RPC endpoint + +**Transaction failures** +- Ensure the faucet wallet has sufficient TBNB balance +- Verify the recipient address is valid +- Check network conditions (gas prices, congestion) + +**Module not found errors** +- Run `npm install` to install dependencies +- Ensure you're using Node.js 18.0 or higher + +## Development + +The server uses: +- `@modelcontextprotocol/sdk` for MCP protocol implementation +- `ethers.js` v6 for blockchain interactions + +## License + +MIT License + +## Testing + +Run unit tests: + +```bash +npm install +npm test +``` + +Run tests with coverage: + +```bash +npm run test:coverage +``` + +Run tests in watch mode: + +```bash +npm run test:watch +``` + +## Resources + +- [Model Context Protocol Documentation](https://modelcontextprotocol.io) +- [BNB Chain Documentation](https://docs.bnbchain.org) +- [Ethers.js Documentation](https://docs.ethers.org) diff --git a/typescript/faucet-mcp/index.js b/typescript/faucet-mcp/index.js new file mode 100644 index 0000000..6414234 --- /dev/null +++ b/typescript/faucet-mcp/index.js @@ -0,0 +1,299 @@ +#!/usr/bin/env node + +/** + * TBNB Faucet MCP Server + * Model Context Protocol server for distributing testnet BNB tokens + */ + +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 { ethers } from "ethers"; + +// Configuration +const BSC_TESTNET_RPC = process.env.BSC_TESTNET_RPC || "https://data-seed-prebsc-1-s1.binance.org:8545/"; +const FAUCET_PRIVATE_KEY = process.env.FAUCET_PRIVATE_KEY || ""; + +if (!FAUCET_PRIVATE_KEY) { + console.error("WARNING: FAUCET_PRIVATE_KEY environment variable is not set"); +} + +// Initialize provider and wallet +const provider = new ethers.JsonRpcProvider(BSC_TESTNET_RPC); +let wallet = null; +let walletAddress = null; + +if (FAUCET_PRIVATE_KEY) { + wallet = new ethers.Wallet(FAUCET_PRIVATE_KEY, provider); + walletAddress = wallet.address; +} + +// MCP Server +const server = new Server( + { + name: "tbnb-faucet", + version: "1.0.0", + }, + { + capabilities: { + tools: {}, + }, + } +); + +// List available tools +server.setRequestHandler(ListToolsRequestSchema, async () => { + return { + tools: [ + { + name: "send_tbnb", + description: "Send testnet BNB tokens to a specified address on BSC testnet", + inputSchema: { + type: "object", + properties: { + recipient: { + type: "string", + description: "The BSC testnet address that will receive the TBNB tokens", + }, + amount: { + type: "number", + description: "Amount of TBNB to send (default: 0.1, maximum: 1.0)", + default: 0.1, + }, + }, + required: ["recipient"], + }, + }, + { + name: "get_faucet_info", + description: "Get information about the faucet including current balance", + inputSchema: { + type: "object", + properties: {}, + }, + }, + { + name: "get_balance", + description: "Get the TBNB balance of a BSC testnet address", + inputSchema: { + type: "object", + properties: { + address: { + type: "string", + description: "The BSC testnet address to check", + }, + }, + required: ["address"], + }, + }, + ], + }; +}); + +// Handle tool calls +server.setRequestHandler(CallToolRequestSchema, async (request) => { + const { name, arguments: args } = request.params; + + try { + switch (name) { + case "send_tbnb": + return await handleSendTbnb(args); + case "get_faucet_info": + return await handleGetFaucetInfo(); + case "get_balance": + return await handleGetBalance(args); + default: + throw new Error(`Unknown tool: ${name}`); + } + } catch (error) { + return { + content: [ + { + type: "text", + text: JSON.stringify( + { + error: error.message, + }, + null, + 2 + ), + }, + ], + isError: true, + }; + } +}); + +/** + * Send TBNB to a recipient address + */ +async function handleSendTbnb(args) { + if (!wallet) { + throw new Error("Faucet wallet not configured. Please set FAUCET_PRIVATE_KEY."); + } + + const recipient = args?.recipient; + const amount = args?.amount || 0.1; + + if (!recipient) { + throw new Error("Recipient address is required"); + } + + // Validate address + if (!ethers.isAddress(recipient)) { + throw new Error(`Invalid address: ${recipient}`); + } + + const recipientAddress = ethers.getAddress(recipient); + + // Prevent self-transfer + if (recipientAddress.toLowerCase() === walletAddress.toLowerCase()) { + throw new Error("Cannot send tokens to the faucet address itself"); + } + + // Validate amount + if (amount <= 0 || amount > 1.0) { + throw new Error("Amount must be between 0 and 1.0 TBNB"); + } + + try { + // Convert amount to Wei + const amountWei = ethers.parseEther(amount.toString()); + + // Get current gas price + const feeData = await provider.getFeeData(); + + // Send transaction + const tx = await wallet.sendTransaction({ + to: recipientAddress, + value: amountWei, + gasLimit: 21000, + gasPrice: feeData.gasPrice, + }); + + // Wait for transaction to be mined + const receipt = await tx.wait(); + + return { + content: [ + { + type: "text", + text: JSON.stringify( + { + success: true, + transactionHash: tx.hash, + recipient: recipientAddress, + amount: amount, + amountWei: amountWei.toString(), + blockNumber: receipt.blockNumber, + status: receipt.status === 1 ? "confirmed" : "failed", + }, + null, + 2 + ), + }, + ], + }; + } catch (error) { + throw new Error(`Transaction failed: ${error.message}`); + } +} + +/** + * Get faucet information and balance + */ +async function handleGetFaucetInfo() { + if (!walletAddress) { + throw new Error("Faucet wallet not configured"); + } + + try { + const balance = await provider.getBalance(walletAddress); + const balanceTbnb = ethers.formatEther(balance); + + // Get network info + const network = await provider.getNetwork(); + + return { + content: [ + { + type: "text", + text: JSON.stringify( + { + faucetAddress: walletAddress, + balanceWei: balance.toString(), + balanceTbnb: parseFloat(balanceTbnb), + network: { + name: "BSC Testnet", + chainId: network.chainId.toString(), + }, + rpcEndpoint: BSC_TESTNET_RPC, + }, + null, + 2 + ), + }, + ], + }; + } catch (error) { + throw new Error(`Failed to get faucet info: ${error.message}`); + } +} + +/** + * Get balance of an address + */ +async function handleGetBalance(args) { + const address = args?.address; + + if (!address) { + throw new Error("Address is required"); + } + + // Validate address + if (!ethers.isAddress(address)) { + throw new Error(`Invalid address: ${address}`); + } + + try { + const addressChecksum = ethers.getAddress(address); + const balance = await provider.getBalance(addressChecksum); + const balanceTbnb = ethers.formatEther(balance); + + return { + content: [ + { + type: "text", + text: JSON.stringify( + { + address: addressChecksum, + balanceWei: balance.toString(), + balanceTbnb: parseFloat(balanceTbnb), + network: "BSC Testnet", + }, + null, + 2 + ), + }, + ], + }; + } catch (error) { + throw new Error(`Failed to get balance: ${error.message}`); + } +} + +// Start server +async function main() { + const transport = new StdioServerTransport(); + await server.connect(transport); + + console.error("TBNB Faucet MCP Server running on stdio"); +} + +main().catch((error) => { + console.error("Fatal error:", error); + process.exit(1); +}); diff --git a/typescript/faucet-mcp/index.test.js b/typescript/faucet-mcp/index.test.js new file mode 100644 index 0000000..9f47c94 --- /dev/null +++ b/typescript/faucet-mcp/index.test.js @@ -0,0 +1,277 @@ +/** + * Unit tests for TBNB Faucet MCP Server (Example 3 - Node.js) + * + * Note: These tests focus on the business logic and validation + * rather than full integration with the MCP server, since the server + * initializes on import and uses stdio transport. + */ + +import { describe, test, expect, beforeEach, jest } from '@jest/globals'; + +describe('Address Validation Logic', () => { + test('should validate correct Ethereum address format', () => { + const validAddress = '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb0'; + // Ethereum addresses are 42 characters (0x + 40 hex chars) + expect(validAddress.length).toBe(42); + expect(validAddress.startsWith('0x')).toBe(true); + expect(/^0x[a-fA-F0-9]{40}$/.test(validAddress)).toBe(true); + }); + + test('should reject invalid address formats', () => { + const invalidAddresses = [ + 'invalid', + '0x123', + '742d35Cc6634C0532925a3b844Bc9e7595f0bEb', // Missing 0x + '0xGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG', // Invalid hex + '', + ]; + + invalidAddresses.forEach((addr) => { + const isValid = addr.length === 42 && addr.startsWith('0x') && /^0x[a-fA-F0-9]{40}$/.test(addr); + expect(isValid).toBe(false); + }); + }); +}); + +describe('Amount Validation Logic', () => { + test('should accept valid amounts between 0 and 1.0', () => { + const validAmounts = [0.01, 0.1, 0.5, 1.0]; + + validAmounts.forEach((amount) => { + const isValid = amount > 0 && amount <= 1.0; + expect(isValid).toBe(true); + }); + }); + + test('should reject zero or negative amounts', () => { + const invalidAmounts = [0, -0.1, -1.0]; + + invalidAmounts.forEach((amount) => { + const isValid = amount > 0 && amount <= 1.0; + expect(isValid).toBe(false); + }); + }); + + test('should reject amounts greater than 1.0', () => { + const invalidAmounts = [1.1, 2.0, 10.0]; + + invalidAmounts.forEach((amount) => { + const isValid = amount > 0 && amount <= 1.0; + expect(isValid).toBe(false); + }); + }); +}); + +describe('Self-Transfer Prevention Logic', () => { + test('should detect self-transfer attempts', () => { + const faucetAddress = '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb'; + const recipient = '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb'; + + const isSelfTransfer = recipient.toLowerCase() === faucetAddress.toLowerCase(); + expect(isSelfTransfer).toBe(true); + }); + + test('should allow transfers to different addresses', () => { + const faucetAddress = '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb'; + const recipient = '0x1234567890123456789012345678901234567890'; + + const isSelfTransfer = recipient.toLowerCase() === faucetAddress.toLowerCase(); + expect(isSelfTransfer).toBe(false); + }); +}); + +describe('Wei Conversion Logic', () => { + test('should convert TBNB to Wei correctly', () => { + // 1 TBNB = 10^18 Wei + const tbnbAmounts = [ + { tbnb: 0.1, wei: '100000000000000000' }, + { tbnb: 1.0, wei: '1000000000000000000' }, + { tbnb: 0.01, wei: '10000000000000000' }, + ]; + + tbnbAmounts.forEach(({ tbnb, wei }) => { + // Manual conversion for testing + const calculatedWei = (tbnb * Math.pow(10, 18)).toString(); + expect(calculatedWei).toBe(wei); + }); + }); + + test('should handle Wei to TBNB conversion', () => { + const weiAmounts = [ + { wei: '100000000000000000', tbnb: 0.1 }, + { wei: '1000000000000000000', tbnb: 1.0 }, + { wei: '500000000000000000', tbnb: 0.5 }, + ]; + + weiAmounts.forEach(({ wei, tbnb }) => { + // Manual conversion for testing + const calculatedTbnb = parseFloat(wei) / Math.pow(10, 18); + expect(calculatedTbnb).toBeCloseTo(tbnb, 10); + }); + }); +}); + +describe('Transaction Response Format', () => { + test('should format successful transaction response correctly', () => { + const mockResponse = { + success: true, + transactionHash: '0xabcdef1234567890', + recipient: '0x1234567890123456789012345678901234567890', + amount: 0.1, + amountWei: '100000000000000000', + blockNumber: 12345, + status: 'confirmed', + }; + + expect(mockResponse).toHaveProperty('success'); + expect(mockResponse).toHaveProperty('transactionHash'); + expect(mockResponse).toHaveProperty('recipient'); + expect(mockResponse).toHaveProperty('amount'); + expect(mockResponse).toHaveProperty('blockNumber'); + expect(mockResponse).toHaveProperty('status'); + expect(mockResponse.success).toBe(true); + expect(mockResponse.status).toBe('confirmed'); + }); + + test('should format error response correctly', () => { + const mockErrorResponse = { + error: 'Invalid address: invalid_address', + }; + + expect(mockErrorResponse).toHaveProperty('error'); + expect(typeof mockErrorResponse.error).toBe('string'); + }); +}); + +describe('Faucet Info Response Format', () => { + test('should format faucet info response correctly', () => { + const mockFaucetInfo = { + faucetAddress: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb', + balanceWei: '1000000000000000000', + balanceTbnb: 1.0, + network: { + name: 'BSC Testnet', + chainId: '97', + }, + rpcEndpoint: 'https://data-seed-prebsc-1-s1.binance.org:8545/', + }; + + expect(mockFaucetInfo).toHaveProperty('faucetAddress'); + expect(mockFaucetInfo).toHaveProperty('balanceWei'); + expect(mockFaucetInfo).toHaveProperty('balanceTbnb'); + expect(mockFaucetInfo).toHaveProperty('network'); + expect(mockFaucetInfo).toHaveProperty('rpcEndpoint'); + expect(mockFaucetInfo.network.chainId).toBe('97'); + }); +}); + +describe('Balance Query Response Format', () => { + test('should format balance query response correctly', () => { + const mockBalanceResponse = { + address: '0x1234567890123456789012345678901234567890', + balanceWei: '500000000000000000', + balanceTbnb: 0.5, + network: 'BSC Testnet', + }; + + expect(mockBalanceResponse).toHaveProperty('address'); + expect(mockBalanceResponse).toHaveProperty('balanceWei'); + expect(mockBalanceResponse).toHaveProperty('balanceTbnb'); + expect(mockBalanceResponse).toHaveProperty('network'); + expect(mockBalanceResponse.balanceTbnb).toBe(0.5); + }); +}); + +describe('Error Handling', () => { + test('should handle missing recipient address', () => { + const recipient = ''; + if (!recipient) { + expect(() => { + throw new Error('Recipient address is required'); + }).toThrow('Recipient address is required'); + } + }); + + test('should handle missing wallet configuration', () => { + const wallet = null; + if (!wallet) { + expect(() => { + throw new Error('Faucet wallet not configured. Please set FAUCET_PRIVATE_KEY.'); + }).toThrow('Faucet wallet not configured'); + } + }); + + test('should handle network errors gracefully', () => { + const networkError = new Error('Network error'); + expect(networkError.message).toBe('Network error'); + expect(networkError).toBeInstanceOf(Error); + }); +}); + +describe('MCP Tool Schema Validation', () => { + test('send_tbnb tool should have correct schema structure', () => { + const toolSchema = { + name: 'send_tbnb', + description: 'Send testnet BNB tokens to a specified address on BSC testnet', + inputSchema: { + type: 'object', + properties: { + recipient: { + type: 'string', + description: 'The BSC testnet address that will receive the TBNB tokens', + }, + amount: { + type: 'number', + description: 'Amount of TBNB to send (default: 0.1, maximum: 1.0)', + default: 0.1, + }, + }, + required: ['recipient'], + }, + }; + + expect(toolSchema).toHaveProperty('name'); + expect(toolSchema).toHaveProperty('description'); + expect(toolSchema).toHaveProperty('inputSchema'); + expect(toolSchema.inputSchema.type).toBe('object'); + expect(toolSchema.inputSchema.required).toContain('recipient'); + }); + + test('get_faucet_info tool should have correct schema structure', () => { + const toolSchema = { + name: 'get_faucet_info', + description: 'Get information about the faucet including current balance', + inputSchema: { + type: 'object', + properties: {}, + }, + }; + + expect(toolSchema).toHaveProperty('name'); + expect(toolSchema).toHaveProperty('description'); + expect(toolSchema).toHaveProperty('inputSchema'); + expect(toolSchema.inputSchema.type).toBe('object'); + }); + + test('get_balance tool should have correct schema structure', () => { + const toolSchema = { + name: 'get_balance', + description: 'Get the TBNB balance of a BSC testnet address', + inputSchema: { + type: 'object', + properties: { + address: { + type: 'string', + description: 'The BSC testnet address to check', + }, + }, + required: ['address'], + }, + }; + + expect(toolSchema).toHaveProperty('name'); + expect(toolSchema).toHaveProperty('description'); + expect(toolSchema).toHaveProperty('inputSchema'); + expect(toolSchema.inputSchema.required).toContain('address'); + }); +}); diff --git a/typescript/faucet-mcp/package.json b/typescript/faucet-mcp/package.json new file mode 100644 index 0000000..8e7ca75 --- /dev/null +++ b/typescript/faucet-mcp/package.json @@ -0,0 +1,41 @@ +{ + "name": "tbnb-faucet-mcp", + "version": "1.0.0", + "description": "MCP server for distributing testnet BNB tokens on BSC testnet", + "type": "module", + "main": "index.js", + "scripts": { + "start": "node index.js", + "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js", + "test:watch": "node --experimental-vm-modules node_modules/jest/bin/jest.js --watch", + "test:coverage": "node --experimental-vm-modules node_modules/jest/bin/jest.js --coverage" + }, + "keywords": [ + "mcp", + "model-context-protocol", + "bnb", + "testnet", + "faucet", + "blockchain" + ], + "author": "", + "license": "MIT", + "dependencies": { + "@modelcontextprotocol/sdk": "^0.5.0", + "ethers": "^6.9.0" + }, + "devDependencies": { + "@jest/globals": "^29.7.0", + "jest": "^29.7.0" + }, + "engines": { + "node": ">=18.0.0" + }, + "jest": { + "testEnvironment": "node", + "transform": {}, + "moduleNameMapper": { + "^(\\.{1,2}/.*)\\.js$": "$1" + } + } +} From 32fb4885a6c54950589a123c7d8abf1e5dcf2fa8 Mon Sep 17 00:00:00 2001 From: 1evi7eo Date: Sat, 24 Jan 2026 23:23:44 +0800 Subject: [PATCH 2/2] completed tx explainer --- typescript/explain-this-tx-example/README.md | 138 + .../explain-this-tx-example/app.test.ts | 57 + typescript/explain-this-tx-example/app.ts | 268 + .../explain-this-tx-example/clone-and-run.sh | 43 + .../explain-this-tx-example.png | Bin 0 -> 356728 bytes .../explain-this-tx-example/frontend.ts | 420 ++ typescript/explain-this-tx-example/index.html | 18 + .../explain-this-tx-example/package-lock.json | 4447 +++++++++++++++++ .../explain-this-tx-example/package.json | 31 + typescript/explain-this-tx-example/server.ts | 124 + .../explain-this-tx-example/tsconfig.json | 19 + .../explain-this-tx-example/vite.config.ts | 14 + .../explain-this-tx-example/vitest.config.ts | 9 + 13 files changed, 5588 insertions(+) create mode 100644 typescript/explain-this-tx-example/README.md create mode 100644 typescript/explain-this-tx-example/app.test.ts create mode 100644 typescript/explain-this-tx-example/app.ts create mode 100644 typescript/explain-this-tx-example/clone-and-run.sh create mode 100644 typescript/explain-this-tx-example/explain-this-tx-example.png create mode 100644 typescript/explain-this-tx-example/frontend.ts create mode 100644 typescript/explain-this-tx-example/index.html create mode 100644 typescript/explain-this-tx-example/package-lock.json create mode 100644 typescript/explain-this-tx-example/package.json create mode 100644 typescript/explain-this-tx-example/server.ts create mode 100644 typescript/explain-this-tx-example/tsconfig.json create mode 100644 typescript/explain-this-tx-example/vite.config.ts create mode 100644 typescript/explain-this-tx-example/vitest.config.ts diff --git a/typescript/explain-this-tx-example/README.md b/typescript/explain-this-tx-example/README.md new file mode 100644 index 0000000..5d6eded --- /dev/null +++ b/typescript/explain-this-tx-example/README.md @@ -0,0 +1,138 @@ +# Transaction Explainer + +A small BNB Smart Chain (BSC) demo that fetches and explains what any transaction does. Enter a transaction hash to get a human-readable explanation of the transaction's purpose, decode contract function calls, and view key transaction details. + +![Screenshot](./explain-this-tx-example.png) + +--- + +## What it does + +- **Fetches** transaction data from BSC using JSON-RPC (via backend `/api/explain`) +- **Decodes** contract function calls (transfer, approve, swap, etc.) +- **Explains** what the transaction does in plain English (default rule-based) +- **Optional LLM** — Set `OPENAI_API_KEY` in `.env` to enhance explanations with OpenAI; otherwise uses the default rule-based explanation +- **Displays** key details: sender, receiver, value, gas, status, and more + +This tool helps you understand blockchain transactions without needing to manually decode hex data or read contract ABIs. + +--- + +## Tech stack + +- **TypeScript** — App logic and tests +- **Express** — Backend server, serves SPA and `/api/explain` +- **ethers v6** — RPC client and transaction parsing +- **Vite** — Build tool and dev server +- **Vitest** — Unit testing +- **OpenAI** (optional) — LLM-enhanced explanations when `OPENAI_API_KEY` is set + +--- + +## Quick start + +### Option 1: Clone and run script (recommended) + +```bash +git clone +cd explain-this-tx-example +chmod +x clone-and-run.sh +./clone-and-run.sh +``` + +The script installs dependencies, creates `.env` from `.env.example`, runs tests, builds, and starts the server. Open **http://localhost:3000** (or the `PORT` in `.env`). + +### Option 2: Manual setup + +```bash +cd explain-this-tx-example +cp .env.example .env +# Optional: set OPENAI_API_KEY for LLM-enhanced explanations +# Optional: set BSC_RPC_URL, PORT +npm install +npm run build +npm test +npm start +``` + +Then open **http://localhost:3000** (or your `PORT`). Use `npm run dev` for Vite-only frontend dev (no `/api`; run `npm run server` separately for the API). + +--- + +## Environment variables + +| Variable | Default | Description | +|----------|---------|-------------| +| `VITE_BSC_RPC_URL` | `https://bsc-dataseed.bnbchain.org` | BSC JSON-RPC endpoint (frontend / legacy) | +| `BSC_RPC_URL` | same as above | BSC JSON-RPC endpoint used by backend | +| `PORT` | `3000` | HTTP server port | +| `OPENAI_API_KEY` | — | **Optional.** Set to enable LLM-enhanced explanations (OpenAI). Otherwise uses default rule-based explanation. | + +--- + +## Scripts + +| Command | Description | +|---------|-------------| +| `npm start` | Build SPA and run Express server (serves `dist/` + `/api/explain`) | +| `npm run server` | Run Express server only (assumes `dist/` exists) | +| `npm run dev` | Vite dev server (frontend only; no `/api` unless server runs separately) | +| `npm run build` | Production build | +| `npm run preview` | Vite preview of `dist/` | +| `npm test` | Run Vitest unit tests | + +--- + +## Project layout + +``` +explain-this-tx-example/ +├── clone-and-run.sh +├── package.json +├── README.md +├── index.html # Entry page +├── server.ts # Express server: serves SPA, /api/explain, optional OpenAI +├── src/ +│ ├── app.ts # Transaction fetching and explanation logic +│ └── frontend.ts # UI (dark theme, info + interaction panes) +├── tests/ +│ └── app.test.ts # Unit tests +└── tsconfig.json +``` + +--- + +## How it works + +1. **Input validation** — Validates the transaction hash format (0x + 64 hex chars) +2. **API call** — Frontend POSTs to `/api/explain` with the tx hash; backend fetches and explains +3. **RPC fetch** — Backend uses `eth_getTransaction` and `eth_getTransactionReceipt` to fetch transaction data +4. **Decoding** — Attempts to decode contract function calls using common function selectors +5. **Explanation** — Builds a human-readable explanation (rule-based). If `OPENAI_API_KEY` is set, optionally enhances with OpenAI (LLM). Covers: + - Simple BNB transfers + - Contract function calls (with decoded function names and parameters) + - Contract creation + - Token operations (transfer, approve, etc.) +6. **Display** — Shows explanation, transaction details, and a link to BSCTrace + +--- + +## Supported function types + +The tool recognizes common ERC-20 and DEX functions: +- `transfer(address,uint256)` +- `transferFrom(address,address,uint256)` +- `approve(address,uint256)` +- `mint(address,uint256)` +- `burn(uint256)` +- `swapExactETHForTokens(...)` +- `swapExactTokensForTokens(...)` +- And more... + +For unknown functions, it shows the function selector and raw data. + +--- + +## License + +MIT. diff --git a/typescript/explain-this-tx-example/app.test.ts b/typescript/explain-this-tx-example/app.test.ts new file mode 100644 index 0000000..aa9b80d --- /dev/null +++ b/typescript/explain-this-tx-example/app.test.ts @@ -0,0 +1,57 @@ +import { describe, it, expect, vi, beforeEach } from "vitest"; +import { + isValidTxHash, + getExplorerUrl, + BSC_CHAIN_ID, +} from "./app.js"; + +describe("isValidTxHash", () => { + it("accepts valid transaction hash", () => { + expect(isValidTxHash("0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef")).toBe(true); + expect(isValidTxHash("0x0000000000000000000000000000000000000000000000000000000000000000")).toBe(true); + }); + + it("rejects invalid formats", () => { + expect(isValidTxHash("")).toBe(false); + expect(isValidTxHash("0x")).toBe(false); + expect(isValidTxHash("0x123")).toBe(false); + expect(isValidTxHash("1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef")).toBe(false); + expect(isValidTxHash("0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcde")).toBe(false); + expect(isValidTxHash("0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdefg")).toBe(false); + }); +}); + +describe("getExplorerUrl", () => { + it("returns BSC mainnet explorer URL for chain ID 56", () => { + const hash = "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"; + const url = getExplorerUrl(hash, 56); + expect(url).toBe(`https://bsctrace.com/tx/${hash}`); + }); + + it("returns testnet explorer URL for chain ID 97", () => { + const hash = "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"; + const url = getExplorerUrl(hash, 97); + expect(url).toBe(`https://testnet.bsctrace.com/tx/${hash}`); + }); + + it("defaults to mainnet if chain ID not specified", () => { + const hash = "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"; + const url = getExplorerUrl(hash); + expect(url).toBe(`https://bsctrace.com/tx/${hash}`); + }); +}); + +describe("BSC_CHAIN_ID", () => { + it("is 56 for BNB Smart Chain mainnet", () => { + expect(BSC_CHAIN_ID).toBe(56); + }); +}); + +// Note: fetchTransaction tests would require mocking the RPC provider +// For a complete test suite, you would mock JsonRpcProvider and test: +// - Successful transaction fetch +// - Contract creation detection +// - Contract call decoding +// - Function argument parsing +// - Error handling for invalid hashes +// - Error handling for non-existent transactions diff --git a/typescript/explain-this-tx-example/app.ts b/typescript/explain-this-tx-example/app.ts new file mode 100644 index 0000000..860c172 --- /dev/null +++ b/typescript/explain-this-tx-example/app.ts @@ -0,0 +1,268 @@ +/** + * Transaction Explanation Tool — core logic for BNB Smart Chain (BSC). + * Fetches and explains what any BSC transaction does. + */ + +import { JsonRpcProvider, formatEther, formatUnits, isAddress, parseTransaction } from "ethers"; + +/** BSC mainnet chain ID. */ +export const BSC_CHAIN_ID = 56; + +/** Transaction explanation result. */ +export interface TxExplanation { + hash: string; + blockNumber: number | null; + from: string; + to: string | null; + value: string; // in BNB + gasUsed: bigint | null; + gasPrice: string; // in Gwei + status: "success" | "failed" | "pending" | "unknown"; + isContractCreation: boolean; + isContractCall: boolean; + functionName: string | null; + functionArgs: Record | null; + explanation: string; + rawData: string; +} + +/** + * Fetches a transaction by hash from BSC. + */ +export async function fetchTransaction( + txHash: string, + rpcUrl: string +): Promise { + if (!txHash.match(/^0x[a-fA-F0-9]{64}$/)) { + throw new Error("Invalid transaction hash format"); + } + + const provider = new JsonRpcProvider(rpcUrl); + + // Fetch transaction receipt and transaction data + const [receipt, tx] = await Promise.all([ + provider.getTransactionReceipt(txHash).catch(() => null), + provider.getTransaction(txHash), + ]); + + if (!tx) { + throw new Error("Transaction not found"); + } + + const value = formatEther(tx.value); + const gasPrice = receipt?.gasPrice + ? formatUnits(receipt.gasPrice, "gwei") + : tx.gasPrice + ? formatUnits(tx.gasPrice, "gwei") + : "0"; + + const isContractCreation = !tx.to; + const isContractCall = tx.to && tx.data && tx.data !== "0x" && tx.data.length > 2; + + let functionName: string | null = null; + let functionArgs: Record | null = null; + let explanation = ""; + + // Parse contract call + if (isContractCall && tx.data) { + const decoded = decodeFunctionCall(tx.data); + functionName = decoded.name; + functionArgs = decoded.args; + } + + // Build explanation + if (isContractCreation) { + explanation = `This transaction creates a new smart contract on BSC.`; + if (value !== "0.0") { + explanation += ` It also sends ${value} BNB to the contract constructor.`; + } + } else if (isContractCall && functionName) { + explanation = `This transaction calls the function "${functionName}" on the contract at ${tx.to}.`; + if (functionArgs && Object.keys(functionArgs).length > 0) { + explanation += ` Parameters: ${formatArgs(functionArgs)}.`; + } + if (value !== "0.0") { + explanation += ` It also sends ${value} BNB along with the call.`; + } + } else if (isContractCall) { + explanation = `This transaction calls an unknown function on the contract at ${tx.to}.`; + if (value !== "0.0") { + explanation += ` It sends ${value} BNB along with the call.`; + } + } else if (value !== "0.0") { + explanation = `This is a simple BNB transfer of ${value} BNB from ${tx.from} to ${tx.to}.`; + } else { + explanation = `This transaction sends 0 BNB from ${tx.from} to ${tx.to}. It may be a failed transaction or a data-only transaction.`; + } + + // Add status info + if (receipt) { + if (receipt.status === 1) { + explanation += ` The transaction succeeded.`; + } else if (receipt.status === 0) { + explanation += ` The transaction failed (reverted).`; + } + if (receipt.gasUsed) { + explanation += ` Gas used: ${receipt.gasUsed.toString()}.`; + } + } else { + explanation += ` Transaction status is pending or unknown.`; + } + + return { + hash: txHash, + blockNumber: receipt?.blockNumber ?? null, + from: tx.from, + to: tx.to ?? null, + value, + gasUsed: receipt?.gasUsed ?? null, + gasPrice, + status: receipt + ? receipt.status === 1 + ? "success" + : receipt.status === 0 + ? "failed" + : "unknown" + : "pending", + isContractCreation, + isContractCall, + functionName, + functionArgs, + explanation, + rawData: tx.data || "0x", + }; +} + +/** + * Attempts to decode a function call from transaction data. + * Returns function name and arguments if decodable, otherwise null. + */ +function decodeFunctionCall(data: string): { name: string; args: Record } { + // Extract function selector (first 4 bytes) + if (data.length < 10) { + return { name: "unknown", args: {} }; + } + + const selector = data.slice(0, 10); + + // Common function selectors (first 4 bytes of keccak256 hash of function signature) + const commonSelectors: Record = { + "0xa9059cbb": "transfer(address,uint256)", + "0x23b872dd": "transferFrom(address,address,uint256)", + "0x095ea7b3": "approve(address,uint256)", + "0x40c10f19": "mint(address,uint256)", + "0x42966c68": "burn(uint256)", + "0x70a08231": "balanceOf(address)", + "0x18160ddd": "totalSupply()", + "0x06fdde03": "name()", + "0x95d89b41": "symbol()", + "0x313ce567": "decimals()", + "0x7ff36ab5": "swapExactETHForTokens(uint256,address[],address,uint256)", + "0x38ed1739": "swapExactTokensForTokens(uint256,uint256,address[],address,uint256)", + "0x02751cec": "removeLiquidity(address,address,uint256,uint256,uint256,address,uint256)", + "0xbaa2abde": "addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)", + }; + + const functionSig = commonSelectors[selector.toLowerCase()]; + if (functionSig) { + return { + name: functionSig.split("(")[0], + args: parseCommonFunctionArgs(selector, data), + }; + } + + return { name: `0x${selector.slice(2)}`, args: {} }; +} + +/** + * Parses common function arguments from transaction data. + */ +function parseCommonFunctionArgs(selector: string, data: string): Record { + const args: Record = {}; + + // Remove selector and parse remaining data + const params = data.slice(10); + if (params.length === 0) return args; + + // Each parameter is 64 hex chars (32 bytes) + const paramSize = 64; + const paramsList: string[] = []; + + for (let i = 0; i < params.length; i += paramSize) { + paramsList.push("0x" + params.slice(i, i + paramSize)); + } + + switch (selector.toLowerCase()) { + case "0xa9059cbb": // transfer(address,uint256) + if (paramsList.length >= 2) { + args.to = paramsList[0]; + args.amount = paramsList[1]; + } + break; + case "0x23b872dd": // transferFrom(address,address,uint256) + if (paramsList.length >= 3) { + args.from = paramsList[0]; + args.to = paramsList[1]; + args.amount = paramsList[2]; + } + break; + case "0x095ea7b3": // approve(address,uint256) + if (paramsList.length >= 2) { + args.spender = paramsList[0]; + args.amount = paramsList[1]; + } + break; + case "0x40c10f19": // mint(address,uint256) + if (paramsList.length >= 2) { + args.to = paramsList[0]; + args.amount = paramsList[1]; + } + break; + case "0x42966c68": // burn(uint256) + if (paramsList.length >= 1) { + args.amount = paramsList[0]; + } + break; + } + + return args; +} + +/** + * Formats function arguments for display. + */ +function formatArgs(args: Record): string { + const parts: string[] = []; + for (const [key, value] of Object.entries(args)) { + if (typeof value === "string" && value.startsWith("0x")) { + // Try to format as address + if (value.length === 66) { + parts.push(`${key}: ${value.slice(0, 10)}...${value.slice(-8)}`); + } else { + parts.push(`${key}: ${value}`); + } + } else { + parts.push(`${key}: ${value}`); + } + } + return parts.join(", "); +} + +/** + * Validates a transaction hash format. + */ +export function isValidTxHash(hash: string): boolean { + return /^0x[a-fA-F0-9]{64}$/.test(hash); +} + +/** + * Gets a BSC explorer URL for a transaction (BSCTrace API / explorer). + */ +export function getExplorerUrl(txHash: string, chainId: number = BSC_CHAIN_ID): string { + if (chainId === 56) { + return `https://bsctrace.com/tx/${txHash}`; + } else if (chainId === 97) { + return `https://testnet.bsctrace.com/tx/${txHash}`; + } + return `https://bsctrace.com/tx/${txHash}`; +} diff --git a/typescript/explain-this-tx-example/clone-and-run.sh b/typescript/explain-this-tx-example/clone-and-run.sh new file mode 100644 index 0000000..01a747a --- /dev/null +++ b/typescript/explain-this-tx-example/clone-and-run.sh @@ -0,0 +1,43 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Transaction Explainer — clone-and-run script. +# Run from repo root or from this project directory. +# Pre-seeds .env for a hassle-free evaluator run. + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +cd "$SCRIPT_DIR" + +echo "[1/5] Ensuring .env..." +if [[ ! -f .env ]]; then + if [[ -f .env.example ]]; then + cp .env.example .env + echo " Created .env from .env.example" + else + { + echo "VITE_BSC_RPC_URL=https://bsc-dataseed.bnbchain.org" + echo "BSC_RPC_URL=https://bsc-dataseed.bnbchain.org" + echo "PORT=3000" + } > .env + echo " Created .env with default BSC RPC and PORT" + fi +else + echo " .env already exists" +fi + +echo "[2/5] Installing dependencies..." +npm install + +echo "[3/5] Running unit tests..." +npm test + +echo "[4/5] Building..." +npm run build + +echo "[5/5] Starting server..." +set -a +# shellcheck disable=SC1091 +source .env 2>/dev/null || true +set +a +echo " Open http://localhost:${PORT:-3000} — use Ctrl+C to stop." +npm run server diff --git a/typescript/explain-this-tx-example/explain-this-tx-example.png b/typescript/explain-this-tx-example/explain-this-tx-example.png new file mode 100644 index 0000000000000000000000000000000000000000..ae69a590c5af384fe4a20e83887e0c9e56626c06 GIT binary patch literal 356728 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

f9b(@t|At7R-4TR!I3(vkcjB$>V$Ou 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%0D00q|0{rP%7r=!l4Cd$3u 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

%NImtFMeFnyWZw&^9G^ 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 literal 0 HcmV?d00001 diff --git a/typescript/explain-this-tx-example/frontend.ts b/typescript/explain-this-tx-example/frontend.ts new file mode 100644 index 0000000..513dcbc --- /dev/null +++ b/typescript/explain-this-tx-example/frontend.ts @@ -0,0 +1,420 @@ +/** + * Transaction Explanation Tool — UI. + * Dark-mode layout: left info pane, right interaction pane. + */ + +import { isValidTxHash, getExplorerUrl, type TxExplanation } from "./app.js"; + +const ROOT_ID = "root"; +const API_BASE = import.meta.env.VITE_API_BASE ?? ""; + +function injectStyles(): void { + const css = ` + :root { + --bg: #0d0f14; + --surface: #161a22; + --surface-hover: #1c212c; + --border: #2a3142; + --muted: #6b7280; + --text: #e2e8f0; + --accent: #f59e0b; + --accent-dim: #b45309; + --success: #22c55e; + --error: #ef4444; + --warning: #f59e0b; + --mono: "JetBrains Mono", ui-monospace, monospace; + --sans: "Outfit", system-ui, sans-serif; + } + * { box-sizing: border-box; margin: 0; padding: 0; } + html, body { height: 100%; } + body { + font-family: var(--sans); + background: var(--bg); + color: var(--text); + line-height: 1.5; + -webkit-font-smoothing: antialiased; + } + #${ROOT_ID} { + display: grid; + grid-template-columns: 360px 1fr; + min-height: 100vh; + } + @media (max-width: 900px) { + #${ROOT_ID} { grid-template-columns: 1fr; } + } + .info-pane { + background: var(--surface); + border-right: 1px solid var(--border); + padding: 1.5rem 1.25rem; + overflow-y: auto; + } + .info-pane h1 { + font-size: 1.1rem; + font-weight: 600; + margin-bottom: 0.5rem; + color: var(--accent); + } + .info-pane h2 { + font-size: 0.9rem; + font-weight: 500; + margin-top: 1.25rem; + margin-bottom: 0.4rem; + color: var(--text); + } + .info-pane p, .info-pane li { + font-size: 0.85rem; + color: var(--muted); + margin-bottom: 0.5rem; + } + .info-pane ul { padding-left: 1rem; margin-bottom: 0.5rem; } + .info-pane code { + font-family: var(--mono); + font-size: 0.8rem; + background: var(--bg); + padding: 0.15rem 0.35rem; + border-radius: 4px; + color: var(--accent); + } + .interaction-pane { + padding: 1.5rem 2rem; + overflow-y: auto; + } + .interaction-pane h2 { + font-size: 1rem; + font-weight: 600; + margin-bottom: 1rem; + color: var(--text); + } + .card { + background: var(--surface); + border: 1px solid var(--border); + border-radius: 10px; + padding: 1.25rem; + margin-bottom: 1rem; + } + .card h3 { + font-size: 0.9rem; + font-weight: 500; + margin-bottom: 0.75rem; + color: var(--muted); + text-transform: uppercase; + letter-spacing: 0.05em; + } + .input-group { + margin-bottom: 1rem; + } + .input-group label { + display: block; + font-size: 0.85rem; + color: var(--muted); + margin-bottom: 0.5rem; + } + .input-group input { + width: 100%; + font-family: var(--mono); + font-size: 0.85rem; + padding: 0.75rem; + background: var(--bg); + border: 1px solid var(--border); + border-radius: 8px; + color: var(--text); + transition: border-color 0.15s; + } + .input-group input:focus { + outline: none; + border-color: var(--accent); + } + .input-group input::placeholder { + color: var(--muted); + } + .btn { + display: inline-flex; + align-items: center; + gap: 0.5rem; + font-family: var(--sans); + font-size: 0.9rem; + font-weight: 500; + padding: 0.6rem 1.1rem; + border: none; + border-radius: 8px; + cursor: pointer; + transition: background 0.15s, transform 0.1s; + } + .btn:active { transform: scale(0.98); } + .btn-primary { + background: var(--accent); + color: var(--bg); + } + .btn-primary:hover { background: var(--accent-dim); filter: brightness(1.1); } + .btn:disabled { opacity: 0.5; cursor: not-allowed; } + .explanation-box { + font-size: 0.9rem; + line-height: 1.6; + background: var(--bg); + padding: 1rem; + border-radius: 8px; + margin-top: 0.75rem; + color: var(--text); + border-left: 3px solid var(--accent); + } + .details-grid { + display: grid; + grid-template-columns: auto 1fr; + gap: 0.5rem 1rem; + font-size: 0.85rem; + margin-top: 0.75rem; + } + .details-grid dt { + color: var(--muted); + font-weight: 500; + } + .details-grid dd { + color: var(--text); + font-family: var(--mono); + word-break: break-all; + } + .status-badge { + display: inline-block; + font-size: 0.75rem; + padding: 0.25rem 0.6rem; + border-radius: 4px; + font-weight: 500; + text-transform: uppercase; + letter-spacing: 0.05em; + } + .status-success { background: rgba(34, 197, 94, 0.2); color: var(--success); } + .status-failed { background: rgba(239, 68, 68, 0.2); color: var(--error); } + .status-pending { background: rgba(245, 158, 11, 0.2); color: var(--warning); } + .status-unknown { background: rgba(107, 114, 128, 0.2); color: var(--muted); } + .err { + color: var(--error); + font-size: 0.85rem; + margin-top: 0.5rem; + padding: 0.75rem; + background: rgba(239, 68, 68, 0.1); + border-radius: 6px; + border-left: 3px solid var(--error); + } + .loading { + color: var(--muted); + font-size: 0.85rem; + margin-top: 0.5rem; + } + .link { + color: var(--accent); + text-decoration: none; + font-size: 0.85rem; + } + .link:hover { text-decoration: underline; } + .mb-1 { margin-bottom: 1rem; } + `; + const el = document.createElement("style"); + el.textContent = css; + document.head.appendChild(el); +} + +function renderInfoPane(): string { + return ` +
+

Transaction Explainer

+

This tool helps you understand what any transaction on BNB Smart Chain (BSC) does by fetching and decoding its details.

+ +

What it does

+

Enter a transaction hash (tx hash) from BSC, and the tool will:

+
    +
  • Fetch the transaction data from the blockchain
    • +
  • Decode contract function calls (if applicable)
    • +
  • Explain what the transaction does in plain English
    • +
  • Show key details like sender, receiver, value, gas, and status
    • +
+ +

Transaction types

+

The tool can explain:

+
    +
  • BNB transfers — Simple value transfers
    • +
  • Contract calls — Function calls on smart contracts
    • +
  • Contract creation — New contract deployments
    • +
  • Token operations — Common ERC-20 functions like transfer, approve, etc.
    • +
+ +

How to use

+

Paste a transaction hash (0x followed by 64 hex characters) into the input field and click "Explain Transaction". The tool will fetch and decode the transaction details.

+ +

Example

+

Try a recent transaction hash from BSCTrace to see how it works.

+ +

LLM (optional)

+

Set OPENAI_API_KEY in .env to enable LLM-enhanced explanations via OpenAI. Otherwise, the app uses default rule-based explanations.

+
+ `; +} + +function renderInteractionPane(): string { + return ` +
+

Explain Transaction

+
+

Transaction Hash

+
+ + +
+ + + +
+ +
+ `; +} + +function render(): void { + const root = document.getElementById(ROOT_ID); + if (!root) return; + injectStyles(); + root.innerHTML = renderInfoPane() + renderInteractionPane(); +} + +function output(key: string, html: string, show = true): void { + const el = document.querySelector(`[data-output="${key}"]`); + if (!el) return; + el.innerHTML = html; + (el as HTMLElement).style.display = show ? "block" : "none"; +} + +/** Toggle result card visibility only (do not overwrite innerHTML). */ +function setResultVisible(show: boolean): void { + const el = document.querySelector(`[data-output="result"]`); + if (!el) return; + (el as HTMLElement).style.display = show ? "block" : "none"; +} + +function getInput(): HTMLInputElement | null { + return document.querySelector("#txHash"); +} + +function getButton(action: string): HTMLButtonElement | null { + return document.querySelector(`[data-action="${action}"]`); +} + +function formatAddress(addr: string | null): string { + if (!addr) return "—"; + return `${addr.slice(0, 6)}…${addr.slice(-4)}`; +} + +function formatValue(value: string): string { + const num = parseFloat(value); + if (num === 0) return "0 BNB"; + if (num < 0.0001) return `${value} BNB`; + return `${parseFloat(value).toFixed(6)} BNB`; +} + +function renderDetails(explanation: TxExplanation): string { + const statusClass = `status-${explanation.status}`; + const statusLabel = explanation.status.charAt(0).toUpperCase() + explanation.status.slice(1); + + return ` +
Status
+
${statusLabel}
+
Hash
+
${explanation.hash}
+
Block
+
${explanation.blockNumber ?? "Pending"}
+
From
+
${explanation.from}
+
To
+
${explanation.to ?? "Contract Creation"}
+
Value
+
${formatValue(explanation.value)}
+
Gas Price
+
${explanation.gasPrice} Gwei
+
Gas Used
+
${explanation.gasUsed?.toString() ?? "—"}
+
Type
+
${explanation.isContractCreation ? "Contract Creation" : explanation.isContractCall ? "Contract Call" : "Transfer"}
+ ${explanation.functionName ? `
Function
${explanation.functionName}
` : ""} + `; +} + +async function onExplain(): Promise { + const btn = getButton("explain"); + const input = getInput(); + if (!btn || !input) return; + + const txHash = input.value.trim(); + + if (!txHash) { + output("error", "Please enter a transaction hash"); + return; + } + + if (!isValidTxHash(txHash)) { + output("error", "Invalid transaction hash format. Must be 0x followed by 64 hex characters."); + return; + } + + btn.disabled = true; + output("error", "", false); + setResultVisible(false); + output("loading", "Fetching transaction data...", true); + + try { + const res = await fetch(`${API_BASE}/api/explain`, { + method: "POST", + headers: { "Content-Type": "application/json" }, + body: JSON.stringify({ txHash }), + }); + const data = await res.json(); + + if (!res.ok) { + throw new Error(data?.error ?? `Request failed: ${res.status}`); + } + + const explanation = data as TxExplanation; + output("loading", "", false); + output("explanation", explanation.explanation); + output("details", renderDetails(explanation)); + + const explorerLink = document.querySelector(`[data-output="explorer-link"]`); + if (explorerLink) { + (explorerLink as HTMLAnchorElement).href = + (data as { explorerUrl?: string }).explorerUrl ?? getExplorerUrl(txHash); + } + + setResultVisible(true); + } catch (e) { + output("loading", "", false); + output("error", e instanceof Error ? e.message : "Failed to fetch transaction"); + } finally { + btn.disabled = false; + } +} + +function bind(): void { + getButton("explain")?.addEventListener("click", onExplain); + getInput()?.addEventListener("keypress", (e) => { + if (e.key === "Enter") { + onExplain(); + } + }); +} + +function init(): void { + render(); + bind(); +} + +init(); diff --git a/typescript/explain-this-tx-example/index.html b/typescript/explain-this-tx-example/index.html new file mode 100644 index 0000000..25e18d0 --- /dev/null +++ b/typescript/explain-this-tx-example/index.html @@ -0,0 +1,18 @@ + + + + + + Transaction Explainer — BNB Cookbook + + + + + +
+ + + diff --git a/typescript/explain-this-tx-example/package-lock.json b/typescript/explain-this-tx-example/package-lock.json new file mode 100644 index 0000000..a0b4a90 --- /dev/null +++ b/typescript/explain-this-tx-example/package-lock.json @@ -0,0 +1,4447 @@ +{ + "name": "explain-this-tx-example", + "version": "1.0.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "explain-this-tx-example", + "version": "1.0.0", + "dependencies": { + "dotenv": "^16.4.5", + "ethers": "^6.13.0", + "express": "^4.21.0", + "openai": "^4.73.0" + }, + "devDependencies": { + "@types/express": "^4.17.21", + "@types/node": "^22.9.0", + "tsx": "^4.19.2", + "typescript": "^5.6.3", + "vite": "^6.0.0", + "vitest": "^2.1.4" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/@adraffy/ens-normalize": { + "version": "1.10.1", + "resolved": "https://registry.npmjs.org/@adraffy/ens-normalize/-/ens-normalize-1.10.1.tgz", + "integrity": "sha512-96Z2IP3mYmF1Xg2cDm8f1gWGf/HUVedQ3FMifV4kG/PQ4yEP51xDtRAEfhVNt5f/uzpNkZHwWQuUcu6D6K+Ekw==", + "license": "MIT" + }, + "node_modules/@esbuild/aix-ppc64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.12.tgz", + "integrity": "sha512-Hhmwd6CInZ3dwpuGTF8fJG6yoWmsToE+vYgD4nytZVxcu1ulHpUQRAB1UJ8+N1Am3Mz4+xOByoQoSZf4D+CpkA==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "aix" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.12.tgz", + "integrity": "sha512-VJ+sKvNA/GE7Ccacc9Cha7bpS8nyzVv0jdVgwNDaR4gDMC/2TTRc33Ip8qrNYUcpkOHUT5OZ0bUcNNVZQ9RLlg==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.12.tgz", + "integrity": "sha512-6AAmLG7zwD1Z159jCKPvAxZd4y/VTO0VkprYy+3N2FtJ8+BQWFXU+OxARIwA46c5tdD9SsKGZ/1ocqBS/gAKHg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.12.tgz", + "integrity": "sha512-5jbb+2hhDHx5phYR2By8GTWEzn6I9UqR11Kwf22iKbNpYrsmRB18aX/9ivc5cabcUiAT/wM+YIZ6SG9QO6a8kg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.12.tgz", + "integrity": "sha512-N3zl+lxHCifgIlcMUP5016ESkeQjLj/959RxxNYIthIg+CQHInujFuXeWbWMgnTo4cp5XVHqFPmpyu9J65C1Yg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.12.tgz", + "integrity": "sha512-HQ9ka4Kx21qHXwtlTUVbKJOAnmG1ipXhdWTmNXiPzPfWKpXqASVcWdnf2bnL73wgjNrFXAa3yYvBSd9pzfEIpA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.12.tgz", + "integrity": "sha512-gA0Bx759+7Jve03K1S0vkOu5Lg/85dou3EseOGUes8flVOGxbhDDh/iZaoek11Y8mtyKPGF3vP8XhnkDEAmzeg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.12.tgz", + "integrity": "sha512-TGbO26Yw2xsHzxtbVFGEXBFH0FRAP7gtcPE7P5yP7wGy7cXK2oO7RyOhL5NLiqTlBh47XhmIUXuGciXEqYFfBQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.12.tgz", + "integrity": "sha512-lPDGyC1JPDou8kGcywY0YILzWlhhnRjdof3UlcoqYmS9El818LLfJJc3PXXgZHrHCAKs/Z2SeZtDJr5MrkxtOw==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.12.tgz", + "integrity": "sha512-8bwX7a8FghIgrupcxb4aUmYDLp8pX06rGh5HqDT7bB+8Rdells6mHvrFHHW2JAOPZUbnjUpKTLg6ECyzvas2AQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ia32": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.12.tgz", + "integrity": "sha512-0y9KrdVnbMM2/vG8KfU0byhUN+EFCny9+8g202gYqSSVMonbsCfLjUO+rCci7pM0WBEtz+oK/PIwHkzxkyharA==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-loong64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.12.tgz", + "integrity": "sha512-h///Lr5a9rib/v1GGqXVGzjL4TMvVTv+s1DPoxQdz7l/AYv6LDSxdIwzxkrPW438oUXiDtwM10o9PmwS/6Z0Ng==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-mips64el": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.12.tgz", + "integrity": "sha512-iyRrM1Pzy9GFMDLsXn1iHUm18nhKnNMWscjmp4+hpafcZjrr2WbT//d20xaGljXDBYHqRcl8HnxbX6uaA/eGVw==", + "cpu": [ + "mips64el" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ppc64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.12.tgz", + "integrity": "sha512-9meM/lRXxMi5PSUqEXRCtVjEZBGwB7P/D4yT8UG/mwIdze2aV4Vo6U5gD3+RsoHXKkHCfSxZKzmDssVlRj1QQA==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-riscv64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.12.tgz", + "integrity": "sha512-Zr7KR4hgKUpWAwb1f3o5ygT04MzqVrGEGXGLnj15YQDJErYu/BGg+wmFlIDOdJp0PmB0lLvxFIOXZgFRrdjR0w==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-s390x": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.12.tgz", + "integrity": "sha512-MsKncOcgTNvdtiISc/jZs/Zf8d0cl/t3gYWX8J9ubBnVOwlk65UIEEvgBORTiljloIWnBzLs4qhzPkJcitIzIg==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.12.tgz", + "integrity": "sha512-uqZMTLr/zR/ed4jIGnwSLkaHmPjOjJvnm6TVVitAa08SLS9Z0VM8wIRx7gWbJB5/J54YuIMInDquWyYvQLZkgw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.12.tgz", + "integrity": "sha512-xXwcTq4GhRM7J9A8Gv5boanHhRa/Q9KLVmcyXHCTaM4wKfIpWkdXiMog/KsnxzJ0A1+nD+zoecuzqPmCRyBGjg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.12.tgz", + "integrity": "sha512-Ld5pTlzPy3YwGec4OuHh1aCVCRvOXdH8DgRjfDy/oumVovmuSzWfnSJg+VtakB9Cm0gxNO9BzWkj6mtO1FMXkQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.12.tgz", + "integrity": "sha512-fF96T6KsBo/pkQI950FARU9apGNTSlZGsv1jZBAlcLL1MLjLNIWPBkj5NlSz8aAzYKg+eNqknrUJ24QBybeR5A==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.12.tgz", + "integrity": "sha512-MZyXUkZHjQxUvzK7rN8DJ3SRmrVrke8ZyRusHlP+kuwqTcfWLyqMOE3sScPPyeIXN/mDJIfGXvcMqCgYKekoQw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openharmony-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.12.tgz", + "integrity": "sha512-rm0YWsqUSRrjncSXGA7Zv78Nbnw4XL6/dzr20cyrQf7ZmRcsovpcRBdhD43Nuk3y7XIoW2OxMVvwuRvk9XdASg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/sunos-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.12.tgz", + "integrity": "sha512-3wGSCDyuTHQUzt0nV7bocDy72r2lI33QL3gkDNGkod22EsYl04sMf0qLb8luNKTOmgF/eDEDP5BFNwoBKH441w==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-arm64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.12.tgz", + "integrity": "sha512-rMmLrur64A7+DKlnSuwqUdRKyd3UE7oPJZmnljqEptesKM8wx9J8gx5u0+9Pq0fQQW8vqeKebwNXdfOyP+8Bsg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-ia32": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.12.tgz", + "integrity": "sha512-HkqnmmBoCbCwxUKKNPBixiWDGCpQGVsrQfJoVGYLPT41XWF8lHuE5N6WhVia2n4o5QK5M4tYr21827fNhi4byQ==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-x64": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.12.tgz", + "integrity": "sha512-alJC0uCZpTFrSL0CCDjcgleBXPnCrEAhTBILpeAp7M/OFgoqtAetfBzX0xM00MUsVVPpVjlPuMbREqnZCXaTnA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.5.5", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz", + "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==", + "dev": true, + "license": "MIT" + }, + "node_modules/@noble/curves": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/@noble/curves/-/curves-1.2.0.tgz", + "integrity": "sha512-oYclrNgRaM9SsBUBVbb8M6DTV7ZHRTKugureoYEncY5c65HOmRzvSiTE3y5CYaPYJA/GVkrhXEoF0M3Ya9PMnw==", + "license": "MIT", + "dependencies": { + "@noble/hashes": "1.3.2" + }, + "funding": { + "url": "https://paulmillr.com/funding/" + } + }, + "node_modules/@noble/hashes": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.3.2.tgz", + "integrity": "sha512-MVC8EAQp7MvEcm30KWENFjgR+Mkmf+D189XJTkFIlwohU5hcBbn1ZkKq7KVTi2Hme3PMGF390DaL52beVrIihQ==", + "license": "MIT", + "engines": { + "node": ">= 16" + }, + "funding": { + "url": "https://paulmillr.com/funding/" + } + }, + "node_modules/@rollup/rollup-android-arm-eabi": { + "version": "4.56.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.56.0.tgz", + "integrity": "sha512-LNKIPA5k8PF1+jAFomGe3qN3bbIgJe/IlpDBwuVjrDKrJhVWywgnJvflMt/zkbVNLFtF1+94SljYQS6e99klnw==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-android-arm64": { + "version": "4.56.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.56.0.tgz", + "integrity": "sha512-lfbVUbelYqXlYiU/HApNMJzT1E87UPGvzveGg2h0ktUNlOCxKlWuJ9jtfvs1sKHdwU4fzY7Pl8sAl49/XaEk6Q==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-darwin-arm64": { + "version": "4.56.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.56.0.tgz", + "integrity": "sha512-EgxD1ocWfhoD6xSOeEEwyE7tDvwTgZc8Bss7wCWe+uc7wO8G34HHCUH+Q6cHqJubxIAnQzAsyUsClt0yFLu06w==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-darwin-x64": { + "version": "4.56.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.56.0.tgz", + "integrity": "sha512-1vXe1vcMOssb/hOF8iv52A7feWW2xnu+c8BV4t1F//m9QVLTfNVpEdja5ia762j/UEJe2Z1jAmEqZAK42tVW3g==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-freebsd-arm64": { + "version": "4.56.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.56.0.tgz", + "integrity": "sha512-bof7fbIlvqsyv/DtaXSck4VYQ9lPtoWNFCB/JY4snlFuJREXfZnm+Ej6yaCHfQvofJDXLDMTVxWscVSuQvVWUQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-freebsd-x64": { + "version": "4.56.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.56.0.tgz", + "integrity": "sha512-KNa6lYHloW+7lTEkYGa37fpvPq+NKG/EHKM8+G/g9WDU7ls4sMqbVRV78J6LdNuVaeeK5WB9/9VAFbKxcbXKYg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-linux-arm-gnueabihf": { + "version": "4.56.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.56.0.tgz", + "integrity": "sha512-E8jKK87uOvLrrLN28jnAAAChNq5LeCd2mGgZF+fGF5D507WlG/Noct3lP/QzQ6MrqJ5BCKNwI9ipADB6jyiq2A==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm-musleabihf": { + "version": "4.56.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.56.0.tgz", + "integrity": "sha512-jQosa5FMYF5Z6prEpTCCmzCXz6eKr/tCBssSmQGEeozA9tkRUty/5Vx06ibaOP9RCrW1Pvb8yp3gvZhHwTDsJw==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-gnu": { + "version": "4.56.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.56.0.tgz", + "integrity": "sha512-uQVoKkrC1KGEV6udrdVahASIsaF8h7iLG0U0W+Xn14ucFwi6uS539PsAr24IEF9/FoDtzMeeJXJIBo5RkbNWvQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-musl": { + "version": "4.56.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.56.0.tgz", + "integrity": "sha512-vLZ1yJKLxhQLFKTs42RwTwa6zkGln+bnXc8ueFGMYmBTLfNu58sl5/eXyxRa2RarTkJbXl8TKPgfS6V5ijNqEA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-gnu": { + "version": "4.56.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.56.0.tgz", + "integrity": "sha512-FWfHOCub564kSE3xJQLLIC/hbKqHSVxy8vY75/YHHzWvbJL7aYJkdgwD/xGfUlL5UV2SB7otapLrcCj2xnF1dg==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-musl": { + "version": "4.56.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.56.0.tgz", + "integrity": "sha512-z1EkujxIh7nbrKL1lmIpqFTc/sr0u8Uk0zK/qIEFldbt6EDKWFk/pxFq3gYj4Bjn3aa9eEhYRlL3H8ZbPT1xvA==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-gnu": { + "version": "4.56.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.56.0.tgz", + "integrity": "sha512-iNFTluqgdoQC7AIE8Q34R3AuPrJGJirj5wMUErxj22deOcY7XwZRaqYmB6ZKFHoVGqRcRd0mqO+845jAibKCkw==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-musl": { + "version": "4.56.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.56.0.tgz", + "integrity": "sha512-MtMeFVlD2LIKjp2sE2xM2slq3Zxf9zwVuw0jemsxvh1QOpHSsSzfNOTH9uYW9i1MXFxUSMmLpeVeUzoNOKBaWg==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-gnu": { + "version": "4.56.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.56.0.tgz", + "integrity": "sha512-in+v6wiHdzzVhYKXIk5U74dEZHdKN9KH0Q4ANHOTvyXPG41bajYRsy7a8TPKbYPl34hU7PP7hMVHRvv/5aCSew==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-musl": { + "version": "4.56.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.56.0.tgz", + "integrity": "sha512-yni2raKHB8m9NQpI9fPVwN754mn6dHQSbDTwxdr9SE0ks38DTjLMMBjrwvB5+mXrX+C0npX0CVeCUcvvvD8CNQ==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-s390x-gnu": { + "version": "4.56.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.56.0.tgz", + "integrity": "sha512-zhLLJx9nQPu7wezbxt2ut+CI4YlXi68ndEve16tPc/iwoylWS9B3FxpLS2PkmfYgDQtosah07Mj9E0khc3Y+vQ==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-gnu": { + "version": "4.56.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.56.0.tgz", + "integrity": "sha512-MVC6UDp16ZSH7x4rtuJPAEoE1RwS8N4oK9DLHy3FTEdFoUTCFVzMfJl/BVJ330C+hx8FfprA5Wqx4FhZXkj2Kw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-musl": { + "version": "4.56.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.56.0.tgz", + "integrity": "sha512-ZhGH1eA4Qv0lxaV00azCIS1ChedK0V32952Md3FtnxSqZTBTd6tgil4nZT5cU8B+SIw3PFYkvyR4FKo2oyZIHA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-openbsd-x64": { + "version": "4.56.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.56.0.tgz", + "integrity": "sha512-O16XcmyDeFI9879pEcmtWvD/2nyxR9mF7Gs44lf1vGGx8Vg2DRNx11aVXBEqOQhWb92WN4z7fW/q4+2NYzCbBA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ] + }, + "node_modules/@rollup/rollup-openharmony-arm64": { + "version": "4.56.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.56.0.tgz", + "integrity": "sha512-LhN/Reh+7F3RCgQIRbgw8ZMwUwyqJM+8pXNT6IIJAqm2IdKkzpCh/V9EdgOMBKuebIrzswqy4ATlrDgiOwbRcQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ] + }, + "node_modules/@rollup/rollup-win32-arm64-msvc": { + "version": "4.56.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.56.0.tgz", + "integrity": "sha512-kbFsOObXp3LBULg1d3JIUQMa9Kv4UitDmpS+k0tinPBz3watcUiV2/LUDMMucA6pZO3WGE27P7DsfaN54l9ing==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-ia32-msvc": { + "version": "4.56.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.56.0.tgz", + "integrity": "sha512-vSSgny54D6P4vf2izbtFm/TcWYedw7f8eBrOiGGecyHyQB9q4Kqentjaj8hToe+995nob/Wv48pDqL5a62EWtg==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-gnu": { + "version": "4.56.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.56.0.tgz", + "integrity": "sha512-FeCnkPCTHQJFbiGG49KjV5YGW/8b9rrXAM2Mz2kiIoktq2qsJxRD5giEMEOD2lPdgs72upzefaUvS+nc8E3UzQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-msvc": { + "version": "4.56.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.56.0.tgz", + "integrity": "sha512-H8AE9Ur/t0+1VXujj90w0HrSOuv0Nq9r1vSZF2t5km20NTfosQsGGUXDaKdQZzwuLts7IyL1fYT4hM95TI9c4g==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@types/body-parser": { + "version": "1.19.6", + "resolved": "https://registry.npmjs.org/@types/body-parser/-/body-parser-1.19.6.tgz", + "integrity": "sha512-HLFeCYgz89uk22N5Qg3dvGvsv46B8GLvKKo1zKG4NybA8U2DiEO3w9lqGg29t/tfLRJpJ6iQxnVw4OnB7MoM9g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/connect": "*", + "@types/node": "*" + } + }, + "node_modules/@types/connect": { + "version": "3.4.38", + "resolved": "https://registry.npmjs.org/@types/connect/-/connect-3.4.38.tgz", + "integrity": "sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/estree": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz", + "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/express": { + "version": "4.17.25", + "resolved": "https://registry.npmjs.org/@types/express/-/express-4.17.25.tgz", + "integrity": "sha512-dVd04UKsfpINUnK0yBoYHDF3xu7xVH4BuDotC/xGuycx4CgbP48X/KF/586bcObxT0HENHXEU8Nqtu6NR+eKhw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/body-parser": "*", + "@types/express-serve-static-core": "^4.17.33", + "@types/qs": "*", + "@types/serve-static": "^1" + } + }, + "node_modules/@types/express-serve-static-core": { + "version": "4.19.8", + "resolved": "https://registry.npmjs.org/@types/express-serve-static-core/-/express-serve-static-core-4.19.8.tgz", + "integrity": "sha512-02S5fmqeoKzVZCHPZid4b8JH2eM5HzQLZWN2FohQEy/0eXTq8VXZfSN6Pcr3F6N9R/vNrj7cpgbhjie6m/1tCA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/node": "*", + "@types/qs": "*", + "@types/range-parser": "*", + "@types/send": "*" + } + }, + "node_modules/@types/http-errors": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@types/http-errors/-/http-errors-2.0.5.tgz", + "integrity": "sha512-r8Tayk8HJnX0FztbZN7oVqGccWgw98T/0neJphO91KkmOzug1KkofZURD4UaD5uH8AqcFLfdPErnBod0u71/qg==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/mime": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/@types/mime/-/mime-1.3.5.tgz", + "integrity": "sha512-/pyBZWSLD2n0dcHE3hq8s8ZvcETHtEuF+3E7XVt0Ig2nvsVQXdghHVcEkIWjy9A0wKfTn97a/PSDYohKIlnP/w==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/node": { + "version": "22.19.7", + "resolved": "https://registry.npmjs.org/@types/node/-/node-22.19.7.tgz", + "integrity": "sha512-MciR4AKGHWl7xwxkBa6xUGxQJ4VBOmPTF7sL+iGzuahOFaO0jHCsuEfS80pan1ef4gWId1oWOweIhrDEYLuaOw==", + "license": "MIT", + "dependencies": { + "undici-types": "~6.21.0" + } + }, + "node_modules/@types/node-fetch": { + "version": "2.6.13", + "resolved": "https://registry.npmjs.org/@types/node-fetch/-/node-fetch-2.6.13.tgz", + "integrity": "sha512-QGpRVpzSaUs30JBSGPjOg4Uveu384erbHBoT1zeONvyCfwQxIkUshLAOqN/k9EjGviPRmWTTe6aH2qySWKTVSw==", + "license": "MIT", + "dependencies": { + "@types/node": "*", + "form-data": "^4.0.4" + } + }, + "node_modules/@types/qs": { + "version": "6.14.0", + "resolved": "https://registry.npmjs.org/@types/qs/-/qs-6.14.0.tgz", + "integrity": "sha512-eOunJqu0K1923aExK6y8p6fsihYEn/BYuQ4g0CxAAgFc4b/ZLN4CrsRZ55srTdqoiLzU2B2evC+apEIxprEzkQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/range-parser": { + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/@types/range-parser/-/range-parser-1.2.7.tgz", + "integrity": "sha512-hKormJbkJqzQGhziax5PItDUTMAM9uE2XXQmM37dyd4hVM+5aVl7oVxMVUiVQn2oCQFN/LKCZdvSM0pFRqbSmQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/send": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/@types/send/-/send-1.2.1.tgz", + "integrity": "sha512-arsCikDvlU99zl1g69TcAB3mzZPpxgw0UQnaHeC1Nwb015xp8bknZv5rIfri9xTOcMuaVgvabfIRA7PSZVuZIQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/serve-static": { + "version": "1.15.10", + "resolved": "https://registry.npmjs.org/@types/serve-static/-/serve-static-1.15.10.tgz", + "integrity": "sha512-tRs1dB+g8Itk72rlSI2ZrW6vZg0YrLI81iQSTkMmOqnqCaNr/8Ek4VwWcN5vZgCYWbg/JJSGBlUaYGAOP73qBw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/http-errors": "*", + "@types/node": "*", + "@types/send": "<1" + } + }, + "node_modules/@types/serve-static/node_modules/@types/send": { + "version": "0.17.6", + "resolved": "https://registry.npmjs.org/@types/send/-/send-0.17.6.tgz", + "integrity": "sha512-Uqt8rPBE8SY0RK8JB1EzVOIZ32uqy8HwdxCnoCOsYrvnswqmFZ/k+9Ikidlk/ImhsdvBsloHbAlewb2IEBV/Og==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/mime": "^1", + "@types/node": "*" + } + }, + "node_modules/@vitest/expect": { + "version": "2.1.9", + "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-2.1.9.tgz", + "integrity": "sha512-UJCIkTBenHeKT1TTlKMJWy1laZewsRIzYighyYiJKZreqtdxSos/S1t+ktRMQWu2CKqaarrkeszJx1cgC5tGZw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/spy": "2.1.9", + "@vitest/utils": "2.1.9", + "chai": "^5.1.2", + "tinyrainbow": "^1.2.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/pretty-format": { + "version": "2.1.9", + "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-2.1.9.tgz", + "integrity": "sha512-KhRIdGV2U9HOUzxfiHmY8IFHTdqtOhIzCpd8WRdJiE7D/HUcZVD0EgQCVjm+Q9gkUXWgBvMmTtZgIG48wq7sOQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "tinyrainbow": "^1.2.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/runner": { + "version": "2.1.9", + "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-2.1.9.tgz", + "integrity": "sha512-ZXSSqTFIrzduD63btIfEyOmNcBmQvgOVsPNPe0jYtESiXkhd8u2erDLnMxmGrDCwHCCHE7hxwRDCT3pt0esT4g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/utils": "2.1.9", + "pathe": "^1.1.2" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/snapshot": { + "version": "2.1.9", + "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-2.1.9.tgz", + "integrity": "sha512-oBO82rEjsxLNJincVhLhaxxZdEtV0EFHMK5Kmx5sJ6H9L183dHECjiefOAdnqpIgT5eZwT04PoggUnW88vOBNQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/pretty-format": "2.1.9", + "magic-string": "^0.30.12", + "pathe": "^1.1.2" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/spy": { + "version": "2.1.9", + "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-2.1.9.tgz", + "integrity": "sha512-E1B35FwzXXTs9FHNK6bDszs7mtydNi5MIfUWpceJ8Xbfb1gBMscAnwLbEu+B44ed6W3XjL9/ehLPHR1fkf1KLQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "tinyspy": "^3.0.2" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/@vitest/utils": { + "version": "2.1.9", + "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-2.1.9.tgz", + "integrity": "sha512-v0psaMSkNJ3A2NMrUEHFRzJtDPFn+/VWZ5WxImB21T9fjucJRmS7xCS3ppEnARb9y11OAzaD+P2Ps+b+BGX5iQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/pretty-format": "2.1.9", + "loupe": "^3.1.2", + "tinyrainbow": "^1.2.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/abort-controller": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/abort-controller/-/abort-controller-3.0.0.tgz", + "integrity": "sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg==", + "license": "MIT", + "dependencies": { + "event-target-shim": "^5.0.0" + }, + "engines": { + "node": ">=6.5" + } + }, + "node_modules/accepts": { + "version": "1.3.8", + "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz", + "integrity": "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==", + "license": "MIT", + "dependencies": { + "mime-types": "~2.1.34", + "negotiator": "0.6.3" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/aes-js": { + "version": "4.0.0-beta.5", + "resolved": "https://registry.npmjs.org/aes-js/-/aes-js-4.0.0-beta.5.tgz", + "integrity": "sha512-G965FqalsNyrPqgEGON7nIx1e/OVENSgiEIzyC63haUMuvNnwIgIjMs52hlTCKhkBny7A2ORNlfY9Zu+jmGk1Q==", + "license": "MIT" + }, + "node_modules/agentkeepalive": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/agentkeepalive/-/agentkeepalive-4.6.0.tgz", + "integrity": "sha512-kja8j7PjmncONqaTsB8fQ+wE2mSU2DJ9D4XKoJ5PFWIdRMa6SLSN1ff4mOr4jCbfRSsxR4keIiySJU0N9T5hIQ==", + "license": "MIT", + "dependencies": { + "humanize-ms": "^1.2.1" + }, + "engines": { + "node": ">= 8.0.0" + } + }, + "node_modules/array-flatten": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz", + "integrity": "sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==", + "license": "MIT" + }, + "node_modules/assertion-error": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz", + "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + } + }, + "node_modules/asynckit": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz", + "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==", + "license": "MIT" + }, + "node_modules/body-parser": { + "version": "1.20.4", + "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.4.tgz", + "integrity": "sha512-ZTgYYLMOXY9qKU/57FAo8F+HA2dGX7bqGc71txDRC1rS4frdFI5R7NhluHxH6M0YItAP0sHB4uqAOcYKxO6uGA==", + "license": "MIT", + "dependencies": { + "bytes": "~3.1.2", + "content-type": "~1.0.5", + "debug": "2.6.9", + "depd": "2.0.0", + "destroy": "~1.2.0", + "http-errors": "~2.0.1", + "iconv-lite": "~0.4.24", + "on-finished": "~2.4.1", + "qs": "~6.14.0", + "raw-body": "~2.5.3", + "type-is": "~1.6.18", + "unpipe": "~1.0.0" + }, + "engines": { + "node": ">= 0.8", + "npm": "1.2.8000 || >= 1.4.16" + } + }, + "node_modules/body-parser/node_modules/debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "license": "MIT", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/body-parser/node_modules/ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==", + "license": "MIT" + }, + "node_modules/bytes": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz", + "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/cac": { + "version": "6.7.14", + "resolved": "https://registry.npmjs.org/cac/-/cac-6.7.14.tgz", + "integrity": "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/call-bind-apply-helpers": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz", + "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/call-bound": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz", + "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==", + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.2", + "get-intrinsic": "^1.3.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/chai": { + "version": "5.3.3", + "resolved": "https://registry.npmjs.org/chai/-/chai-5.3.3.tgz", + "integrity": "sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw==", + "dev": true, + "license": "MIT", + "dependencies": { + "assertion-error": "^2.0.1", + "check-error": "^2.1.1", + "deep-eql": "^5.0.1", + "loupe": "^3.1.0", + "pathval": "^2.0.0" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/check-error": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/check-error/-/check-error-2.1.3.tgz", + "integrity": "sha512-PAJdDJusoxnwm1VwW07VWwUN1sl7smmC3OKggvndJFadxxDRyFJBX/ggnu/KE4kQAB7a3Dp8f/YXC1FlUprWmA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 16" + } + }, + "node_modules/combined-stream": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz", + "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==", + "license": "MIT", + "dependencies": { + "delayed-stream": "~1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/content-disposition": { + "version": "0.5.4", + "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.4.tgz", + "integrity": "sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==", + "license": "MIT", + "dependencies": { + "safe-buffer": "5.2.1" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/content-type": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz", + "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/cookie": { + "version": "0.7.2", + "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz", + "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/cookie-signature": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.7.tgz", + "integrity": "sha512-NXdYc3dLr47pBkpUCHtKSwIOQXLVn8dZEuywboCOJY/osA0wFSLlSawr3KN8qXJEyX66FcONTH8EIlVuK0yyFA==", + "license": "MIT" + }, + "node_modules/debug": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/deep-eql": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-5.0.2.tgz", + "integrity": "sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/delayed-stream": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz", + "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==", + "license": "MIT", + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/depd": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz", + "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/destroy": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz", + "integrity": "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==", + "license": "MIT", + "engines": { + "node": ">= 0.8", + "npm": "1.2.8000 || >= 1.4.16" + } + }, + "node_modules/dotenv": { + "version": "16.6.1", + "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.6.1.tgz", + "integrity": "sha512-uBq4egWHTcTt33a72vpSG0z3HnPuIl6NqYcTrKEg2azoEyl2hpW0zqlxysq2pK9HlDIHyHyakeYaYnSAwd8bow==", + "license": "BSD-2-Clause", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://dotenvx.com" + } + }, + "node_modules/dunder-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz", + "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==", + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.1", + "es-errors": "^1.3.0", + "gopd": "^1.2.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/ee-first": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz", + "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==", + "license": "MIT" + }, + "node_modules/encodeurl": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz", + "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/es-define-property": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz", + "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-errors": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz", + "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-module-lexer": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.7.0.tgz", + "integrity": "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==", + "dev": true, + "license": "MIT" + }, + "node_modules/es-object-atoms": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz", + "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-set-tostringtag": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz", + "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.6", + "has-tostringtag": "^1.0.2", + "hasown": "^2.0.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/esbuild": { + "version": "0.25.12", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.12.tgz", + "integrity": "sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=18" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.25.12", + "@esbuild/android-arm": "0.25.12", + "@esbuild/android-arm64": "0.25.12", + "@esbuild/android-x64": "0.25.12", + "@esbuild/darwin-arm64": "0.25.12", + "@esbuild/darwin-x64": "0.25.12", + "@esbuild/freebsd-arm64": "0.25.12", + "@esbuild/freebsd-x64": "0.25.12", + "@esbuild/linux-arm": "0.25.12", + "@esbuild/linux-arm64": "0.25.12", + "@esbuild/linux-ia32": "0.25.12", + "@esbuild/linux-loong64": "0.25.12", + "@esbuild/linux-mips64el": "0.25.12", + "@esbuild/linux-ppc64": "0.25.12", + "@esbuild/linux-riscv64": "0.25.12", + "@esbuild/linux-s390x": "0.25.12", + "@esbuild/linux-x64": "0.25.12", + "@esbuild/netbsd-arm64": "0.25.12", + "@esbuild/netbsd-x64": "0.25.12", + "@esbuild/openbsd-arm64": "0.25.12", + "@esbuild/openbsd-x64": "0.25.12", + "@esbuild/openharmony-arm64": "0.25.12", + "@esbuild/sunos-x64": "0.25.12", + "@esbuild/win32-arm64": "0.25.12", + "@esbuild/win32-ia32": "0.25.12", + "@esbuild/win32-x64": "0.25.12" + } + }, + "node_modules/escape-html": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz", + "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==", + "license": "MIT" + }, + "node_modules/estree-walker": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz", + "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/estree": "^1.0.0" + } + }, + "node_modules/etag": { + "version": "1.8.1", + "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz", + "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/ethers": { + "version": "6.16.0", + "resolved": "https://registry.npmjs.org/ethers/-/ethers-6.16.0.tgz", + "integrity": "sha512-U1wulmetNymijEhpSEQ7Ct/P/Jw9/e7R1j5XIbPRydgV2DjLVMsULDlNksq3RQnFgKoLlZf88ijYtWEXcPa07A==", + "funding": [ + { + "type": "individual", + "url": "https://github.com/sponsors/ethers-io/" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "license": "MIT", + "dependencies": { + "@adraffy/ens-normalize": "1.10.1", + "@noble/curves": "1.2.0", + "@noble/hashes": "1.3.2", + "@types/node": "22.7.5", + "aes-js": "4.0.0-beta.5", + "tslib": "2.7.0", + "ws": "8.17.1" + }, + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/ethers/node_modules/@types/node": { + "version": "22.7.5", + "resolved": "https://registry.npmjs.org/@types/node/-/node-22.7.5.tgz", + "integrity": "sha512-jML7s2NAzMWc//QSJ1a3prpk78cOPchGvXJsC3C6R6PSMoooztvRVQEz89gmBTBY1SPMaqo5teB4uNHPdetShQ==", + "license": "MIT", + "dependencies": { + "undici-types": "~6.19.2" + } + }, + "node_modules/ethers/node_modules/undici-types": { + "version": "6.19.8", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.19.8.tgz", + "integrity": "sha512-ve2KP6f/JnbPBFyobGHuerC9g1FYGn/F8n1LWTwNxCEzd6IfqTwUQcNXgEtmmQ6DlRrC1hrSrBnCZPokRrDHjw==", + "license": "MIT" + }, + "node_modules/ethers/node_modules/ws": { + "version": "8.17.1", + "resolved": "https://registry.npmjs.org/ws/-/ws-8.17.1.tgz", + "integrity": "sha512-6XQFvXTkbfUOZOKKILFG1PDK2NDQs4azKQl26T0YS5CxqWLgXajbPZ+h4gZekJyRqFU8pvnbAbbs/3TgRPy+GQ==", + "license": "MIT", + "engines": { + "node": ">=10.0.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": ">=5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } + } + }, + "node_modules/event-target-shim": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/event-target-shim/-/event-target-shim-5.0.1.tgz", + "integrity": "sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/expect-type": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.3.0.tgz", + "integrity": "sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=12.0.0" + } + }, + "node_modules/express": { + "version": "4.22.1", + "resolved": "https://registry.npmjs.org/express/-/express-4.22.1.tgz", + "integrity": "sha512-F2X8g9P1X7uCPZMA3MVf9wcTqlyNp7IhH5qPCI0izhaOIYXaW9L535tGA3qmjRzpH+bZczqq7hVKxTR4NWnu+g==", + "license": "MIT", + "dependencies": { + "accepts": "~1.3.8", + "array-flatten": "1.1.1", + "body-parser": "~1.20.3", + "content-disposition": "~0.5.4", + "content-type": "~1.0.4", + "cookie": "~0.7.1", + "cookie-signature": "~1.0.6", + "debug": "2.6.9", + "depd": "2.0.0", + "encodeurl": "~2.0.0", + "escape-html": "~1.0.3", + "etag": "~1.8.1", + "finalhandler": "~1.3.1", + "fresh": "~0.5.2", + "http-errors": "~2.0.0", + "merge-descriptors": "1.0.3", + "methods": "~1.1.2", + "on-finished": "~2.4.1", + "parseurl": "~1.3.3", + "path-to-regexp": "~0.1.12", + "proxy-addr": "~2.0.7", + "qs": "~6.14.0", + "range-parser": "~1.2.1", + "safe-buffer": "5.2.1", + "send": "~0.19.0", + "serve-static": "~1.16.2", + "setprototypeof": "1.2.0", + "statuses": "~2.0.1", + "type-is": "~1.6.18", + "utils-merge": "1.0.1", + "vary": "~1.1.2" + }, + "engines": { + "node": ">= 0.10.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/express/node_modules/debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "license": "MIT", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/express/node_modules/ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==", + "license": "MIT" + }, + "node_modules/fdir": { + "version": "6.5.0", + "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz", + "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12.0.0" + }, + "peerDependencies": { + "picomatch": "^3 || ^4" + }, + "peerDependenciesMeta": { + "picomatch": { + "optional": true + } + } + }, + "node_modules/finalhandler": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.2.tgz", + "integrity": "sha512-aA4RyPcd3badbdABGDuTXCMTtOneUCAYH/gxoYRTZlIJdF0YPWuGqiAsIrhNnnqdXGswYk6dGujem4w80UJFhg==", + "license": "MIT", + "dependencies": { + "debug": "2.6.9", + "encodeurl": "~2.0.0", + "escape-html": "~1.0.3", + "on-finished": "~2.4.1", + "parseurl": "~1.3.3", + "statuses": "~2.0.2", + "unpipe": "~1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/finalhandler/node_modules/debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "license": "MIT", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/finalhandler/node_modules/ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==", + "license": "MIT" + }, + "node_modules/form-data": { + "version": "4.0.5", + "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.5.tgz", + "integrity": "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==", + "license": "MIT", + "dependencies": { + "asynckit": "^0.4.0", + "combined-stream": "^1.0.8", + "es-set-tostringtag": "^2.1.0", + "hasown": "^2.0.2", + "mime-types": "^2.1.12" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/form-data-encoder": { + "version": "1.7.2", + "resolved": "https://registry.npmjs.org/form-data-encoder/-/form-data-encoder-1.7.2.tgz", + "integrity": "sha512-qfqtYan3rxrnCk1VYaA4H+Ms9xdpPqvLZa6xmMgFvhO32x7/3J/ExcTd6qpxM0vH2GdMI+poehyBZvqfMTto8A==", + "license": "MIT" + }, + "node_modules/formdata-node": { + "version": "4.4.1", + "resolved": "https://registry.npmjs.org/formdata-node/-/formdata-node-4.4.1.tgz", + "integrity": "sha512-0iirZp3uVDjVGt9p49aTaqjk84TrglENEDuqfdlZQ1roC9CWlPk6Avf8EEnZNcAqPonwkG35x4n3ww/1THYAeQ==", + "license": "MIT", + "dependencies": { + "node-domexception": "1.0.0", + "web-streams-polyfill": "4.0.0-beta.3" + }, + "engines": { + "node": ">= 12.20" + } + }, + "node_modules/forwarded": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz", + "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/fresh": { + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz", + "integrity": "sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/fsevents": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/function-bind": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz", + "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/get-intrinsic": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz", + "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==", + "license": "MIT", + "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" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/get-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz", + "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==", + "license": "MIT", + "dependencies": { + "dunder-proto": "^1.0.1", + "es-object-atoms": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/get-tsconfig": { + "version": "4.13.0", + "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.13.0.tgz", + "integrity": "sha512-1VKTZJCwBrvbd+Wn3AOgQP/2Av+TfTCOlE4AcRJE72W1ksZXbAx8PPBR9RzgTeSPzlPMHrbANMH3LbltH73wxQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "resolve-pkg-maps": "^1.0.0" + }, + "funding": { + "url": "https://github.com/privatenumber/get-tsconfig?sponsor=1" + } + }, + "node_modules/gopd": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz", + "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-symbols": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz", + "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-tostringtag": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz", + "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==", + "license": "MIT", + "dependencies": { + "has-symbols": "^1.0.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/hasown": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz", + "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==", + "license": "MIT", + "dependencies": { + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/http-errors": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.1.tgz", + "integrity": "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==", + "license": "MIT", + "dependencies": { + "depd": "~2.0.0", + "inherits": "~2.0.4", + "setprototypeof": "~1.2.0", + "statuses": "~2.0.2", + "toidentifier": "~1.0.1" + }, + "engines": { + "node": ">= 0.8" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/humanize-ms": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/humanize-ms/-/humanize-ms-1.2.1.tgz", + "integrity": "sha512-Fl70vYtsAFb/C06PTS9dZBo7ihau+Tu/DNCk/OyHhea07S+aeMWpFFkUaXRa8fI+ScZbEI8dfSxwY7gxZ9SAVQ==", + "license": "MIT", + "dependencies": { + "ms": "^2.0.0" + } + }, + "node_modules/iconv-lite": { + "version": "0.4.24", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz", + "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==", + "license": "MIT", + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/inherits": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", + "license": "ISC" + }, + "node_modules/ipaddr.js": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz", + "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==", + "license": "MIT", + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/loupe": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/loupe/-/loupe-3.2.1.tgz", + "integrity": "sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/magic-string": { + "version": "0.30.21", + "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz", + "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.5.5" + } + }, + "node_modules/math-intrinsics": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz", + "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/media-typer": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz", + "integrity": "sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/merge-descriptors": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.3.tgz", + "integrity": "sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/methods": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz", + "integrity": "sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/mime": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz", + "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==", + "license": "MIT", + "bin": { + "mime": "cli.js" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/mime-db": { + "version": "1.52.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz", + "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/mime-types": { + "version": "2.1.35", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz", + "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==", + "license": "MIT", + "dependencies": { + "mime-db": "1.52.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "license": "MIT" + }, + "node_modules/nanoid": { + "version": "3.3.11", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz", + "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "bin": { + "nanoid": "bin/nanoid.cjs" + }, + "engines": { + "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" + } + }, + "node_modules/negotiator": { + "version": "0.6.3", + "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz", + "integrity": "sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/node-domexception": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/node-domexception/-/node-domexception-1.0.0.tgz", + "integrity": "sha512-/jKZoMpw0F8GRwl4/eLROPA3cfcXtLApP0QzLmUT/HuPCZWyB7IY9ZrMeKw2O/nFIqPQB3PVM9aYm0F312AXDQ==", + "deprecated": "Use your platform's native DOMException instead", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/jimmywarting" + }, + { + "type": "github", + "url": "https://paypal.me/jimmywarting" + } + ], + "license": "MIT", + "engines": { + "node": ">=10.5.0" + } + }, + "node_modules/node-fetch": { + "version": "2.7.0", + "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz", + "integrity": "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==", + "license": "MIT", + "dependencies": { + "whatwg-url": "^5.0.0" + }, + "engines": { + "node": "4.x || >=6.0.0" + }, + "peerDependencies": { + "encoding": "^0.1.0" + }, + "peerDependenciesMeta": { + "encoding": { + "optional": true + } + } + }, + "node_modules/object-inspect": { + "version": "1.13.4", + "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz", + "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/on-finished": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz", + "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==", + "license": "MIT", + "dependencies": { + "ee-first": "1.1.1" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/openai": { + "version": "4.104.0", + "resolved": "https://registry.npmjs.org/openai/-/openai-4.104.0.tgz", + "integrity": "sha512-p99EFNsA/yX6UhVO93f5kJsDRLAg+CTA2RBqdHK4RtK8u5IJw32Hyb2dTGKbnnFmnuoBv5r7Z2CURI9sGZpSuA==", + "license": "Apache-2.0", + "dependencies": { + "@types/node": "^18.11.18", + "@types/node-fetch": "^2.6.4", + "abort-controller": "^3.0.0", + "agentkeepalive": "^4.2.1", + "form-data-encoder": "1.7.2", + "formdata-node": "^4.3.2", + "node-fetch": "^2.6.7" + }, + "bin": { + "openai": "bin/cli" + }, + "peerDependencies": { + "ws": "^8.18.0", + "zod": "^3.23.8" + }, + "peerDependenciesMeta": { + "ws": { + "optional": true + }, + "zod": { + "optional": true + } + } + }, + "node_modules/openai/node_modules/@types/node": { + "version": "18.19.130", + "resolved": "https://registry.npmjs.org/@types/node/-/node-18.19.130.tgz", + "integrity": "sha512-GRaXQx6jGfL8sKfaIDD6OupbIHBr9jv7Jnaml9tB7l4v068PAOXqfcujMMo5PhbIs6ggR1XODELqahT2R8v0fg==", + "license": "MIT", + "dependencies": { + "undici-types": "~5.26.4" + } + }, + "node_modules/openai/node_modules/undici-types": { + "version": "5.26.5", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz", + "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==", + "license": "MIT" + }, + "node_modules/parseurl": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz", + "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/path-to-regexp": { + "version": "0.1.12", + "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.12.tgz", + "integrity": "sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ==", + "license": "MIT" + }, + "node_modules/pathe": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/pathe/-/pathe-1.1.2.tgz", + "integrity": "sha512-whLdWMYL2TwI08hn8/ZqAbrVemu0LNaNNJZX73O6qaIdCTfXutsLhMkjdENX0qhsQ9uIimo4/aQOmXkoon2nDQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/pathval": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/pathval/-/pathval-2.0.1.tgz", + "integrity": "sha512-//nshmD55c46FuFw26xV/xFAaB5HF9Xdap7HJBBnrKdAd6/GxDBaNA1870O79+9ueg61cZLSVc+OaFlfmObYVQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 14.16" + } + }, + "node_modules/picocolors": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz", + "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==", + "dev": true, + "license": "ISC" + }, + "node_modules/picomatch": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz", + "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/postcss": { + "version": "8.5.6", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz", + "integrity": "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/postcss" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "nanoid": "^3.3.11", + "picocolors": "^1.1.1", + "source-map-js": "^1.2.1" + }, + "engines": { + "node": "^10 || ^12 || >=14" + } + }, + "node_modules/proxy-addr": { + "version": "2.0.7", + "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz", + "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==", + "license": "MIT", + "dependencies": { + "forwarded": "0.2.0", + "ipaddr.js": "1.9.1" + }, + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/qs": { + "version": "6.14.1", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.14.1.tgz", + "integrity": "sha512-4EK3+xJl8Ts67nLYNwqw/dsFVnCf+qR7RgXSK9jEEm9unao3njwMDdmsdvoKBKHzxd7tCYz5e5M+SnMjdtXGQQ==", + "license": "BSD-3-Clause", + "dependencies": { + "side-channel": "^1.1.0" + }, + "engines": { + "node": ">=0.6" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/range-parser": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz", + "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/raw-body": { + "version": "2.5.3", + "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.3.tgz", + "integrity": "sha512-s4VSOf6yN0rvbRZGxs8Om5CWj6seneMwK3oDb4lWDH0UPhWcxwOWw5+qk24bxq87szX1ydrwylIOp2uG1ojUpA==", + "license": "MIT", + "dependencies": { + "bytes": "~3.1.2", + "http-errors": "~2.0.1", + "iconv-lite": "~0.4.24", + "unpipe": "~1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/resolve-pkg-maps": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/resolve-pkg-maps/-/resolve-pkg-maps-1.0.0.tgz", + "integrity": "sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1" + } + }, + "node_modules/rollup": { + "version": "4.56.0", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.56.0.tgz", + "integrity": "sha512-9FwVqlgUHzbXtDg9RCMgodF3Ua4Na6Gau+Sdt9vyCN4RhHfVKX2DCHy3BjMLTDd47ITDhYAnTwGulWTblJSDLg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/estree": "1.0.8" + }, + "bin": { + "rollup": "dist/bin/rollup" + }, + "engines": { + "node": ">=18.0.0", + "npm": ">=8.0.0" + }, + "optionalDependencies": { + "@rollup/rollup-android-arm-eabi": "4.56.0", + "@rollup/rollup-android-arm64": "4.56.0", + "@rollup/rollup-darwin-arm64": "4.56.0", + "@rollup/rollup-darwin-x64": "4.56.0", + "@rollup/rollup-freebsd-arm64": "4.56.0", + "@rollup/rollup-freebsd-x64": "4.56.0", + "@rollup/rollup-linux-arm-gnueabihf": "4.56.0", + "@rollup/rollup-linux-arm-musleabihf": "4.56.0", + "@rollup/rollup-linux-arm64-gnu": "4.56.0", + "@rollup/rollup-linux-arm64-musl": "4.56.0", + "@rollup/rollup-linux-loong64-gnu": "4.56.0", + "@rollup/rollup-linux-loong64-musl": "4.56.0", + "@rollup/rollup-linux-ppc64-gnu": "4.56.0", + "@rollup/rollup-linux-ppc64-musl": "4.56.0", + "@rollup/rollup-linux-riscv64-gnu": "4.56.0", + "@rollup/rollup-linux-riscv64-musl": "4.56.0", + "@rollup/rollup-linux-s390x-gnu": "4.56.0", + "@rollup/rollup-linux-x64-gnu": "4.56.0", + "@rollup/rollup-linux-x64-musl": "4.56.0", + "@rollup/rollup-openbsd-x64": "4.56.0", + "@rollup/rollup-openharmony-arm64": "4.56.0", + "@rollup/rollup-win32-arm64-msvc": "4.56.0", + "@rollup/rollup-win32-ia32-msvc": "4.56.0", + "@rollup/rollup-win32-x64-gnu": "4.56.0", + "@rollup/rollup-win32-x64-msvc": "4.56.0", + "fsevents": "~2.3.2" + } + }, + "node_modules/safe-buffer": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", + "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT" + }, + "node_modules/safer-buffer": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", + "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==", + "license": "MIT" + }, + "node_modules/send": { + "version": "0.19.2", + "resolved": "https://registry.npmjs.org/send/-/send-0.19.2.tgz", + "integrity": "sha512-VMbMxbDeehAxpOtWJXlcUS5E8iXh6QmN+BkRX1GARS3wRaXEEgzCcB10gTQazO42tpNIya8xIyNx8fll1OFPrg==", + "license": "MIT", + "dependencies": { + "debug": "2.6.9", + "depd": "2.0.0", + "destroy": "1.2.0", + "encodeurl": "~2.0.0", + "escape-html": "~1.0.3", + "etag": "~1.8.1", + "fresh": "~0.5.2", + "http-errors": "~2.0.1", + "mime": "1.6.0", + "ms": "2.1.3", + "on-finished": "~2.4.1", + "range-parser": "~1.2.1", + "statuses": "~2.0.2" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/send/node_modules/debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "license": "MIT", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/send/node_modules/debug/node_modules/ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==", + "license": "MIT" + }, + "node_modules/serve-static": { + "version": "1.16.3", + "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.16.3.tgz", + "integrity": "sha512-x0RTqQel6g5SY7Lg6ZreMmsOzncHFU7nhnRWkKgWuMTu5NN0DR5oruckMqRvacAN9d5w6ARnRBXl9xhDCgfMeA==", + "license": "MIT", + "dependencies": { + "encodeurl": "~2.0.0", + "escape-html": "~1.0.3", + "parseurl": "~1.3.3", + "send": "~0.19.1" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/setprototypeof": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz", + "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==", + "license": "ISC" + }, + "node_modules/side-channel": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz", + "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==", + "license": "MIT", + "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" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-list": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz", + "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "object-inspect": "^1.13.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-map": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz", + "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.5", + "object-inspect": "^1.13.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-weakmap": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz", + "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==", + "license": "MIT", + "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" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/siginfo": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/siginfo/-/siginfo-2.0.0.tgz", + "integrity": "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==", + "dev": true, + "license": "ISC" + }, + "node_modules/source-map-js": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz", + "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/stackback": { + "version": "0.0.2", + "resolved": "https://registry.npmjs.org/stackback/-/stackback-0.0.2.tgz", + "integrity": "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==", + "dev": true, + "license": "MIT" + }, + "node_modules/statuses": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.2.tgz", + "integrity": "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/std-env": { + "version": "3.10.0", + "resolved": "https://registry.npmjs.org/std-env/-/std-env-3.10.0.tgz", + "integrity": "sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==", + "dev": true, + "license": "MIT" + }, + "node_modules/tinybench": { + "version": "2.9.0", + "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz", + "integrity": "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==", + "dev": true, + "license": "MIT" + }, + "node_modules/tinyexec": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-0.3.2.tgz", + "integrity": "sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==", + "dev": true, + "license": "MIT" + }, + "node_modules/tinyglobby": { + "version": "0.2.15", + "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz", + "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "fdir": "^6.5.0", + "picomatch": "^4.0.3" + }, + "engines": { + "node": ">=12.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/SuperchupuDev" + } + }, + "node_modules/tinypool": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/tinypool/-/tinypool-1.1.1.tgz", + "integrity": "sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^18.0.0 || >=20.0.0" + } + }, + "node_modules/tinyrainbow": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-1.2.0.tgz", + "integrity": "sha512-weEDEq7Z5eTHPDh4xjX789+fHfF+P8boiFB+0vbWzpbnbsEr/GRaohi/uMKxg8RZMXnl1ItAi/IUHWMsjDV7kQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/tinyspy": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/tinyspy/-/tinyspy-3.0.2.tgz", + "integrity": "sha512-n1cw8k1k0x4pgA2+9XrOkFydTerNcJ1zWCO5Nn9scWHTD+5tp8dghT2x1uduQePZTZgd3Tupf+x9BxJjeJi77Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/toidentifier": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz", + "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==", + "license": "MIT", + "engines": { + "node": ">=0.6" + } + }, + "node_modules/tr46": { + "version": "0.0.3", + "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz", + "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==", + "license": "MIT" + }, + "node_modules/tslib": { + "version": "2.7.0", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.7.0.tgz", + "integrity": "sha512-gLXCKdN1/j47AiHiOkJN69hJmcbGTHI0ImLmbYLHykhgeN0jVGola9yVjFgzCUklsZQMW55o+dW7IXv3RCXDzA==", + "license": "0BSD" + }, + "node_modules/tsx": { + "version": "4.21.0", + "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.21.0.tgz", + "integrity": "sha512-5C1sg4USs1lfG0GFb2RLXsdpXqBSEhAaA/0kPL01wxzpMqLILNxIxIOKiILz+cdg/pLnOUxFYOR5yhHU666wbw==", + "dev": true, + "license": "MIT", + "dependencies": { + "esbuild": "~0.27.0", + "get-tsconfig": "^4.7.5" + }, + "bin": { + "tsx": "dist/cli.mjs" + }, + "engines": { + "node": ">=18.0.0" + }, + "optionalDependencies": { + "fsevents": "~2.3.3" + } + }, + "node_modules/tsx/node_modules/@esbuild/aix-ppc64": { + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.2.tgz", + "integrity": "sha512-GZMB+a0mOMZs4MpDbj8RJp4cw+w1WV5NYD6xzgvzUJ5Ek2jerwfO2eADyI6ExDSUED+1X8aMbegahsJi+8mgpw==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "aix" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/android-arm": { + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.27.2.tgz", + "integrity": "sha512-DVNI8jlPa7Ujbr1yjU2PfUSRtAUZPG9I1RwW4F4xFB1Imiu2on0ADiI/c3td+KmDtVKNbi+nffGDQMfcIMkwIA==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/android-arm64": { + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.27.2.tgz", + "integrity": "sha512-pvz8ZZ7ot/RBphf8fv60ljmaoydPU12VuXHImtAs0XhLLw+EXBi2BLe3OYSBslR4rryHvweW5gmkKFwTiFy6KA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/android-x64": { + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.27.2.tgz", + "integrity": "sha512-z8Ank4Byh4TJJOh4wpz8g2vDy75zFL0TlZlkUkEwYXuPSgX8yzep596n6mT7905kA9uHZsf/o2OJZubl2l3M7A==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/darwin-arm64": { + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.27.2.tgz", + "integrity": "sha512-davCD2Zc80nzDVRwXTcQP/28fiJbcOwvdolL0sOiOsbwBa72kegmVU0Wrh1MYrbuCL98Omp5dVhQFWRKR2ZAlg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/darwin-x64": { + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.27.2.tgz", + "integrity": "sha512-ZxtijOmlQCBWGwbVmwOF/UCzuGIbUkqB1faQRf5akQmxRJ1ujusWsb3CVfk/9iZKr2L5SMU5wPBi1UWbvL+VQA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/freebsd-arm64": { + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.27.2.tgz", + "integrity": "sha512-lS/9CN+rgqQ9czogxlMcBMGd+l8Q3Nj1MFQwBZJyoEKI50XGxwuzznYdwcav6lpOGv5BqaZXqvBSiB/kJ5op+g==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/freebsd-x64": { + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.27.2.tgz", + "integrity": "sha512-tAfqtNYb4YgPnJlEFu4c212HYjQWSO/w/h/lQaBK7RbwGIkBOuNKQI9tqWzx7Wtp7bTPaGC6MJvWI608P3wXYA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/linux-arm": { + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.27.2.tgz", + "integrity": "sha512-vWfq4GaIMP9AIe4yj1ZUW18RDhx6EPQKjwe7n8BbIecFtCQG4CfHGaHuh7fdfq+y3LIA2vGS/o9ZBGVxIDi9hw==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/linux-arm64": { + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.27.2.tgz", + "integrity": "sha512-hYxN8pr66NsCCiRFkHUAsxylNOcAQaxSSkHMMjcpx0si13t1LHFphxJZUiGwojB1a/Hd5OiPIqDdXONia6bhTw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/linux-ia32": { + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.27.2.tgz", + "integrity": "sha512-MJt5BRRSScPDwG2hLelYhAAKh9imjHK5+NE/tvnRLbIqUWa+0E9N4WNMjmp/kXXPHZGqPLxggwVhz7QP8CTR8w==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/linux-loong64": { + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.27.2.tgz", + "integrity": "sha512-lugyF1atnAT463aO6KPshVCJK5NgRnU4yb3FUumyVz+cGvZbontBgzeGFO1nF+dPueHD367a2ZXe1NtUkAjOtg==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/linux-mips64el": { + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.27.2.tgz", + "integrity": "sha512-nlP2I6ArEBewvJ2gjrrkESEZkB5mIoaTswuqNFRv/WYd+ATtUpe9Y09RnJvgvdag7he0OWgEZWhviS1OTOKixw==", + "cpu": [ + "mips64el" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/linux-ppc64": { + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.27.2.tgz", + "integrity": "sha512-C92gnpey7tUQONqg1n6dKVbx3vphKtTHJaNG2Ok9lGwbZil6DrfyecMsp9CrmXGQJmZ7iiVXvvZH6Ml5hL6XdQ==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/linux-riscv64": { + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.27.2.tgz", + "integrity": "sha512-B5BOmojNtUyN8AXlK0QJyvjEZkWwy/FKvakkTDCziX95AowLZKR6aCDhG7LeF7uMCXEJqwa8Bejz5LTPYm8AvA==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/linux-s390x": { + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.27.2.tgz", + "integrity": "sha512-p4bm9+wsPwup5Z8f4EpfN63qNagQ47Ua2znaqGH6bqLlmJ4bx97Y9JdqxgGZ6Y8xVTixUnEkoKSHcpRlDnNr5w==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/linux-x64": { + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.27.2.tgz", + "integrity": "sha512-uwp2Tip5aPmH+NRUwTcfLb+W32WXjpFejTIOWZFw/v7/KnpCDKG66u4DLcurQpiYTiYwQ9B7KOeMJvLCu/OvbA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/netbsd-arm64": { + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.27.2.tgz", + "integrity": "sha512-Kj6DiBlwXrPsCRDeRvGAUb/LNrBASrfqAIok+xB0LxK8CHqxZ037viF13ugfsIpePH93mX7xfJp97cyDuTZ3cw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/netbsd-x64": { + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.27.2.tgz", + "integrity": "sha512-HwGDZ0VLVBY3Y+Nw0JexZy9o/nUAWq9MlV7cahpaXKW6TOzfVno3y3/M8Ga8u8Yr7GldLOov27xiCnqRZf0tCA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/openbsd-arm64": { + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.27.2.tgz", + "integrity": "sha512-DNIHH2BPQ5551A7oSHD0CKbwIA/Ox7+78/AWkbS5QoRzaqlev2uFayfSxq68EkonB+IKjiuxBFoV8ESJy8bOHA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/openbsd-x64": { + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.27.2.tgz", + "integrity": "sha512-/it7w9Nb7+0KFIzjalNJVR5bOzA9Vay+yIPLVHfIQYG/j+j9VTH84aNB8ExGKPU4AzfaEvN9/V4HV+F+vo8OEg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/openharmony-arm64": { + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.27.2.tgz", + "integrity": "sha512-LRBbCmiU51IXfeXk59csuX/aSaToeG7w48nMwA6049Y4J4+VbWALAuXcs+qcD04rHDuSCSRKdmY63sruDS5qag==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/sunos-x64": { + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.27.2.tgz", + "integrity": "sha512-kMtx1yqJHTmqaqHPAzKCAkDaKsffmXkPHThSfRwZGyuqyIeBvf08KSsYXl+abf5HDAPMJIPnbBfXvP2ZC2TfHg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/win32-arm64": { + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.27.2.tgz", + "integrity": "sha512-Yaf78O/B3Kkh+nKABUF++bvJv5Ijoy9AN1ww904rOXZFLWVc5OLOfL56W+C8F9xn5JQZa3UX6m+IktJnIb1Jjg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/win32-ia32": { + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.27.2.tgz", + "integrity": "sha512-Iuws0kxo4yusk7sw70Xa2E2imZU5HoixzxfGCdxwBdhiDgt9vX9VUCBhqcwY7/uh//78A1hMkkROMJq9l27oLQ==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/win32-x64": { + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.27.2.tgz", + "integrity": "sha512-sRdU18mcKf7F+YgheI/zGf5alZatMUTKj/jNS6l744f9u3WFu4v7twcUI9vu4mknF4Y9aDlblIie0IM+5xxaqQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/esbuild": { + "version": "0.27.2", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.27.2.tgz", + "integrity": "sha512-HyNQImnsOC7X9PMNaCIeAm4ISCQXs5a5YasTXVliKv4uuBo1dKrG0A+uQS8M5eXjVMnLg3WgXaKvprHlFJQffw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=18" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.27.2", + "@esbuild/android-arm": "0.27.2", + "@esbuild/android-arm64": "0.27.2", + "@esbuild/android-x64": "0.27.2", + "@esbuild/darwin-arm64": "0.27.2", + "@esbuild/darwin-x64": "0.27.2", + "@esbuild/freebsd-arm64": "0.27.2", + "@esbuild/freebsd-x64": "0.27.2", + "@esbuild/linux-arm": "0.27.2", + "@esbuild/linux-arm64": "0.27.2", + "@esbuild/linux-ia32": "0.27.2", + "@esbuild/linux-loong64": "0.27.2", + "@esbuild/linux-mips64el": "0.27.2", + "@esbuild/linux-ppc64": "0.27.2", + "@esbuild/linux-riscv64": "0.27.2", + "@esbuild/linux-s390x": "0.27.2", + "@esbuild/linux-x64": "0.27.2", + "@esbuild/netbsd-arm64": "0.27.2", + "@esbuild/netbsd-x64": "0.27.2", + "@esbuild/openbsd-arm64": "0.27.2", + "@esbuild/openbsd-x64": "0.27.2", + "@esbuild/openharmony-arm64": "0.27.2", + "@esbuild/sunos-x64": "0.27.2", + "@esbuild/win32-arm64": "0.27.2", + "@esbuild/win32-ia32": "0.27.2", + "@esbuild/win32-x64": "0.27.2" + } + }, + "node_modules/type-is": { + "version": "1.6.18", + "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.18.tgz", + "integrity": "sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==", + "license": "MIT", + "dependencies": { + "media-typer": "0.3.0", + "mime-types": "~2.1.24" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/typescript": { + "version": "5.9.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz", + "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + }, + "node_modules/undici-types": { + "version": "6.21.0", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz", + "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==", + "license": "MIT" + }, + "node_modules/unpipe": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz", + "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/utils-merge": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz", + "integrity": "sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==", + "license": "MIT", + "engines": { + "node": ">= 0.4.0" + } + }, + "node_modules/vary": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz", + "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/vite": { + "version": "6.4.1", + "resolved": "https://registry.npmjs.org/vite/-/vite-6.4.1.tgz", + "integrity": "sha512-+Oxm7q9hDoLMyJOYfUYBuHQo+dkAloi33apOPP56pzj+vsdJDzr+j1NISE5pyaAuKL4A3UD34qd0lx5+kfKp2g==", + "dev": true, + "license": "MIT", + "dependencies": { + "esbuild": "^0.25.0", + "fdir": "^6.4.4", + "picomatch": "^4.0.2", + "postcss": "^8.5.3", + "rollup": "^4.34.9", + "tinyglobby": "^0.2.13" + }, + "bin": { + "vite": "bin/vite.js" + }, + "engines": { + "node": "^18.0.0 || ^20.0.0 || >=22.0.0" + }, + "funding": { + "url": "https://github.com/vitejs/vite?sponsor=1" + }, + "optionalDependencies": { + "fsevents": "~2.3.3" + }, + "peerDependencies": { + "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0", + "jiti": ">=1.21.0", + "less": "*", + "lightningcss": "^1.21.0", + "sass": "*", + "sass-embedded": "*", + "stylus": "*", + "sugarss": "*", + "terser": "^5.16.0", + "tsx": "^4.8.1", + "yaml": "^2.4.2" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + }, + "jiti": { + "optional": true + }, + "less": { + "optional": true + }, + "lightningcss": { + "optional": true + }, + "sass": { + "optional": true + }, + "sass-embedded": { + "optional": true + }, + "stylus": { + "optional": true + }, + "sugarss": { + "optional": true + }, + "terser": { + "optional": true + }, + "tsx": { + "optional": true + }, + "yaml": { + "optional": true + } + } + }, + "node_modules/vite-node": { + "version": "2.1.9", + "resolved": "https://registry.npmjs.org/vite-node/-/vite-node-2.1.9.tgz", + "integrity": "sha512-AM9aQ/IPrW/6ENLQg3AGY4K1N2TGZdR5e4gu/MmmR2xR3Ll1+dib+nook92g4TV3PXVyeyxdWwtaCAiUL0hMxA==", + "dev": true, + "license": "MIT", + "dependencies": { + "cac": "^6.7.14", + "debug": "^4.3.7", + "es-module-lexer": "^1.5.4", + "pathe": "^1.1.2", + "vite": "^5.0.0" + }, + "bin": { + "vite-node": "vite-node.mjs" + }, + "engines": { + "node": "^18.0.0 || >=20.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + } + }, + "node_modules/vite-node/node_modules/@esbuild/aix-ppc64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz", + "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "aix" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite-node/node_modules/@esbuild/android-arm": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.5.tgz", + "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite-node/node_modules/@esbuild/android-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz", + "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite-node/node_modules/@esbuild/android-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.5.tgz", + "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite-node/node_modules/@esbuild/darwin-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz", + "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite-node/node_modules/@esbuild/darwin-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz", + "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite-node/node_modules/@esbuild/freebsd-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz", + "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite-node/node_modules/@esbuild/freebsd-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz", + "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite-node/node_modules/@esbuild/linux-arm": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz", + "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite-node/node_modules/@esbuild/linux-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz", + "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite-node/node_modules/@esbuild/linux-ia32": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz", + "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite-node/node_modules/@esbuild/linux-loong64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz", + "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite-node/node_modules/@esbuild/linux-mips64el": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz", + "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==", + "cpu": [ + "mips64el" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite-node/node_modules/@esbuild/linux-ppc64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz", + "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite-node/node_modules/@esbuild/linux-riscv64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz", + "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite-node/node_modules/@esbuild/linux-s390x": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz", + "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite-node/node_modules/@esbuild/linux-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz", + "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite-node/node_modules/@esbuild/netbsd-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz", + "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite-node/node_modules/@esbuild/openbsd-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz", + "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite-node/node_modules/@esbuild/sunos-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz", + "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite-node/node_modules/@esbuild/win32-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz", + "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite-node/node_modules/@esbuild/win32-ia32": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz", + "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite-node/node_modules/@esbuild/win32-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz", + "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite-node/node_modules/esbuild": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz", + "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=12" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.21.5", + "@esbuild/android-arm": "0.21.5", + "@esbuild/android-arm64": "0.21.5", + "@esbuild/android-x64": "0.21.5", + "@esbuild/darwin-arm64": "0.21.5", + "@esbuild/darwin-x64": "0.21.5", + "@esbuild/freebsd-arm64": "0.21.5", + "@esbuild/freebsd-x64": "0.21.5", + "@esbuild/linux-arm": "0.21.5", + "@esbuild/linux-arm64": "0.21.5", + "@esbuild/linux-ia32": "0.21.5", + "@esbuild/linux-loong64": "0.21.5", + "@esbuild/linux-mips64el": "0.21.5", + "@esbuild/linux-ppc64": "0.21.5", + "@esbuild/linux-riscv64": "0.21.5", + "@esbuild/linux-s390x": "0.21.5", + "@esbuild/linux-x64": "0.21.5", + "@esbuild/netbsd-x64": "0.21.5", + "@esbuild/openbsd-x64": "0.21.5", + "@esbuild/sunos-x64": "0.21.5", + "@esbuild/win32-arm64": "0.21.5", + "@esbuild/win32-ia32": "0.21.5", + "@esbuild/win32-x64": "0.21.5" + } + }, + "node_modules/vite-node/node_modules/vite": { + "version": "5.4.21", + "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.21.tgz", + "integrity": "sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==", + "dev": true, + "license": "MIT", + "dependencies": { + "esbuild": "^0.21.3", + "postcss": "^8.4.43", + "rollup": "^4.20.0" + }, + "bin": { + "vite": "bin/vite.js" + }, + "engines": { + "node": "^18.0.0 || >=20.0.0" + }, + "funding": { + "url": "https://github.com/vitejs/vite?sponsor=1" + }, + "optionalDependencies": { + "fsevents": "~2.3.3" + }, + "peerDependencies": { + "@types/node": "^18.0.0 || >=20.0.0", + "less": "*", + "lightningcss": "^1.21.0", + "sass": "*", + "sass-embedded": "*", + "stylus": "*", + "sugarss": "*", + "terser": "^5.4.0" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + }, + "less": { + "optional": true + }, + "lightningcss": { + "optional": true + }, + "sass": { + "optional": true + }, + "sass-embedded": { + "optional": true + }, + "stylus": { + "optional": true + }, + "sugarss": { + "optional": true + }, + "terser": { + "optional": true + } + } + }, + "node_modules/vitest": { + "version": "2.1.9", + "resolved": "https://registry.npmjs.org/vitest/-/vitest-2.1.9.tgz", + "integrity": "sha512-MSmPM9REYqDGBI8439mA4mWhV5sKmDlBKWIYbA3lRb2PTHACE0mgKwA8yQ2xq9vxDTuk4iPrECBAEW2aoFXY0Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/expect": "2.1.9", + "@vitest/mocker": "2.1.9", + "@vitest/pretty-format": "^2.1.9", + "@vitest/runner": "2.1.9", + "@vitest/snapshot": "2.1.9", + "@vitest/spy": "2.1.9", + "@vitest/utils": "2.1.9", + "chai": "^5.1.2", + "debug": "^4.3.7", + "expect-type": "^1.1.0", + "magic-string": "^0.30.12", + "pathe": "^1.1.2", + "std-env": "^3.8.0", + "tinybench": "^2.9.0", + "tinyexec": "^0.3.1", + "tinypool": "^1.0.1", + "tinyrainbow": "^1.2.0", + "vite": "^5.0.0", + "vite-node": "2.1.9", + "why-is-node-running": "^2.3.0" + }, + "bin": { + "vitest": "vitest.mjs" + }, + "engines": { + "node": "^18.0.0 || >=20.0.0" + }, + "funding": { + "url": "https://opencollective.com/vitest" + }, + "peerDependencies": { + "@edge-runtime/vm": "*", + "@types/node": "^18.0.0 || >=20.0.0", + "@vitest/browser": "2.1.9", + "@vitest/ui": "2.1.9", + "happy-dom": "*", + "jsdom": "*" + }, + "peerDependenciesMeta": { + "@edge-runtime/vm": { + "optional": true + }, + "@types/node": { + "optional": true + }, + "@vitest/browser": { + "optional": true + }, + "@vitest/ui": { + "optional": true + }, + "happy-dom": { + "optional": true + }, + "jsdom": { + "optional": true + } + } + }, + "node_modules/vitest/node_modules/@esbuild/aix-ppc64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz", + "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "aix" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vitest/node_modules/@esbuild/android-arm": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.5.tgz", + "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vitest/node_modules/@esbuild/android-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz", + "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vitest/node_modules/@esbuild/android-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.5.tgz", + "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vitest/node_modules/@esbuild/darwin-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz", + "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vitest/node_modules/@esbuild/darwin-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz", + "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vitest/node_modules/@esbuild/freebsd-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz", + "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vitest/node_modules/@esbuild/freebsd-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz", + "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vitest/node_modules/@esbuild/linux-arm": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz", + "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vitest/node_modules/@esbuild/linux-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz", + "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vitest/node_modules/@esbuild/linux-ia32": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz", + "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vitest/node_modules/@esbuild/linux-loong64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz", + "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vitest/node_modules/@esbuild/linux-mips64el": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz", + "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==", + "cpu": [ + "mips64el" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vitest/node_modules/@esbuild/linux-ppc64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz", + "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vitest/node_modules/@esbuild/linux-riscv64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz", + "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vitest/node_modules/@esbuild/linux-s390x": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz", + "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vitest/node_modules/@esbuild/linux-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz", + "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vitest/node_modules/@esbuild/netbsd-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz", + "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vitest/node_modules/@esbuild/openbsd-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz", + "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vitest/node_modules/@esbuild/sunos-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz", + "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vitest/node_modules/@esbuild/win32-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz", + "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vitest/node_modules/@esbuild/win32-ia32": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz", + "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vitest/node_modules/@esbuild/win32-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz", + "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vitest/node_modules/@vitest/mocker": { + "version": "2.1.9", + "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-2.1.9.tgz", + "integrity": "sha512-tVL6uJgoUdi6icpxmdrn5YNo3g3Dxv+IHJBr0GXHaEdTcw3F+cPKnsXFhli6nO+f/6SDKPHEK1UN+k+TQv0Ehg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vitest/spy": "2.1.9", + "estree-walker": "^3.0.3", + "magic-string": "^0.30.12" + }, + "funding": { + "url": "https://opencollective.com/vitest" + }, + "peerDependencies": { + "msw": "^2.4.9", + "vite": "^5.0.0" + }, + "peerDependenciesMeta": { + "msw": { + "optional": true + }, + "vite": { + "optional": true + } + } + }, + "node_modules/vitest/node_modules/esbuild": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz", + "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=12" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.21.5", + "@esbuild/android-arm": "0.21.5", + "@esbuild/android-arm64": "0.21.5", + "@esbuild/android-x64": "0.21.5", + "@esbuild/darwin-arm64": "0.21.5", + "@esbuild/darwin-x64": "0.21.5", + "@esbuild/freebsd-arm64": "0.21.5", + "@esbuild/freebsd-x64": "0.21.5", + "@esbuild/linux-arm": "0.21.5", + "@esbuild/linux-arm64": "0.21.5", + "@esbuild/linux-ia32": "0.21.5", + "@esbuild/linux-loong64": "0.21.5", + "@esbuild/linux-mips64el": "0.21.5", + "@esbuild/linux-ppc64": "0.21.5", + "@esbuild/linux-riscv64": "0.21.5", + "@esbuild/linux-s390x": "0.21.5", + "@esbuild/linux-x64": "0.21.5", + "@esbuild/netbsd-x64": "0.21.5", + "@esbuild/openbsd-x64": "0.21.5", + "@esbuild/sunos-x64": "0.21.5", + "@esbuild/win32-arm64": "0.21.5", + "@esbuild/win32-ia32": "0.21.5", + "@esbuild/win32-x64": "0.21.5" + } + }, + "node_modules/vitest/node_modules/vite": { + "version": "5.4.21", + "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.21.tgz", + "integrity": "sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==", + "dev": true, + "license": "MIT", + "dependencies": { + "esbuild": "^0.21.3", + "postcss": "^8.4.43", + "rollup": "^4.20.0" + }, + "bin": { + "vite": "bin/vite.js" + }, + "engines": { + "node": "^18.0.0 || >=20.0.0" + }, + "funding": { + "url": "https://github.com/vitejs/vite?sponsor=1" + }, + "optionalDependencies": { + "fsevents": "~2.3.3" + }, + "peerDependencies": { + "@types/node": "^18.0.0 || >=20.0.0", + "less": "*", + "lightningcss": "^1.21.0", + "sass": "*", + "sass-embedded": "*", + "stylus": "*", + "sugarss": "*", + "terser": "^5.4.0" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + }, + "less": { + "optional": true + }, + "lightningcss": { + "optional": true + }, + "sass": { + "optional": true + }, + "sass-embedded": { + "optional": true + }, + "stylus": { + "optional": true + }, + "sugarss": { + "optional": true + }, + "terser": { + "optional": true + } + } + }, + "node_modules/web-streams-polyfill": { + "version": "4.0.0-beta.3", + "resolved": "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-4.0.0-beta.3.tgz", + "integrity": "sha512-QW95TCTaHmsYfHDybGMwO5IJIM93I/6vTRk+daHTWFPhwh+C8Cg7j7XyKrwrj8Ib6vYXe0ocYNrmzY4xAAN6ug==", + "license": "MIT", + "engines": { + "node": ">= 14" + } + }, + "node_modules/webidl-conversions": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz", + "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==", + "license": "BSD-2-Clause" + }, + "node_modules/whatwg-url": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz", + "integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==", + "license": "MIT", + "dependencies": { + "tr46": "~0.0.3", + "webidl-conversions": "^3.0.0" + } + }, + "node_modules/why-is-node-running": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz", + "integrity": "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==", + "dev": true, + "license": "MIT", + "dependencies": { + "siginfo": "^2.0.0", + "stackback": "0.0.2" + }, + "bin": { + "why-is-node-running": "cli.js" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/ws": { + "version": "8.19.0", + "resolved": "https://registry.npmjs.org/ws/-/ws-8.19.0.tgz", + "integrity": "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==", + "license": "MIT", + "optional": true, + "peer": true, + "engines": { + "node": ">=10.0.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": ">=5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } + } + } + } +} diff --git a/typescript/explain-this-tx-example/package.json b/typescript/explain-this-tx-example/package.json new file mode 100644 index 0000000..ed41ac1 --- /dev/null +++ b/typescript/explain-this-tx-example/package.json @@ -0,0 +1,31 @@ +{ + "name": "explain-this-tx-example", + "version": "1.0.0", + "description": "Transaction explanation tool for BNB Smart Chain (BSC) - decode and explain what any transaction does", + "type": "module", + "scripts": { + "dev": "vite", + "start": "vite build && npx tsx server.ts", + "build": "vite build", + "preview": "vite preview", + "server": "npx tsx server.ts", + "test": "vitest run" + }, + "engines": { + "node": ">=18" + }, + "dependencies": { + "ethers": "^6.13.0", + "express": "^4.21.0", + "dotenv": "^16.4.5", + "openai": "^4.73.0" + }, + "devDependencies": { + "@types/express": "^4.17.21", + "@types/node": "^22.9.0", + "tsx": "^4.19.2", + "typescript": "^5.6.3", + "vite": "^6.0.0", + "vitest": "^2.1.4" + } +} diff --git a/typescript/explain-this-tx-example/server.ts b/typescript/explain-this-tx-example/server.ts new file mode 100644 index 0000000..2b6dbdc --- /dev/null +++ b/typescript/explain-this-tx-example/server.ts @@ -0,0 +1,124 @@ +/** + * Transaction Explainer — Express server. + * Serves SPA and /api/explain. Optionally enhances explanations via OpenAI when OPENAI_API_KEY is set. + */ + +import "dotenv/config"; +import express from "express"; +import { readFileSync } from "fs"; +import { join, dirname } from "path"; +import { fileURLToPath } from "url"; +import { fetchTransaction, getExplorerUrl, type TxExplanation } from "./app.js"; +import OpenAI from "openai"; + +const __dirname = dirname(fileURLToPath(import.meta.url)); +const DIST = join(__dirname, "dist"); + +const PORT = Number(process.env.PORT) || 3000; +const RPC_URL = + process.env.BSC_RPC_URL || + process.env.VITE_BSC_RPC_URL || + "https://bsc-dataseed.bnbchain.org"; +const OPENAI_API_KEY = (process.env.OPENAI_API_KEY ?? "").trim(); + +const openai = OPENAI_API_KEY ? new OpenAI({ apiKey: OPENAI_API_KEY }) : null; + +function buildSummary(ex: TxExplanation): string { + const parts: string[] = [ + `Hash: ${ex.hash}`, + `From: ${ex.from}`, + `To: ${ex.to ?? "Contract Creation"}`, + `Value: ${ex.value} BNB`, + `Status: ${ex.status}`, + `Type: ${ex.isContractCreation ? "Contract Creation" : ex.isContractCall ? "Contract Call" : "Transfer"}`, + ]; + if (ex.functionName) parts.push(`Function: ${ex.functionName}`); + if (ex.gasUsed) parts.push(`Gas used: ${ex.gasUsed}`); + parts.push(`\nCurrent explanation: ${ex.explanation}`); + return parts.join("\n"); +} + +async function enhanceWithOpenAI(ex: TxExplanation): Promise { + if (!openai) return ex.explanation; + try { + const summary = buildSummary(ex); + const completion = await openai.chat.completions.create({ + model: "gpt-4o-mini", + messages: [ + { + role: "system", + content: + "You are a blockchain analyst. Explain BNB Smart Chain (BSC) transactions clearly and concisely for a general audience. Use 2–4 short sentences. Focus on what the transaction does, not raw data.", + }, + { + role: "user", + content: `Explain this BSC transaction:\n\n${summary}`, + }, + ], + max_tokens: 300, + }); + const text = completion.choices[0]?.message?.content?.trim(); + return text && text.length > 0 ? text : ex.explanation; + } catch (e) { + console.warn("OpenAI enhance failed, using default:", e); + return ex.explanation; + } +} + +const app = express(); +app.use(express.json()); + +app.post("/api/explain", async (req, res) => { + const txHash = (req.body?.txHash as string)?.trim(); + if (!txHash) { + res.status(400).json({ error: "Missing txHash in request body" }); + return; + } + try { + const explanation = await fetchTransaction(txHash, RPC_URL); + const enhanced = await enhanceWithOpenAI(explanation); + res.json({ + ...explanation, + explanation: enhanced, + explorerUrl: getExplorerUrl(txHash), + }); + } catch (e) { + const msg = e instanceof Error ? e.message : "Failed to fetch transaction"; + res.status(500).json({ error: msg }); + } +}); + +app.use(express.static(DIST)); +app.get("*", (_req, res) => { + try { + res.setHeader("Content-Type", "text/html; charset=utf-8"); + res.send(readFileSync(join(DIST, "index.html"), "utf-8")); + } catch { + res.status(404).send("Not found. Run npm run build first."); + } +}); + +function tryListen(port: number): void { + const server = app.listen(port, () => { + console.log(`Transaction Explainer running at http://localhost:${port}`); + if (OPENAI_API_KEY) { + console.log("OpenAI API key set — explanations will be enhanced with LLM."); + } else { + console.log("No OPENAI_API_KEY — using default rule-based explanations."); + } + }); + server.on("error", (err: NodeJS.ErrnoException) => { + server.close(); + if (err.code === "EADDRINUSE" && port < PORT + 5) { + const next = port + 1; + console.warn(`Port ${port} in use, trying ${next}...`); + tryListen(next); + } else { + console.error(err.code === "EADDRINUSE" + ? `Port ${port} in use. Set PORT in .env or stop the other process.` + : err); + process.exit(1); + } + }); +} +tryListen(PORT); diff --git a/typescript/explain-this-tx-example/tsconfig.json b/typescript/explain-this-tx-example/tsconfig.json new file mode 100644 index 0000000..e17e60a --- /dev/null +++ b/typescript/explain-this-tx-example/tsconfig.json @@ -0,0 +1,19 @@ +{ + "compilerOptions": { + "target": "ES2022", + "module": "ESNext", + "moduleResolution": "bundler", + "lib": ["ES2022", "DOM", "DOM.Iterable"], + "outDir": "dist", + "rootDir": ".", + "strict": true, + "esModuleInterop": true, + "skipLibCheck": true, + "resolveJsonModule": true, + "isolatedModules": true, + "noEmit": true, + "types": ["node"] + }, + "include": ["*.ts"], + "exclude": ["node_modules", "dist"] +} diff --git a/typescript/explain-this-tx-example/vite.config.ts b/typescript/explain-this-tx-example/vite.config.ts new file mode 100644 index 0000000..cbf6642 --- /dev/null +++ b/typescript/explain-this-tx-example/vite.config.ts @@ -0,0 +1,14 @@ +import { defineConfig } from "vite"; + +export default defineConfig({ + root: ".", + build: { + outDir: "dist", + rollupOptions: { + input: "index.html", + }, + }, + resolve: { + alias: {}, + }, +}); diff --git a/typescript/explain-this-tx-example/vitest.config.ts b/typescript/explain-this-tx-example/vitest.config.ts new file mode 100644 index 0000000..ebf4c9b --- /dev/null +++ b/typescript/explain-this-tx-example/vitest.config.ts @@ -0,0 +1,9 @@ +import { defineConfig } from "vitest/config"; + +export default defineConfig({ + test: { + environment: "node", + globals: true, + include: ["*.test.ts"], + }, +});