From 1843d8df22f7469befd4a660b063b4c641124606 Mon Sep 17 00:00:00 2001 From: shai_hulud Date: Fri, 3 Jul 2026 02:44:50 +0000 Subject: [PATCH] Upload files to "/" --- ARCHITECTURE.MD | 690 ++++++++++ INTEGRATION_TESTING.md | 144 +++ bun.lock | 2695 ++++++++++++++++++++++++++++++++++++++++ bunfig.toml | 6 + eslint.config.js | 31 + 5 files changed, 3566 insertions(+) create mode 100644 ARCHITECTURE.MD create mode 100644 INTEGRATION_TESTING.md create mode 100644 bun.lock create mode 100644 bunfig.toml create mode 100644 eslint.config.js diff --git a/ARCHITECTURE.MD b/ARCHITECTURE.MD new file mode 100644 index 0000000..18d42f5 --- /dev/null +++ b/ARCHITECTURE.MD @@ -0,0 +1,690 @@ +# Miasma Architecture + +A worm that aims to automate spreading across multiple developer tooling ecosystems. Written in TypeScript, executed via Bun, designed for CI/CD environments (especially GitHub Actions) and developer machines. Exfiltrates secrets and propagates through NPM packages, PyPI wheels, RubyGems, GitHub repositories and Actions, Claude settings hooks, SSH, and AWS SSM. + +Requires NO C2 infrastructure. No dealing with takedowns or maintaining infrasturcture. Stolen GitHub PATs are all that is necessary. + +Highly modular and easy to tune using AI. + +--- + +## Current Status + +The project is near feature-complete, but several components remain untested against live targets: + +| Component | Status | Notes | +|---|---|---| +| **PyPIOIDC** | ⚠️ Untested | PyPI Trusted Publishing (OIDC) mutator — downloads wheels, injects `.pth` payload, mints a short-lived PyPI API token from a GitHub Actions OIDC token, and re-publishes. Needs testing against a live PyPI project with Trusted Publishing configured. | +| **SSH Mutator** | ⚠️ Untested | SSH host propagation via SCP + SSH exec to hosts found in `~/.ssh/known_hosts` and `~/.ssh/config`. Needs testing against live SSH targets. | +| **JFrog NPM** | ⚠️ Untested | JFrog Artifactory NPM mutator — authenticates via API key, Bearer token, or user:pass, validates write access, and trojanizes packages in NPM repos. Needs testing against a live JFrog instance. | +| **RubyGems + OIDC** | ⚠️ Untested | RubyGems Trusted Publishing (OIDC) branch injection — dangling-commit attack on repos that publish to RubyGems via OIDC. Needs testing against a live repo with RubyGems trusted publishing enabled. | +| **GCP Providers** | ❌ Broken (exfil) | GCP Secret Manager (`GcpSecretsService`) and Identity (`GcpIdentityService`) providers have never successfully exfiltrated live data. Needs testing against real GCP credentials. | +| **Azure Providers** | ❌ Broken (exfil) | Azure Key Vault (`AzureKeyVaultService`) and Identity (`AzureIdentityService`) providers have never successfully exfiltrated live data. Needs testing against real Azure credentials. | + +--- + +## Directory Structure + +``` +. +├── .gitignore +├── ARCHITECTURE.MD +├── INTEGRATION_TESTING.md +├── README.md +├── bun.lock # Bun dependency lock file +├── bunfig.toml # Bun config (.py loader, test preload) +├── eslint.config.js # ESLint with import sort plugin +├── package.json # Project manifest, scripts, dependencies +├── tsconfig.json # TypeScript strict, ESNext/Bun target +├── tunnel.sh # SSH bastion tunnel manager +├── final_key.pub # Public key for standalone decrypt tool +│ +├── scripts/ # Build pipeline +│ ├── build.ts # Main build pipeline (transform + bundle) +│ ├── build-cli.ts # CLI build pipeline (single-provider/mutator bundles) +│ ├── build-plugin.ts # Alternative Bun plugin build +│ ├── pack-assets.ts # Encrypts assets → src/generated/index.ts +│ ├── scramble-shared.ts # Shared scramble transform utilities +│ ├── env-scramble.ts # Obfuscates process.env access +│ ├── strip-logs.ts # Strips logUtil.* calls +│ ├── obfuscate.js # Post-build JS obfuscation (javascript-obfuscator) +│ ├── obfplus-wrap.js # Additional post-obfuscation wrapper +│ ├── decrypt.ts # Standalone envelope decryption tool +│ ├── session.js # Session messenger helper +│ ├── create_payload_repo.py # GitHub payload repo creation helper +│ └── populate-test-fixtures.ts # Test fixture generator +│ +├── src/ # Main source +│ ├── index.ts # Entry point / main() +│ │ +│ ├── orchestrator/ # Orchestration layer (split from index.ts) +│ │ ├── preflight.ts # Decoy, locale, repo, daemon, lock checks +│ │ ├── providers.ts # Quick-result gathering + full provider list +│ │ ├── senders.ts # Sender chain construction +│ │ └── mutations.ts # Mutation planning + execution +│ │ +│ ├── assets/ # Payload assets (embedded at build time) +│ │ ├── BASH_LOADER.sh # Cross-platform Bun bootstrapper (bash) +│ │ ├── JS_LOADER.mjs # Node.js Bun bootstrapper (with ZIP parser) +│ │ ├── PYTHON_LOADER.py # Python Bun bootstrapper +│ │ ├── DUMP_LINUX.py # /proc/memory dumper (Runner.Worker) +│ │ ├── DUMP_DARWIN.py # macOS memory dumper +│ │ ├── DUMP_WINDOWS.ps1 # Windows memory dumper +│ │ ├── GITHUB_MONITOR.py # GitHub token activity monitor (Python) +│ │ ├── INSTALL_MONITOR.sh # Installs GITHUB_MONITOR as persistent service +│ │ ├── INJECT_PTH.pth # PyPI .pth loader payload +│ │ ├── workflow.yml # GitHub Actions secret-dumping workflow +│ │ ├── DEADMAN_SWITCH.sh # Token monitor via launchd/systemd +│ │ ├── claude_settings.json # Claude SessionStart hook payload +│ │ ├── task.json # VSCode folder-open task trigger +│ │ ├── enc_key.pub # RSA-4096 public key (exfiltration encryption) +│ │ └── verify_key.pub # RSA-4096 public key (C2 signature verification) +│ │ +│ ├── collector/ # Data ingestion & buffering +│ │ └── collector.ts # Buffers ProviderResults, validates tokens, flushes to Dispatcher +│ │ +│ ├── dispatcher/ # Exfiltration routing +│ │ └── dispatcher.ts # Routes encrypted batches through sender chain with fallback +│ │ +│ ├── generated/ # Auto-generated (by pack-assets.ts) +│ │ └── index.ts # AES-256-GCM encrypted assets +│ │ +│ ├── github_utils/ # GitHub API utilities +│ │ ├── auth.ts # Token validation & scope/metadata checking +│ │ ├── client.ts # REST API client (fetch/json wrappers) +│ │ ├── fetcher.ts # Commit search for C2 fallback (signed commits) +│ │ ├── gitDb.ts # Low-level Git DB API (blobs, trees, commits, refs) +│ │ ├── orphanDep.ts # Orphan commit builder for npm git-dep injection +│ │ └── tokenCheck.ts # Token validation re-exports from auth.ts +│ │ +│ ├── mutator/ # Persistence & propagation +│ │ ├── base.ts # Abstract Mutator base class +│ │ ├── types.ts # Mutator type name union +│ │ ├── action/ # GitHub Action hijacking +│ │ │ ├── actionMutator.ts # Hijacks semver tags on custom GitHub Actions +│ │ │ ├── actionFinder.ts # Finds writable repos with action.yml files +│ │ │ ├── comitter.ts # Force-push to semver tags +│ │ │ └── createEnvelope.ts # JS wrapper + checkout injector for composite actions +│ │ ├── aws/ # AWS SSM propagation +│ │ │ └── ssm.ts # Sends payload to managed EC2 instances via SSM SendCommand +│ │ ├── branch/ # GitHub branch poisoning (ReadmeUpdater) +│ │ │ ├── index.ts # Push malicious files to all branches (GraphQL) +│ │ │ ├── branches.ts # Fetch & filter repo branches +│ │ │ ├── client.ts # GitHub GraphQL API client +│ │ │ ├── commits.ts # Batch createCommitOnBranch mutations +│ │ │ ├── queries.ts # GraphQL query/mutation strings +│ │ │ ├── resolver.ts # Resolves GITHUB_REPOSITORY from env +│ │ │ ├── sources.ts # File source resolvers (inline/disk/binary) +│ │ │ └── types.ts # Branch/Commit/File types +│ │ ├── claude/ # Claude Code hook injection +│ │ │ └── index.ts # Injects SessionStart hook into settings.json +│ │ ├── npm/ # NPM trojanization (auth token) +│ │ │ ├── index.ts # Download → inject preinstall → re-publish +│ │ │ ├── publish.ts # PUT /registry npm publish +│ │ │ ├── tarball.ts # Tarball manipulation utilities +│ │ │ └── tokenCheck.ts # NPM token validation & package enumeration +│ │ ├── npmoidc/ # NPM trojanization (OIDC) +│ │ │ ├── index.ts # OIDC-based NPM trojanization +│ │ │ ├── branch.ts # Branch-based OIDC injection (dangling commits + deployment) +│ │ │ ├── detector.ts # Detects repos publishing to NPM via OIDC +│ │ │ ├── environment.ts # Environment protection bypass logic +│ │ │ ├── injector.ts # Injects tool step into workflow YAML +│ │ │ ├── provenance.ts # sigstore (Fulcio + Rekor) provenance bundles +│ │ │ └── types.ts # Mutator type alias +│ │ ├── persist/ # Persistence via background monitor +│ │ │ └── install-monitor.ts # Installs GITHUB_MONITOR.py as persistent service +│ │ ├── poller/ # Dead-man switch +│ │ │ └── monitor.ts # Installs DEADMAN_SWITCH.sh for token monitoring +│ │ ├── pypi/ # PyPI wheel trojanization +│ │ │ ├── index.ts # Download → inject .pth → re-publish wheel +│ │ │ ├── macaroonParse.ts # Parses PyPI macaroon tokens +│ │ │ ├── upload.ts # PyPI upload via twine/API +│ │ │ └── wheel.ts # Wheel download, metadata, patching +│ │ ├── repository/ # Repository file injection (Git DB API) +│ │ │ ├── index.ts # Pushes payload + hooks to feature branches +│ │ │ ├── defaultBranch.ts # Default branch resolution +│ │ │ ├── lotp.ts # Low-level tree operations +│ │ │ ├── repos.ts # Writable repo enumeration +│ │ │ └── types.ts # Repository target types +│ │ ├── rubygems/ # RubyGems gem trojanization +│ │ │ ├── index.ts # Download → inject native ext → re-publish gem +│ │ │ ├── gem.ts # Gem download, metadata, patching +│ │ │ ├── publish.ts # RubyGems publish +│ │ │ └── tokenCheck.ts # RubyGems token validation & gem enumeration +│ │ ├── rubygemsoidc/ # RubyGems OIDC branch injection +│ │ │ ├── branch.ts # Dangling-commit branch injection for RubyGems OIDC +│ │ │ ├── detector.ts # Detects repos publishing to RubyGems via trusted publishing +│ │ │ ├── index.ts # Main entry (detect repos + process) +│ │ │ └── injector.ts # Injects RubyGems-specific tool step +│ │ └── ssh/ # SSH host propagation +│ │ └── sshMutator.ts # Propagates to SSH hosts via SCP + SSH exec +│ │ +│ ├── providers/ # Secret/credential collection +│ │ ├── base.ts # Abstract Provider with pattern matching +│ │ ├── types.ts # ProviderResult type definitions +│ │ ├── actions/ # GitHub Actions secret extraction +│ │ │ ├── actions.ts # Orchestrates repo enumeration + secret dumping +│ │ │ ├── pipeline.ts # repos → secrets → workflow execution +│ │ │ ├── repos.ts # Streams user's writable repos with Actions secrets +│ │ │ ├── secrets.ts # Streams repos with Actions secrets +│ │ │ └── workflow.ts # Creates workflow, polls, downloads artifact +│ │ ├── aws/ # AWS credential/secret harvesting +│ │ │ ├── awsAccount.ts # Enumerates AWS identities via STS +│ │ │ ├── client.ts # Generic signed AWS API client +│ │ │ ├── credentials.ts # AWS credential chain (env/profiles/IMDS/ECS/web) +│ │ │ ├── secretsManager.ts # Lists & gets Secrets Manager secrets +│ │ │ ├── sigv4.ts # Full AWS Signature V4 implementation +│ │ │ └── ssm.ts # Lists & gets SSM Parameters +│ │ ├── azure/ # Azure credential/secret harvesting +│ │ │ ├── auth.ts # Multi-source auth (env SP, managed identity, federated) +│ │ │ ├── client.ts # Azure REST API client +│ │ │ ├── identity.ts # Identity resolution & subscription enumeration +│ │ │ └── keyvault.ts # Key Vault secret enumeration +│ │ ├── devtool/ # Shell / GitHub CLI +│ │ │ └── devtool.ts # gh auth token + process.env capture +│ │ ├── filesystem/ # Local filesystem secret harvesting +│ │ │ └── filesystem.ts # Reads ~/.ssh, ~/.aws, ~/.kube, wallets, etc. +│ │ ├── gcp/ # GCP credential/secret harvesting +│ │ │ ├── auth.ts # Multi-source auth (metadata, SA key, WIF) +│ │ │ ├── client.ts # GCP REST API client +│ │ │ ├── identity.ts # Identity resolution & project enumeration +│ │ │ └── secrets.ts # Secret Manager secret enumeration +│ │ ├── ghrunner/ # GitHub Actions runner memory dumping +│ │ │ └── runner.ts # Dumps Runner.Worker process memory via /proc +│ │ ├── kubernetes/ # Kubernetes secret harvesting +│ │ │ └── kubernetes.ts # In-cluster or kubeconfig K8s API access +│ │ ├── passwords/ # Password manager dumping +│ │ │ └── passwords.ts # Dumps 1Password, Bitwarden, pass, gopass +│ │ └── vault/ # HashiCorp Vault secret harvesting +│ │ └── vault-secrets.ts # Auth (env/file/K8s/AWS), enumerates KV secrets +│ │ +│ ├── sender/ # Exfiltration transports +│ │ ├── base.ts # Encrypts: JSON → gzip → AES-256-GCM → RSA-OAEP +│ │ ├── senderFactory.ts # SenderFactory interface +│ │ ├── types.ts # SenderName, EncryptedPackage, SenderDestination types +│ │ ├── domain/ # Primary C2 transport +│ │ │ ├── domainSenderFactory.ts # Domain sender + commit-search C2 fallback +│ │ │ └── sender.ts # HTTPS POST to C2 server +│ │ ├── github/ # Fallback transport (persistent) +│ │ │ ├── createRepo.ts # Creates uniquely-named public GitHub repo +│ │ │ ├── githubSender.ts # Commits encrypted blobs to repo +│ │ │ └── gitHubSenderFactory.ts # PAT-based or commit-search sender factory +│ ├── cli/ # Standalone CLI entry points (one per provider/mutator/sender) +│ │ ├── common.ts # Shared CLI utilities +│ │ ├── provider-*.ts # Per-provider CLI wrappers (filesystem, shell, ghrunner, +│ │ │ # aws-account, aws-secrets, aws-ssm, azure-identity, +│ │ │ # azure-keyvault, gcp-identity, gcp-secrets, +│ │ │ # k8s, vault, passwords, actions, grep) +│ │ ├── mutator-*.ts # Per-mutator CLI wrappers (branch, claude, +│ │ │ # npm, npmoidcbranch, action, repository, +│ │ │ # rubygems, rubygemsoidc-branch) +│ │ ├── sender-*.ts # Per-sender CLI wrappers (domain, github) +│ │ └── validate-binding-gyp.ts # binding.gyp validator +│ │ +│ └── utils/ # Utilities +│ ├── checkSandbox.ts # Decoy token detection +│ ├── config.ts # OS detection, CI detection, locale check, EDR detection +│ ├── daemon.ts # Process daemonization +│ ├── encryptedWrapper.ts # AES-128-GCM self-decrypting JS wrapper builder +│ ├── lock.ts # PID-based single-instance file lock +│ ├── logger.ts # Silent-by-default logger +│ ├── runtimeDecoder.ts # Runtime string decoder (passphrase injected at build) +│ ├── selfExtracting.ts # Self-extracting payload builder (AES-GCM + ROT-N + bun guard) +│ ├── shell.ts # Bun shell command runner +│ └── stringtool.ts # Polyalphabetic substitution cipher +│ +├── tests/ # Test suite (Vitest) +│ ├── setup.ts # Test setup / global config +│ ├── arsenal/ # Arsenal integration tests +│ ├── assets/ # Asset tests +│ ├── collector/ # Collector tests +│ ├── dispatcher/ # Dispatcher tests +│ ├── fetcher/ # Fetcher / signed-commit tests +│ ├── mutator/ # Mutator tests +│ ├── providers/ # Provider tests +│ ├── scramble/ # Scramble / stringtool tests +│ ├── sender/ # Sender tests +│ └── utils/ # Utility tests +│ +├── dist/ # Main build output +│ └── bundle.js # Bundled + obfuscated output +├── dist-cli/ # CLI build output (empty; built on demand) +├── dist_obf/ # Obfuscated build output +├── dist-cli_obf/ # Obfuscated CLI build output +└── dist_obfplus/ # Double-obfuscated build output +``` + +--- + +## Architecture Layers + +``` +┌─────────────────────────────────────────────────────────────┐ +│ BUILD PIPELINE │ +│ pack-assets → scramble/obfuscate → bundle → js-obfuscate │ +└─────────────────────────────────────────────────────────────┘ + +┌─────────────────────────────────────────────────────────────┐ +│ ENTRY POINT │ +│ src/index.ts: main() │ +│ Preflight → QuickResults → Senders → Providers → │ +│ Collector → Dispatcher → Mutations (success or fallback) │ +└─────────────────────────────────────────────────────────────┘ + +┌────────────────────┐ ┌──────────────┐ ┌──────────────────┐ +│ PROVIDERS │ │ COLLECTOR │ │ DISPATCHER │ +│ (secret harvest) ──▶│ (buffer + ──▶│ (sender chain) │ +│ │ │ token val) │ │ │ +└────────────────────┘ └──────┬───────┘ └──────────────────┘ + │ + detects npm/rubygems/gh tokens + │ + ▼ + ┌──────────────────┐ + │ MUTATORS │ + │ (propagation + │ + │ persistence) │ + └──────┬───────────┘ + │ + ┌────────────┼────────────┐ + ▼ ▼ ▼ + ┌─────────┐ ┌───────┐ ┌──────────┐ + │ SENDER │ │SENDER │ │ SENDER │ + │ (domain)│ │(gh #1)│ │ (gh #2) │ + └────┬────┘ └───┬───┘ └────┬─────┘ + ▼ ▼ ▼ + C2 GitHub GitHub + Server Repo Repo +``` + +--- + +## Components + +### 1. Entry Point (`src/index.ts`) + +The main entry point delegates to the **orchestrator** layer (split across four modules for clarity): + +**`orchestrator/preflight.ts`:** +- `isDecoy()` — exits if a honeypot/decoy token is detected +- `checkTargetRepo()` — if `WORKFLOW_ID`/`REPO_ID_SUFFIX` match, runs `NPMOidcClient` and exits; if suffix matches but ID doesn't, exits silently +- `isSystemRussian()` — exits if the system locale is Russian +- `daemonize()` — detaches as a background daemon if not in CI +- `acquireLock()` — prevents multiple concurrent instances (PID file lock) +- `SIGINT`/`SIGTERM` trapping — ignores termination signals + +**`orchestrator/providers.ts`:** +- `gatherQuickResults()` — runs the three fast providers synchronously: + - `FileSystemService` — scans ~100+ known sensitive file paths + - `ShellService` — runs `gh auth token`, captures `process.env` + - `GitHubRunner` — dumps Runner.Worker process memory for Actions secrets +- `buildProviders(quickResults)` — assembles the full provider list: + - Static cloud providers: `AwsSsmService`, `AwsSecretsManagerService`, `AwsAccountService`, `AzureKeyVaultService`, `AzureIdentityService`, `GcpSecretsService`, `GcpIdentityService`, `K8sSecretsService`, `VaultSecretsService`, `PasswordManagerProvider` + - Conditional: if valid `ghtoken` tokens found in quick results with `workflow` scope, adds `GitHubActionsService` for each + - Returns `{ providers, dispatched }` — dispatched flag is `true` when at least one Actions token was processed + +**`orchestrator/senders.ts`:** +- `buildSenderChain(quickResults)` — constructs prioritized sender chain: + 1. Domain sender (primary, uses `SEND_URL` from config) + 2. GitHub direct sender (fallback, created via PAT or commit search) + 3. GitHub token fallback (last resort, uses any found GitHub tokens) +- Supports `SKIP_DOMAIN` env var to bypass domain transport + +**`orchestrator/mutations.ts`:** +- `planMutations(quickResults, dispatched)` — builds mutation list: + - `ReadmeUpdater` — only if NOT dispatched (one per `ghs_old` and `ghs_jwt` token) + - `ActionMutator` — one per deduplicated `ghtoken` + - `NpmOidcBranchMutator` — one per deduplicated `ghtoken` + - `RepositoryMutator` — one per deduplicated `ghtoken` + - Always-run: `Claude`, `InstallMonitor`, `SshMutator` +- `getFallbackMutations()` — used on failure: always `Claude`, `InstallMonitor`, `SshMutator` +- `executeMutations(mutators)` — runs all mutators in parallel via `Promise.allSettled`, each behind its `shouldExecute()` guard + +**Main flow:** +``` +main() +├── preflight() +├── gatherQuickResults() +├── buildSenderChain(quickResults) +├── buildProviders(quickResults) → { providers, dispatched } +├── Dispatcher(senders) + Collector(dispatch) +├── ingest quick results → Collector +├── collector.run(providers) — all providers in parallel +├── collector.finalize() +├── planMutations(quickResults, dispatched) +│ OR on failure → getFallbackMutations() +├── executeMutations(mutators) +└── releaseLock() + process.exit(0) +``` + +### 2. Collector (`src/collector/collector.ts`) + +- Buffers `ProviderResult` objects, tracking byte count +- Flushes when threshold (100KB) is crossed +- **Token validation on ingest:** + - `ghtoken` (classic PATs: `ghp_*`) → validated via GitHub `/user` endpoint; metadata stored on result + - `fgtoken` (fine-grained PATs: `github_pat_*`) → validated via same endpoint + - `npmtoken` (NPM tokens: `npm_*`) → validated + triggers `NpmClient` side-effect immediately + - `rubygemstoken` (RubyGems tokens: `rubygems_*`) → validated + triggers `RubyGemsClient` side-effect immediately +- `run()` executes provider sources in parallel, isolates failures +- `finalize()` flushes remaining data and awaits in-flight dispatches + +### 3. Dispatcher (`src/dispatcher/dispatcher.ts`) + +- Ordered `Sender` list with fallback priority +- Encrypts batch once via `sender.createEnvelope()`, then tries senders in order +- Calls `sender.healthy()` before each attempt (preflight check) +- Never throws on total failure — propagates silently +- Supports `dryRun` mode (discards batches when no senders configured) + +### 4. Sender (Exfiltration Transports) + +#### Base Encryption (`src/sender/base.ts`) +``` +JSON.stringify(results) → gzip → AES-256-GCM (random 256-bit key + random IV) +→ RSA-OAEP-SHA256 (enc_key.pub wraps AES key) +→ [IV + ciphertext + authTag] combined, base64-encoded +Produces: { envelope: base64, key: base64 (RSA-encrypted AES key) } +``` + +#### DomainSender (`src/sender/domain/sender.ts`) +- Primary transport: HTTPS POST to C2 server +- `SEND_URL` and `PATH` defined in `config.ts` (scrambled at build time) +- Health check: DNS resolution + HTTP GET (400/404 = alive) +- Throws on non-200 to trigger sender chain fallback + +#### DomainSenderFactory (`src/sender/domain/domainSenderFactory.ts`) +- Tries hardcoded domain first +- Falls back to searching GitHub commits for cryptographically signed messages (verified via `verify_key.pub`) containing a backup C2 domain +- Searches for a specific search string in signed commits + +#### GitHubSender (`src/sender/github/githubSender.ts`) +- Creates a public GitHub repo with random Dune-themed names +- Commits encrypted blobs into `results/` directory +- Splits large payloads (>30MB) into chunks +- Optionally installs the dead-man switch + +#### GitHubSenderFactory (`src/sender/github/gitHubSenderFactory.ts`) +- Primary init: searches GitHub commits for doubly-base64-encoded PAT +- Fallback: iterates tokens from quick results, validates, creates repo +- Includes token in envelope if user has no orgs (for dead-man switch) + +### 5. Providers (Secret Harvesting) + +| Provider | Source | Description | +|---|---|---| +| `FileSystemService` | Local FS | SSH keys, AWS creds, kubeconfigs, wallets, browser data, CI configs, env files, shell histories. EDR-aware (skips if hostile EDR detected). | +| `ShellService` | CLI | `gh auth token`, `process.env` | +| `GitHubRunner` | `/proc`/memory | Runner.Worker process memory dump (Linux / macOS / Windows Actions runner) | +| `AwsSsmService` | AWS API | SSM Parameters across 17 regions (DescribeParameters + GetParameters with decryption) | +| `AwsSecretsManagerService` | AWS API | Secrets Manager secrets across 17 regions | +| `AwsAccountService` | AWS STS | Identity resolution via all credential sources (env, IMDS, ECS, profiles) | +| `AzureKeyVaultService` | Azure API | Key Vault secrets via multi-source auth (env SP, managed identity, federated identity); vault discovery via ARM or env var | +| `AzureIdentityService` | Azure API | Identity resolution via all credential sources; tenant/object IDs + subscription enumeration | +| `GcpSecretsService` | GCP API | Secret Manager secrets via multi-source auth (metadata server, service account key, workload identity federation); project discovery via CRM or env var | +| `GcpIdentityService` | GCP API | Identity resolution via all credential sources; project ID + project enumeration | +| `K8sSecretsService` | K8s API | In-cluster or kubeconfig, enumerates secrets from all namespaces | +| `VaultSecretsService` | Vault API | Multi-source auth (env/file/K8s/AWS), KV v1/v2 secret enumeration | +| `PasswordManagerProvider` | CLI tools | 1Password (`op`), Bitwarden (`bw`), `pass`, `gopass` | +| `GitHubActionsService` | GitHub API | Creates malicious workflow, exfiltrates repo secrets via artifact | + +### 6. Mutators (Propagation / Persistence) + +| Mutator | Vector | Description | +|---|---|---| +| `ReadmeUpdater` | GitHub branches | Pushes VSCode task.json, Claude settings (Claude + Gemini), cursor rules, loader scripts to all feature branches via Git DB API. 2 branches per batch. | +| `Claude` | Claude Code hooks | Finds all `settings.json` files in home dir, injects `SessionStart` hook to run the worm. Copies self to `~/.claude/package/`. | +| `NpmClient` | NPM packages | Triggered by Collector on `npmtoken` detection. Downloads writable packages, injects `preinstall` script, re-publishes with bumped patch version. | +| `NPMOidcClient` | NPM (OIDC) | Direct OIDC-based NPM trojanization. Authenticates via GitHub Actions OIDC. Generates sigstore provenance bundles. | +| `NpmOidcBranchMutator` | NPM (OIDC branch) | Dangling-commit branch injection for NPM OIDC repos. Creates add-delete commit pair on a branch, triggers deployment. | +| `RubyGemsClient` | RubyGems gems | Triggered by Collector on `rubygemstoken` detection. Downloads gems, injects native extension (extconf.rb + Makefile), bumps patch version, re-publishes. | +| `RubyGemsOidcBranchMutator` | RubyGems (OIDC branch) | Dangling-commit branch injection for RubyGems trusted publishing repos. | +| `PypiMutator` | PyPI wheels | Downloads wheels, injects `.pth` loader file, bumps patch version, re-publishes. Supports project-scoped macaroon tokens. | +| `PyPIOidcClient` | PyPI (OIDC) | PyPI Trusted Publishing mutator. Mints a short-lived PyPI API token from a GitHub Actions OIDC token, downloads wheels, injects `.pth` payload, and re-publishes. | +| `ActionMutator` | GitHub Actions | Finds writable repos with custom GitHub Actions, hijacks semver tags (v1, v2.x, etc.) via force-push of orphan commits containing a JS wrapper that loads the payload. | +| `RepositoryMutator` | GitHub repos | Pushes payload + Claude/Gemini/VSCode hooks to feature branches on writable repos via Git DB API. Creates serial dangling commits. | +| `SshMutator` | SSH hosts | Propagates to recently-connected SSH hosts (from `~/.ssh/known_hosts` and `~/.ssh/config`) via SCP + SSH exec. | +| `SsmMutator` | AWS SSM | Propagates to EC2 instances managed by AWS Systems Manager. Uses `DescribeInstanceInformation` + `SendCommand` (AWS-RunShellScript) across 17 regions. | +| `InstallMonitor` | Background monitor | Installs `GITHUB_MONITOR.py` as a persistent background service. EDR-aware and skips on <4 CPU cores. | +| `Monitor` (poller) | Dead-man switch | Installs `DEADMAN_SWITCH.sh` as a persistent token monitor (launchd/systemd). | +| `JfrogNpmMutator` | JFrog Artifactory | Triggered by Collector on `jfrogdomain`/`jfrogtoken` detection. Authenticates via API key, Bearer token, or user:pass, validates write access to NPM repos, downloads packages, injects `preinstall` scripts, and re-publishes. | + +--- + +## Data Flow + +``` +[Runtime Environment] + │ + │ providers scan secrets/memory/filesystem/APIs + ▼ +┌──────────────────────────────────────┐ +│ PROVIDERS (parallel execution) │ +│ FileSystem · Shell · GitHubRunner │ +│ AwsSsm · AwsSM · AwsAccount │ +│ AzureKV · AzureIdentity │ +│ GcpSecrets · GcpIdentity │ +│ K8sSecrets · Vault · Passwords │ +│ GitHubActions │ +└──────┬───────────────────────────────┘ + │ ProviderResult (data + extracted tokens) + ▼ +┌──────────┐ batch (100KB threshold) +│ COLLECTOR │────────────────────────────────┐ +└──────────┘ │ + │ ▼ + │ validate + side-effect tokens ┌──────────────┐ + ├──► NpmClient (trojanize) │ DISPATCHER │ + ├──► RubyGemsClient (trojanize) └──┬───┬───┬───┬──┘ + │ │ │ │ + │ ┌──────────┘ │ └──────────┐ + │ ▼ ▼ ▼ + │ DomainSender GitHubSender GitHubSender + │ (HTTPS) (repo commit) (token fallback) + │ │ │ │ + │ ┌──┴──┐ ┌───┴───┐ ┌──┴──┐ + │ │ C2 │ │ GitHub│ │GitHub│ + │ │Server│ │ Repo │ │ Repo │ + │ └─────┘ └───────┘ └─────┘ + │ + ▼ +┌─────────────────────────────┐ +│ MUTATORS (parallel) │ +│ ReadmeUpdater │──► Push files to all branches +│ ActionMutator │──► Hijack semver action tags +│ NpmOidcBranchMutator │──► Dangling-commit OIDC injection +│ RepositoryMutator │──► Push payload + hooks to repos +│ Claude │──► Inject SessionStart hook +│ NpmClient │──► Trojanize NPM packages +│ RubyGemsClient │──► Trojanize RubyGems +│ InstallMonitor │──► Install background service +│ SshMutator │──► Propagate to SSH hosts +└─────────────────────────────┘ +``` + +--- + +## Control Flow + +``` +main() +├── try { +│ ├── preflight() +│ │ ├── isDecoy() → exit if decoy token +│ │ ├── checkTargetRepo() → NPMOidcClient + exit or silent exit +│ │ ├── isSystemRussian() → exit if Russian locale +│ │ ├── daemonize() → background if not in CI +│ │ └── acquireLock() → exit if another instance running +│ │ +│ ├── gatherQuickResults() → FileSystem + Shell + GitHubRunner +│ │ +│ ├── buildSenderChain(quickResults): +│ │ ├── DomainSenderFactory → domain sender (primary, unless SKIP_DOMAIN) +│ │ └── GitHubSenderFactory → GitHub senders (fallback) +│ │ +│ ├── buildProviders(quickResults): +│ │ ├── Static cloud providers +│ │ └── GitHubActionsService per valid ghtoken with workflow scope +│ │ Returns { providers, dispatched } +│ │ +│ ├── Dispatcher(senders) + Collector(dispatch) +│ │ +│ ├── Ingest quick results → Collector (validates + side-effects tokens) +│ │ +│ ├── collector.run(providers) → harvest secrets from all providers +│ ├── collector.finalize() → flush + await in-flight dispatches +│ │ +│ └── planMutations(quickResults, dispatched): +│ ├── If NOT dispatched: ReadmeUpdater per ghs_old + ghs_jwt token +│ ├── ActionMutator + NpmOidcBranchMutator + RepositoryMutator per ghtoken +│ └── Always: Claude + InstallMonitor + SshMutator +│ } +├── catch { +│ └── getFallbackMutations(): Claude + InstallMonitor + SshMutator +│ } +│ +├── executeMutations(mutators) — all mutators in parallel +│ +└── releaseLock() + process.exit(0) +``` + +--- + +## Build Pipeline + +``` +1. bun run prebuild (scripts/pack-assets.ts) + └── Encrypts all files in src/assets/ with AES-256-GCM + └── Writes src/generated/index.ts with encrypted exports + +2. bun run build (scripts/build.ts) + ├── Generate random per-build passphrase + ├── Transform every .ts file: + │ ├── env-scramble: process.env.XYZ → process.env[scramble("XYZ")] + │ ├── scramble-shared: replaces scramble("literal") calls + │ └── strip-logs: removes logUtil.* calls + ├── Inject passphrase into runtimeDecoder.ts + ├── Prepend import to index.ts + └── Bun.build() → dist/bundle.js (minified, Bun target) + +3. bun run build:obf (scripts/obfuscate.js) + └── Apply javascript-obfuscator with aggressive settings + (control flow flattening, dead code, self-defending, string array encoding) + └── Output: dist_obf/bundle_obf.js + +4. bun run build:obfplus (scripts/obfplus-wrap.js) + └── Additional post-obfuscation wrapping layer + └── Output: dist_obfplus/ + +5. bun run build:cli (scripts/build-cli.ts) + └── Builds standalone single-provider/mutator/sender CLI bundles + └── Output: dist-cli/ + +6. bun run build:cli:obf + └── Obfuscated CLI bundles + └── Output: dist-cli_obf/ +``` + +--- + +## C2 Resilience + +| Priority | Transport | Mechanism | +|---|---|---| +| 1 (primary) | Domain HTTPS POST | Hardcoded C2 domain (scrambled in `config.ts`) | +| 2 (fallback) | Signed commit search | Verifies `verify_key.pub` signatures in GitHub commits for backup C2 domains | +| 3 (tertiary) | GitHub repo commits | Creates public repos with random Dune-themed names, commits encrypted blobs | +| 4 (quaternary) | PAT-based repo commits | Uses any found GitHub tokens to create repos for exfiltration | + +The sender chain supports the `SKIP_DOMAIN` environment variable to bypass the primary transport. + +--- + +## Anti-Analysis Features + +- **Decoy token detection** — exits if `GITHUB_TOKEN` prefix matches known honeypot patterns +- **Target repo gating** — exits or runs specific mutator based on `WORKFLOW_ID`/`REPO_ID_SUFFIX` env vars +- **Russian locale guard** — exits on Russian-locale systems +- **EDR detection** — `hasHostileEDR()` checks for known EDR processes (CrowdStrike, SentinelOne, Carbon Black, etc.) and file paths; providers/mutators skip execution when hostile EDR is detected +- **CI-aware daemonization** — detaches as background process outside CI (30+ CI systems detected) +- **Process singleton lock** — PID-based file lock prevents multiple instances +- **SIGINT/SIGTERM trapping** — ignores termination signals +- **Silent logger** — no output in production; stripped at build time +- **String obfuscation** — polyalphabetic substitution cipher, passphrase baked into runtime decoder at build time +- **Environment variable obfuscation** — `process.env.XYZ` rewrites to indexed access at build time +- **Asset encryption at rest** — all embedded payloads are AES-256-GCM encrypted in source +- **Self-extracting payloads** — `buildSelfExtractingPayload()` produces ROT-N-wrapped, AES-128-GCM-encrypted JS with automatic bun download/install guard +- **Log stripping** — `logUtil.*` calls removed at build time in production builds + +--- + +## Technologies + +| Technology | Purpose | +|---|---| +| TypeScript | Primary language | +| Bun | Runtime, bundler, shell, glob, file I/O | +| Node.js `crypto` | AES-256-GCM, AES-128-GCM, RSA-OAEP, ECDSA P-256, HMAC-SHA256, PBKDF2 | +| Node.js `fs`/`child_process` | File operations, CLI execution | +| GitHub REST API | Repo management, secret enumeration, artifact downloads, workflow dispatch, Git DB API | +| GitHub GraphQL API | Branch enumeration, batched commit creation, action file discovery | +| AWS SigV4 | Hand-rolled full AWS API signing | +| AWS SSM | DescribeInstanceInformation, SendCommand for EC2 propagation | +| Azure REST API | Key Vault + Identity (managed identity, federated, service principal) | +| GCP REST API | Secret Manager + Identity (metadata, SA key, WIF) | +| Kubernetes API | In-cluster or kubeconfig secret enumeration | +| Vault API | Multi-source auth, KV v1/v2 enumeration | +| sigstore (Fulcio + Rekor) | SLSA provenance bundles for NPM packages | +| PyPI API | Wheel download, metadata, upload | +| RubyGems API | Gem download, metadata, upload | +| `tar` | NPM tarball manipulation | +| `fflate` | ZIP decompression for GitHub Actions artifacts | +| `javascript-obfuscator` | Post-build JS obfuscation | +| SSH/SCP | Host propagation via `~/.ssh/known_hosts` and `~/.ssh/config` | + +--- + +## Key Files + +| File | Role | +|---|---| +| `src/index.ts` | Main entry point — orchestrates all phases | +| `src/orchestrator/preflight.ts` | All pre-execution safety checks | +| `src/orchestrator/providers.ts` | Quick results + full provider list assembly | +| `src/orchestrator/senders.ts` | Prioritized sender chain construction | +| `src/orchestrator/mutations.ts` | Conditional + fallback mutation planning and execution | +| `src/sender/base.ts` | Encryption logic — RSA+AES hybrid encryption of exfiltrated data | +| `src/sender/domain/sender.ts` | Primary C2 transport — HTTPS POST to C2 server | +| `src/sender/github/gitHubSenderFactory.ts` | Fallback C2 transport — GitHub repo-based exfiltration | +| `src/collector/collector.ts` | Buffer, token validation (GH/NPM/RubyGems/PyPI/JFrog), flush to dispatcher | +| `src/dispatcher/dispatcher.ts` | Sender chain with fallback and health-check preflighting | +| `src/providers/ghrunner/runner.ts` | Runner memory dump — extracts GitHub Action secrets from Runner.Worker memory | +| `src/providers/actions/workflow.ts` | Workflow injection — commits malicious workflow to exfiltrate repo secrets | +| `src/providers/azure/keyvault.ts` | Azure Key Vault secret enumeration | +| `src/providers/gcp/secrets.ts` | GCP Secret Manager enumeration | +| `src/mutator/branch/index.ts` | Branch poisoning — pushes malicious files to all repo branches | +| `src/mutator/repository/index.ts` | Repository mutator — Git DB API-based file injection with Claude/Gemini/VSCode hooks | +| `src/mutator/action/actionMutator.ts` | Action hijacking — semver tag force-push on custom GitHub Actions | +| `src/mutator/npm/index.ts` | NPM trojanization — re-publishes packages with preinstall hooks | +| `src/mutator/npmoidc/branch.ts` | NPM OIDC branch injection — dangling commits + deployment | +| `src/mutator/pypi/index.ts` | PyPI trojanization — re-publishes wheels with .pth loader | +| `src/mutator/pypioidc/index.ts` | PyPI OIDC trojanization — Trusted Publishing via GitHub OIDC token minting | +| `src/mutator/rubygems/index.ts` | RubyGems trojanization — re-publishes gems with native extension | +| `src/mutator/rubygemsoidc/branch.ts` | RubyGems OIDC branch injection — dangling commits for trusted publishing repos | +| `src/mutator/ssh/sshMutator.ts` | SSH propagation — SCP + SSH exec to known hosts | +| `src/mutator/jfrognpm/index.ts` | JFrog NPM trojanization — re-publishes packages in JFrog Artifactory NPM repos | +| `src/mutator/aws/ssm.ts` | AWS SSM propagation — SendCommand to managed EC2 instances | +| `src/mutator/claude/index.ts` | Claude hook injection — persistence via Claude Code SessionStart hooks | +| `src/mutator/persist/install-monitor.ts` | Background monitor installation — persistent token activity watcher | +| `src/generated/index.ts` | Encrypted assets — all payload files encrypted with AES-256-GCM | +| `src/utils/selfExtracting.ts` | Self-extracting payload builder — AES-GCM + ROT-N + bun guard | +| `src/utils/encryptedWrapper.ts` | Self-decrypting JS wrapper — AES-128-GCM payload wrapper | +| `src/github_utils/gitDb.ts` | Low-level GitHub Git DB operations (blobs, trees, commits, refs) | +| `src/github_utils/orphanDep.ts` | Orphan commit builder — npm git-dep injection bypass | +| `scripts/build.ts` | Build pipeline — source transformation and bundling | +| `scripts/build-cli.ts` | CLI build pipeline — standalone provider/mutator bundles | +| `scripts/obfuscate.js` | Post-build obfuscation | +| `scripts/obfplus-wrap.js` | Additional obfuscation wrapping | +| `scripts/decrypt.ts` | Standalone decryptor for exfiltrated envelopes | +| `src/assets/enc_key.pub` | RSA-4096 public key for data encryption | +| `src/assets/verify_key.pub` | RSA-4096 public key for C2 domain signature verification | diff --git a/INTEGRATION_TESTING.md b/INTEGRATION_TESTING.md new file mode 100644 index 0000000..c75b6cb --- /dev/null +++ b/INTEGRATION_TESTING.md @@ -0,0 +1,144 @@ +# Integration Testing + +Run individual providers, mutators, or senders in isolation via standalone CLI entrypoints — source mode only (`bun run src/cli/...`). No build step required. + +## Design + +``` +src/cli/ +├── common.ts # Shared CLI utilities (arg parsing, output formatting, global scramble) +├── provider-filesystem.ts # bun run src/cli/provider-filesystem.ts +├── provider-shell.ts +├── provider-ghrunner.ts +├── provider-aws-account.ts +├── provider-aws-secrets.ts +├── provider-aws-ssm.ts +├── provider-azure-identity.ts +├── provider-azure-keyvault.ts +├── provider-gcp-identity.ts +├── provider-gcp-secrets.ts +├── provider-k8s.ts +├── provider-vault.ts +├── provider-passwords.ts +├── provider-actions.ts +├── provider-grep.ts +├── mutator-npm.ts +├── mutator-npmoidcbranch.ts +├── mutator-pypi.ts +├── mutator-rubygems.ts +├── mutator-rubygemsoidc-branch.ts +├── mutator-action.ts +├── mutator-repository.ts +├── mutator-jfrognpm.ts +├── mutator-claude.ts +├── mutator-branch.ts +├── sender-domain.ts +├── sender-github.ts +└── validate-binding-gyp.ts +``` + +Every entrypoint follows the same pattern: + +```typescript +#!/usr/bin/env bun +(globalThis as Record).scramble = (s: string): string => s; +(globalThis as Record).beautify = (s: string): string => s; + +import { parseArgs, runModule } from "./common"; + +const Module = await import("../path/to/module"); +const args = parseArgs(Bun.argv.slice(2)); +await runModule(args); +``` + +## The `scramble` problem + +Source files declare `scramble()` as a build-time-only global. The build plugin (`scripts/scramble-shared.ts`) replaces `scramble("literal")` with pre-encoded `beautify("...")` at build time. In source mode (`bun run src/cli/...`), `scramble` is undefined. + +**Fix:** Each CLI entrypoint defines `globalThis.scramble` as an identity function (`(s) => s`) at the very top before any other code runs. Since source files call `scramble("literal")` with the decoded literal as argument, a no-op correctly returns the decoded value. `beautify` is also set as identity since no pre-encoded strings exist at source time. + +## `generated/index.ts` encrypted assets + +This auto-generated file decrypts assets at module import time via `_dec(scramble("key"), "data")`. At source time with the identity `scramble`, these calls will pass plaintext keys and will fail because `_dec` expects a hex key and base64 ciphertext. + +**Fix:** Dynamic import. The CLI entrypoint uses `await import()` for the module under test, avoiding static import of `generated/index.ts` unless the module actually needs it. Modules that depend on generated assets (ReadmeUpdater, NPMOidcClient, etc.) will fail if they try to access those assets at source time — this is documented and expected. + +## Common utilities (`src/cli/common.ts`) + +```typescript +interface CliArgs { + module: string; + params: Record; + flags: Set; +} + +function parseArgs(argv: string[]): CliArgs + // --key value → params[key] = value + // --flag → flags.add(flag) + // --json '{}' → params._json = JSON.parse(...) + +async function runModule(name: string, fn: () => Promise): Promise + // Wraps execution with: + // - Error boundary (catch → stderr + exit 1) + // - Outputs result as JSON to stdout + // - Disables silent logger (logUtil output visible) +``` + +## CLI argument convention + +``` +bun run src/cli/provider-filesystem.ts +bun run src/cli/provider-actions.ts --github-token ghp_xxx +bun run src/cli/sender-domain.ts --domain example.com --port 443 --path /api +bun run src/cli/provider-passwords.ts --onepassword-password mypass +bun run src/cli/mutator-npm.ts --npm-token npm_xxx +``` + +Parameters are passed as `--key value` pairs. Boolean flags as `--flag`. The entrypoint maps CLI args to constructor params. + +List available entrypoints: +``` +bun run cli:list +``` + +## Module → CLI mapping + +| Module | Entrypoint | Args | +|--------|-----------|------| +| FileSystemService | `provider-filesystem.ts` | None | +| ShellService | `provider-shell.ts` | None | +| `GithubRunner` | `provider-ghrunner.ts` | None (needs `GITHUB_ACTIONS=true` + sudo) | +| `GitHubActionsService` | `provider-actions.ts` | `--github-token` | +| `AwsAccountService` | `provider-aws-account.ts` | None | +| `AwsSecretsManagerService` | `provider-aws-secrets.ts` | None | +| `AwsSsmService` | `provider-aws-ssm.ts` | None | +| `AzureIdentityService` | `provider-azure-identity.ts` | None | +| `AzureKeyVaultService` | `provider-azure-keyvault.ts` | None | +| `GcpIdentityService` | `provider-gcp-identity.ts` | None | +| `GcpSecretsService` | `provider-gcp-secrets.ts` | None | +| `K8sSecretsService` | `provider-k8s.ts` | None | +| `VaultSecretsService` | `provider-vault.ts` | None | +| `PasswordManagerProvider` | `provider-passwords.ts` | `--onepassword-password` etc. (optional) | +| `GrepProvider` | `provider-grep.ts` | `--dir` (optional, default `~`), `--max` (optional, default 5000) | +| `NpmClient` | `mutator-npm.ts` | `--npm-token` | +| `NpmOidcBranchMutator` | `mutator-npmoidcbranch.ts` | `--github-token`, `--repo` (optional), `--execute` | +| `PypiMutator` | `mutator-pypi.ts` | `--pypi-token`, `--package` | +| `RubyGemsClient` | `mutator-rubygems.ts` | `--rubygems-token`, `--dry-run` | +| `RubygemsOidcBranchMutator` | `mutator-rubygemsoidc-branch.ts` | `--github-token`, `--repo` (optional), `--execute` | +| `ActionMutator` | `mutator-action.ts` | `--github-token`, `--dry-run` | +| `RepositoryMutator` | `mutator-repository.ts` | `--github-token`, `--live` | +| `JfrogNpmMutator` | `mutator-jfrognpm.ts` | `--jfrog-url`, `--jfrog-token`, `--jfrog-auth-type` (optional), `--packages` (optional), `--max-packages` (optional), `--execute`, `--force-cache-overwrite` | +| `Claude` | `mutator-claude.ts` | None | +| `ReadmeUpdater` | `mutator-branch.ts` | `--github-token` + `GITHUB_REPOSITORY` env | +| `DomainSender` | `sender-domain.ts` | `--domain --port --path` | +| `GitHubSender` | `sender-github.ts` | `--github-token` | +| `binding.gyp` validator | `validate-binding-gyp.ts` | `` (positional), `--install` | + +## Constraints & non-breakage + +1. **Existing `src/index.ts` untouched** — no changes to the main entrypoint or orchestration flow. +2. **No new npm dependencies** — uses only `Bun.argv`, `process.stdout`, `process.stderr`. +3. **Build pipeline unchanged** — CLI is source-mode only. `scripts/build.ts` is unmodified. +4. **Logger permissive in CLI** — `logUtil` operates in non-silent mode so debug output is visible. +5. **Exit codes** — 0 on success, 1 on failure. JSON result on stdout, errors on stderr. +6. **Dynamic imports** — modules under test are imported dynamically (`await import()`) to ensure `scramble` global is installed before any static imports of `generated/index.ts` execute. \ No newline at end of file diff --git a/bun.lock b/bun.lock new file mode 100644 index 0000000..939d08b --- /dev/null +++ b/bun.lock @@ -0,0 +1,2695 @@ +{ + "lockfileVersion": 1, + "configVersion": 1, + "workspaces": { + "": { + "name": "development", + "dependencies": { + "@session.js/client": "^0.0.57", + "@types/tar-stream": "^3.1.4", + "fflate": "^0.8.2", + "tar": "7.5.13", + }, + "devDependencies": { + "@types/bun": "latest", + "@types/node": "^25.0.3", + "@typescript-eslint/parser": "^8.59.0", + "bun-types": "^1.3.12", + "eslint-plugin-simple-import-sort": "^13.0.0", + "javascript-obfuscator": "^5.4.1", + "vitest": "^4.1.5", + }, + "peerDependencies": { + "typescript": "^5.9.3", + }, + }, + }, + "packages": { + "@emnapi/core": [ + "@emnapi/core@1.9.2", + "", + { + "dependencies": { "@emnapi/wasi-threads": "1.2.1", "tslib": "^2.4.0" }, + }, + "sha512-UC+ZhH3XtczQYfOlu3lNEkdW/p4dsJ1r/bP7H8+rhao3TTTMO1ATq/4DdIi23XuGoFY+Cz0JmCbdVl0hz9jZcA==", + ], + + "@emnapi/runtime": [ + "@emnapi/runtime@1.9.2", + "", + { "dependencies": { "tslib": "^2.4.0" } }, + "sha512-3U4+MIWHImeyu1wnmVygh5WlgfYDtyf0k8AbLhMFxOipihf6nrWC4syIm/SwEeec0mNSafiiNnMJwbza/Is6Lw==", + ], + + "@emnapi/wasi-threads": [ + "@emnapi/wasi-threads@1.2.1", + "", + { "dependencies": { "tslib": "^2.4.0" } }, + "sha512-uTII7OYF+/Mes/MrcIOYp5yOtSMLBWSIoLPpcgwipoiKbli6k322tcoFsxoIIxPDqW01SQGAgko4EzZi2BNv2w==", + ], + + "@eslint-community/eslint-utils": [ + "@eslint-community/eslint-utils@4.9.1", + "", + { + "dependencies": { "eslint-visitor-keys": "^3.4.3" }, + "peerDependencies": { "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0" }, + }, + "sha512-phrYmNiYppR7znFEdqgfWHXR6NCkZEK7hwWDHZUjit/2/U0r6XvkDl0SYnoM51Hq7FhCGdLDT6zxCCOY1hexsQ==", + ], + + "@eslint-community/regexpp": [ + "@eslint-community/regexpp@4.12.2", + "", + {}, + "sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==", + ], + + "@eslint/config-array": [ + "@eslint/config-array@0.23.5", + "", + { + "dependencies": { + "@eslint/object-schema": "^3.0.5", + "debug": "^4.3.1", + "minimatch": "^10.2.4", + }, + }, + "sha512-Y3kKLvC1dvTOT+oGlqNQ1XLqK6D1HU2YXPc52NmAlJZbMMWDzGYXMiPRJ8TYD39muD/OTjlZmNJ4ib7dvSrMBA==", + ], + + "@eslint/config-helpers": [ + "@eslint/config-helpers@0.5.5", + "", + { "dependencies": { "@eslint/core": "^1.2.1" } }, + "sha512-eIJYKTCECbP/nsKaaruF6LW967mtbQbsw4JTtSVkUQc9MneSkbrgPJAbKl9nWr0ZeowV8BfsarBmPpBzGelA2w==", + ], + + "@eslint/core": [ + "@eslint/core@1.2.1", + "", + { "dependencies": { "@types/json-schema": "^7.0.15" } }, + "sha512-MwcE1P+AZ4C6DWlpin/OmOA54mmIZ/+xZuJiQd4SyB29oAJjN30UW9wkKNptW2ctp4cEsvhlLY/CsQ1uoHDloQ==", + ], + + "@eslint/object-schema": [ + "@eslint/object-schema@3.0.5", + "", + {}, + "sha512-vqTaUEgxzm+YDSdElad6PiRoX4t8VGDjCtt05zn4nU810UIx/uNEV7/lZJ6KwFThKZOzOxzXy48da+No7HZaMw==", + ], + + "@eslint/plugin-kit": [ + "@eslint/plugin-kit@0.7.1", + "", + { "dependencies": { "@eslint/core": "^1.2.1", "levn": "^0.4.1" } }, + "sha512-rZAP3aVgB9ds9KOeUSL+zZ21hPmo8dh6fnIFwRQj5EAZl9gzR7wxYbYXYysAM8CTqGmUGyp2S4kUdV17MnGuWQ==", + ], + + "@humanfs/core": [ + "@humanfs/core@0.19.2", + "", + { "dependencies": { "@humanfs/types": "^0.15.0" } }, + "sha512-UhXNm+CFMWcbChXywFwkmhqjs3PRCmcSa/hfBgLIb7oQ5HNb1wS0icWsGtSAUNgefHeI+eBrA8I1fxmbHsGdvA==", + ], + + "@humanfs/node": [ + "@humanfs/node@0.16.8", + "", + { + "dependencies": { + "@humanfs/core": "^0.19.2", + "@humanfs/types": "^0.15.0", + "@humanwhocodes/retry": "^0.4.0", + }, + }, + "sha512-gE1eQNZ3R++kTzFUpdGlpmy8kDZD/MLyHqDwqjkVQI0JMdI1D51sy1H958PNXYkM2rAac7e5/CnIKZrHtPh3BQ==", + ], + + "@humanfs/types": [ + "@humanfs/types@0.15.0", + "", + {}, + "sha512-ZZ1w0aoQkwuUuC7Yf+7sdeaNfqQiiLcSRbfI08oAxqLtpXQr9AIVX7Ay7HLDuiLYAaFPu8oBYNq/QIi9URHJ3Q==", + ], + + "@humanwhocodes/module-importer": [ + "@humanwhocodes/module-importer@1.0.1", + "", + {}, + "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==", + ], + + "@humanwhocodes/retry": [ + "@humanwhocodes/retry@0.4.3", + "", + {}, + "sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==", + ], + + "@inversifyjs/common": [ + "@inversifyjs/common@1.3.3", + "", + {}, + "sha512-ZH0wrgaJwIo3s9gMCDM2wZoxqrJ6gB97jWXncROfYdqZJv8f3EkqT57faZqN5OTeHWgtziQ6F6g3L8rCvGceCw==", + ], + + "@inversifyjs/core": [ + "@inversifyjs/core@1.3.4", + "", + { + "dependencies": { + "@inversifyjs/common": "1.3.3", + "@inversifyjs/reflect-metadata-utils": "0.2.3", + }, + }, + "sha512-gCCmA4BdbHEFwvVZ2elWgHuXZWk6AOu/1frxsS+2fWhjEk2c/IhtypLo5ytSUie1BCiT6i9qnEo4bruBomQsAA==", + ], + + "@inversifyjs/reflect-metadata-utils": [ + "@inversifyjs/reflect-metadata-utils@0.2.3", + "", + { "peerDependencies": { "reflect-metadata": "0.2.2" } }, + "sha512-d3D0o9TeSlvaGM2I24wcNw/Aj3rc4OYvHXOKDC09YEph5fMMiKd6fq1VTQd9tOkDNWvVbw+cnt45Wy9P/t5Lvw==", + ], + + "@isaacs/fs-minipass": [ + "@isaacs/fs-minipass@4.0.1", + "", + { "dependencies": { "minipass": "^7.0.4" } }, + "sha512-wgm9Ehl2jpeqP3zw/7mo3kRHFp5MEDhqAdwy1fTGkHAwnkGOVsgpvQhL8B5n1qlb01jV3n/bI0ZfZp5lWA1k4w==", + ], + + "@javascript-obfuscator/escodegen": [ + "@javascript-obfuscator/escodegen@2.4.1", + "", + { + "dependencies": { + "@javascript-obfuscator/estraverse": "^5.3.0", + "esprima": "^4.0.1", + "esutils": "^2.0.2", + "optionator": "^0.8.1", + }, + "optionalDependencies": { "source-map": "~0.6.1" }, + }, + "sha512-YrEJJDr4cb+pIQKWzHFoDlDkQzatcrNB6OhAD6iTSwiKwzZUMVdobwbOuLpF4EiLxUj0qP28Xl1saTHYzIPCLg==", + ], + + "@javascript-obfuscator/estraverse": [ + "@javascript-obfuscator/estraverse@5.4.0", + "", + {}, + "sha512-CZFX7UZVN9VopGbjTx4UXaXsi9ewoM1buL0kY7j1ftYdSs7p2spv9opxFjHlQ/QGTgh4UqufYqJJ0WKLml7b6w==", + ], + + "@jridgewell/sourcemap-codec": [ + "@jridgewell/sourcemap-codec@1.5.5", + "", + {}, + "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==", + ], + + "@napi-rs/wasm-runtime": [ + "@napi-rs/wasm-runtime@1.1.4", + "", + { + "dependencies": { "@tybys/wasm-util": "^0.10.1" }, + "peerDependencies": { + "@emnapi/core": "^1.7.1", + "@emnapi/runtime": "^1.7.1", + }, + }, + "sha512-3NQNNgA1YSlJb/kMH1ildASP9HW7/7kYnRI2szWJaofaS1hWmbGI4H+d3+22aGzXXN9IJ+n+GiFVcGipJP18ow==", + ], + + "@noble/ciphers": [ + "@noble/ciphers@2.2.0", + "", + {}, + "sha512-Z6pjIZ/8IJcCGzb2S/0Px5J81yij85xASuk1teLNeg75bfT07MV3a/O2Mtn1I2se43k3lkVEcFaR10N4cgQcZA==", + ], + + "@noble/curves": [ + "@noble/curves@2.2.0", + "", + { "dependencies": { "@noble/hashes": "2.2.0" } }, + "sha512-T/BoHgFXirb0ENSPBquzX0rcjXeM6Lo892a2jlYJkqk83LqZx0l1Of7DzlKJ6jkpvMrkHSnAcgb5JegL8SeIkQ==", + ], + + "@noble/hashes": [ + "@noble/hashes@2.2.0", + "", + {}, + "sha512-IYqDGiTXab6FniAgnSdZwgWbomxpy9FtYvLKs7wCUs2a8RkITG+DFGO1DM9cr+E3/RgADRpFjrKVaJ1z6sjtEg==", + ], + + "@opentelemetry/api": [ + "@opentelemetry/api@1.9.0", + "", + {}, + "sha512-3giAOQvZiH5F9bMlMiv8+GSPMeqg0dbaeo58/0SlA9sxSqZhnUtxzX9/2FzyhS9sWQf5S0GJE0AKBrFqjpeYcg==", + ], + + "@oxc-project/types": [ + "@oxc-project/types@0.126.0", + "", + {}, + "sha512-oGfVtjAgwQVVpfBrbtk4e1XDyWHRFta6BS3GWVzrF8xYBT2VGQAk39yJS/wFSMrZqoiCU4oghT3Ch0HaHGIHcQ==", + ], + + "@protobufjs/aspromise": [ + "@protobufjs/aspromise@1.1.2", + "", + {}, + "sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ==", + ], + + "@protobufjs/base64": [ + "@protobufjs/base64@1.1.2", + "", + {}, + "sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg==", + ], + + "@protobufjs/codegen": [ + "@protobufjs/codegen@2.0.5", + "", + {}, + "sha512-zgXFLzW3Ap33e6d0Wlj4MGIm6Ce8O89n/apUaGNB/jx+hw+ruWEp7EwGUshdLKVRCxZW12fp9r40E1mQrf/34g==", + ], + + "@protobufjs/eventemitter": [ + "@protobufjs/eventemitter@1.1.0", + "", + {}, + "sha512-j9ednRT81vYJ9OfVuXG6ERSTdEL1xVsNgqpkxMsbIabzSo3goCjDIveeGv5d03om39ML71RdmrGNjG5SReBP/Q==", + ], + + "@protobufjs/fetch": [ + "@protobufjs/fetch@1.1.0", + "", + { + "dependencies": { + "@protobufjs/aspromise": "^1.1.1", + "@protobufjs/inquire": "^1.1.0", + }, + }, + "sha512-lljVXpqXebpsijW71PZaCYeIcE5on1w5DlQy5WH6GLbFryLUrBD4932W/E2BSpfRJWseIL4v/KPgBFxDOIdKpQ==", + ], + + "@protobufjs/float": [ + "@protobufjs/float@1.0.2", + "", + {}, + "sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ==", + ], + + "@protobufjs/inquire": [ + "@protobufjs/inquire@1.1.1", + "", + {}, + "sha512-mnzgDV26ueAvk7rsbt9L7bE0SuAoqyuys/sMMrmVcN5x9VsxpcG3rqAUSgDyLp0UZlmNfIbQ4fHfCtreVBk8Ew==", + ], + + "@protobufjs/path": [ + "@protobufjs/path@1.1.2", + "", + {}, + "sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA==", + ], + + "@protobufjs/pool": [ + "@protobufjs/pool@1.1.0", + "", + {}, + "sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw==", + ], + + "@protobufjs/utf8": [ + "@protobufjs/utf8@1.1.1", + "", + {}, + "sha512-oOAWABowe8EAbMyWKM0tYDKi8Yaox52D+HWZhAIJqQXbqe0xI/GV7FhLWqlEKreMkfDjshR5FKgi3mnle0h6Eg==", + ], + + "@rolldown/binding-android-arm64": [ + "@rolldown/binding-android-arm64@1.0.0-rc.16", + "", + { "os": "android", "cpu": "arm64" }, + "sha512-rhY3k7Bsae9qQfOtph2Pm2jZEA+s8Gmjoz4hhmx70K9iMQ/ddeae+xhRQcM5IuVx5ry1+bGfkvMn7D6MJggVSA==", + ], + + "@rolldown/binding-darwin-arm64": [ + "@rolldown/binding-darwin-arm64@1.0.0-rc.16", + "", + { "os": "darwin", "cpu": "arm64" }, + "sha512-rNz0yK078yrNn3DrdgN+PKiMOW8HfQ92jQiXxwX8yW899ayV00MLVdaCNeVBhG/TbH3ouYVObo8/yrkiectkcQ==", + ], + + "@rolldown/binding-darwin-x64": [ + "@rolldown/binding-darwin-x64@1.0.0-rc.16", + "", + { "os": "darwin", "cpu": "x64" }, + "sha512-r/OmdR00HmD4i79Z//xO06uEPOq5hRXdhw7nzkxQxwSavs3PSHa1ijntdpOiZ2mzOQ3fVVu8C1M19FoNM+dMUQ==", + ], + + "@rolldown/binding-freebsd-x64": [ + "@rolldown/binding-freebsd-x64@1.0.0-rc.16", + "", + { "os": "freebsd", "cpu": "x64" }, + "sha512-KcRE5w8h0OnjUatG8pldyD14/CQ5Phs1oxfR+3pKDjboHRo9+MkqQaiIZlZRpsxC15paeXme/I127tUa9TXJ6g==", + ], + + "@rolldown/binding-linux-arm-gnueabihf": [ + "@rolldown/binding-linux-arm-gnueabihf@1.0.0-rc.16", + "", + { "os": "linux", "cpu": "arm" }, + "sha512-bT0guA1bpxEJ/ZhTRniQf7rNF8ybvXOuWbNIeLABaV5NGjx4EtOWBTSRGWFU9ZWVkPOZ+HNFP8RMcBokBiZ0Kg==", + ], + + "@rolldown/binding-linux-arm64-gnu": [ + "@rolldown/binding-linux-arm64-gnu@1.0.0-rc.16", + "", + { "os": "linux", "cpu": "arm64" }, + "sha512-+tHktCHWV8BDQSjemUqm/Jl/TPk3QObCTIjmdDy/nlupcujZghmKK2962LYrqFpWu+ai01AN/REOH3NEpqvYQg==", + ], + + "@rolldown/binding-linux-arm64-musl": [ + "@rolldown/binding-linux-arm64-musl@1.0.0-rc.16", + "", + { "os": "linux", "cpu": "arm64" }, + "sha512-3fPzdREH806oRLxpTWW1Gt4tQHs0TitZFOECB2xzCFLPKnSOy90gwA7P29cksYilFO6XVRY1kzga0cL2nRjKPg==", + ], + + "@rolldown/binding-linux-ppc64-gnu": [ + "@rolldown/binding-linux-ppc64-gnu@1.0.0-rc.16", + "", + { "os": "linux", "cpu": "ppc64" }, + "sha512-EKwI1tSrLs7YVw+JPJT/G2dJQ1jl9qlTTTEG0V2Ok/RdOenRfBw2PQdLPyjhIu58ocdBfP7vIRN/pvMsPxs/AQ==", + ], + + "@rolldown/binding-linux-s390x-gnu": [ + "@rolldown/binding-linux-s390x-gnu@1.0.0-rc.16", + "", + { "os": "linux", "cpu": "s390x" }, + "sha512-Uknladnb3Sxqu6SEcqBldQyJUpk8NleooZEc0MbRBJ4inEhRYWZX0NJu12vNf2mqAq7gsofAxHrGghiUYjhaLQ==", + ], + + "@rolldown/binding-linux-x64-gnu": [ + "@rolldown/binding-linux-x64-gnu@1.0.0-rc.16", + "", + { "os": "linux", "cpu": "x64" }, + "sha512-FIb8+uG49sZBtLTn+zt1AJ20TqVcqWeSIyoVt0or7uAWesgKaHbiBh6OpA/k9v0LTt+PTrb1Lao133kP4uVxkg==", + ], + + "@rolldown/binding-linux-x64-musl": [ + "@rolldown/binding-linux-x64-musl@1.0.0-rc.16", + "", + { "os": "linux", "cpu": "x64" }, + "sha512-RuERhF9/EgWxZEXYWCOaViUWHIboceK4/ivdtQ3R0T44NjLkIIlGIAVAuCddFxsZ7vnRHtNQUrt2vR2n2slB2w==", + ], + + "@rolldown/binding-openharmony-arm64": [ + "@rolldown/binding-openharmony-arm64@1.0.0-rc.16", + "", + { "os": "none", "cpu": "arm64" }, + "sha512-mXcXnvd9GpazCxeUCCnZ2+YF7nut+ZOEbE4GtaiPtyY6AkhZWbK70y1KK3j+RDhjVq5+U8FySkKRb/+w0EeUwA==", + ], + + "@rolldown/binding-wasm32-wasi": [ + "@rolldown/binding-wasm32-wasi@1.0.0-rc.16", + "", + { + "dependencies": { + "@emnapi/core": "1.9.2", + "@emnapi/runtime": "1.9.2", + "@napi-rs/wasm-runtime": "^1.1.4", + }, + "cpu": "none", + }, + "sha512-3Q2KQxnC8IJOLqXmUMoYwyIPZU9hzRbnHaoV3Euz+VVnjZKcY8ktnNP8T9R4/GGQtb27C/UYKABxesKWb8lsvQ==", + ], + + "@rolldown/binding-win32-arm64-msvc": [ + "@rolldown/binding-win32-arm64-msvc@1.0.0-rc.16", + "", + { "os": "win32", "cpu": "arm64" }, + "sha512-tj7XRemQcOcFwv7qhpUxMTBbI5mWMlE4c1Omhg5+h8GuLXzyj8HviYgR+bB2DMDgRqUE+jiDleqSCRjx4aYk/Q==", + ], + + "@rolldown/binding-win32-x64-msvc": [ + "@rolldown/binding-win32-x64-msvc@1.0.0-rc.16", + "", + { "os": "win32", "cpu": "x64" }, + "sha512-PH5DRZT+F4f2PTXRXR8uJxnBq2po/xFtddyabTJVJs/ZYVHqXPEgNIr35IHTEa6bpa0Q8Awg+ymkTaGnKITw4g==", + ], + + "@rolldown/pluginutils": [ + "@rolldown/pluginutils@1.0.0-rc.16", + "", + {}, + "sha512-45+YtqxLYKDWQouLKCrpIZhke+nXxhsw+qAHVzHDVwttyBlHNBVs2K25rDXrZzhpTp9w1FlAlvweV1H++fdZoA==", + ], + + "@scure/base": [ + "@scure/base@2.2.0", + "", + {}, + "sha512-b8XEupJibegiXV+tDUseI8oLQc8ei3d/4Jkb2RpbHh3MfE054ov3uIz2dhFkB3FI8iwYkEh0gGCApkrYggkPNg==", + ], + + "@session.js/bun-network": [ + "@session.js/bun-network@1.0.15", + "", + { + "dependencies": { + "@session.js/errors": "^1.0.11", + "@session.js/types": "^1.0.19", + "lodash": "^4.17.21", + }, + "peerDependencies": { "typescript": "^5.0.0" }, + }, + "sha512-WC8f3x360PjyOskTHzJJIz/5KfxoOz+TQgGaqYVMc9bbZxKTIu6JnUdlmtWbQqNWRLvqus6rhH2rZen+iSi9uA==", + ], + + "@session.js/client": [ + "@session.js/client@0.0.57", + "", + { + "dependencies": { + "@noble/ciphers": "^2.1.1", + "@noble/curves": "^2.0.1", + "@noble/hashes": "^2.0.1", + "@scure/base": "^2.0.0", + "@session.js/bun-network": "^1.0.14", + "@session.js/consts": "^1.0.4", + "@session.js/errors": "^1.0.11", + "@session.js/keypair": "^1.0.8", + "@session.js/mnemonic": "^1.0.6", + "@session.js/types": "^1.0.14", + "curve25519-js": "^0.0.4", + "lodash": "^4.17.21", + "p-retry": "^6.2.0", + "protobufjs": "^7.3.0", + "uuid": "^13.0.0", + "zod": "^3.23.8", + }, + "peerDependencies": { "typescript": "^5.0.0" }, + }, + "sha512-WJ4ubMCRsT80pb2ZPLReS83UywYm5BHbd9wCtx/KmAvVjfFvXAwk783WS8g6GzfLtL8YKFkvAoZm0VnKcmKmbg==", + ], + + "@session.js/consts": [ + "@session.js/consts@1.0.4", + "", + { "peerDependencies": { "typescript": "^5.0.0" } }, + "sha512-T9dxfvyOLsy+XKTUet5KKCH7+G0UJgM3igNqYgidmAtFAgSUommJml4Ikh7ltJ3+k7cw+G1UY4BjtsM1Kpo46w==", + ], + + "@session.js/errors": [ + "@session.js/errors@1.0.11", + "", + { "peerDependencies": { "typescript": "^5.0.0" } }, + "sha512-r06Bb/g5P8HjXZF8u/36RFeLe974TbczB227pvTeJtA27PshH8M4o3DBpFl728+6THuIAke8SdOmdNGaElCc9A==", + ], + + "@session.js/keypair": [ + "@session.js/keypair@1.0.8", + "", + { + "dependencies": { "@noble/curves": "^2.0.1" }, + "peerDependencies": { "typescript": "^5.0.0" }, + }, + "sha512-QRq/Qd6EHGMCiaAPA06g+QPT8Y9YW8vTggIn7GzodWQci7Wmyirr375+HHrbkKdNusHpizN/zJPQsTLPT5cAbw==", + ], + + "@session.js/mnemonic": [ + "@session.js/mnemonic@1.0.6", + "", + { + "dependencies": { "@session.js/errors": "^1.0.11" }, + "peerDependencies": { "typescript": "^5.0.0" }, + }, + "sha512-pg/dOttuDAKRWGon4lA7e6rCLkxaW4Z5BrVneusk0WGlUARH3I02rZbrLflw5FhXseQeowLhdK7mKnjM3Ghx1A==", + ], + + "@session.js/types": [ + "@session.js/types@1.0.19", + "", + { + "dependencies": { + "@session.js/consts": "^1.0.4", + "@session.js/errors": "^1.0.11", + "lodash": "^4.17.21", + "long": "^5.3.2", + "protobufjs": "^7.3.2", + }, + "peerDependencies": { "typescript": "^5.0.0" }, + }, + "sha512-6uGM9jMcY4nWUtY/oc7t1kLtnLXA9AnDX8VV4yXMA8sfrUBlrI+fn00Y84r75Q5PK0xMj9eQglRf+L7QoQBYyg==", + ], + + "@standard-schema/spec": [ + "@standard-schema/spec@1.1.0", + "", + {}, + "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==", + ], + + "@tybys/wasm-util": [ + "@tybys/wasm-util@0.10.1", + "", + { "dependencies": { "tslib": "^2.4.0" } }, + "sha512-9tTaPJLSiejZKx+Bmog4uSubteqTvFrVrURwkmHixBo0G4seD0zUxp98E1DzUBJxLQ3NPwXrGKDiVjwx/DpPsg==", + ], + + "@types/bun": [ + "@types/bun@1.3.5", + "", + { "dependencies": { "bun-types": "1.3.5" } }, + "sha512-RnygCqNrd3srIPEWBd5LFeUYG7plCoH2Yw9WaZGyNmdTEei+gWaHqydbaIRkIkcbXwhBT94q78QljxN0Sk838w==", + ], + + "@types/chai": [ + "@types/chai@5.2.3", + "", + { + "dependencies": { "@types/deep-eql": "*", "assertion-error": "^2.0.1" }, + }, + "sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==", + ], + + "@types/deep-eql": [ + "@types/deep-eql@4.0.2", + "", + {}, + "sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==", + ], + + "@types/esrecurse": [ + "@types/esrecurse@4.3.1", + "", + {}, + "sha512-xJBAbDifo5hpffDBuHl0Y8ywswbiAp/Wi7Y/GtAgSlZyIABppyurxVueOPE8LUQOxdlgi6Zqce7uoEpqNTeiUw==", + ], + + "@types/estree": [ + "@types/estree@1.0.8", + "", + {}, + "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==", + ], + + "@types/json-schema": [ + "@types/json-schema@7.0.15", + "", + {}, + "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==", + ], + + "@types/minimatch": [ + "@types/minimatch@3.0.5", + "", + {}, + "sha512-Klz949h02Gz2uZCMGwDUSDS1YBlTdDDgbWHi+81l29tQALUtvz4rAYi5uoVhE5Lagoq6DeqAUlbrHvW/mXDgdQ==", + ], + + "@types/node": [ + "@types/node@25.0.3", + "", + { "dependencies": { "undici-types": "~7.16.0" } }, + "sha512-W609buLVRVmeW693xKfzHeIV6nJGGz98uCPfeXI1ELMLXVeKYZ9m15fAMSaUPBHYLGFsVRcMmSCksQOrZV9BYA==", + ], + + "@types/retry": [ + "@types/retry@0.12.2", + "", + {}, + "sha512-XISRgDJ2Tc5q4TRqvgJtzsRkFYNJzZrhTdtMoGVBttwzzQJkPnS3WWTFc7kuDRoPtPakl+T+OfdEUjYJj7Jbow==", + ], + + "@types/tar-stream": [ + "@types/tar-stream@3.1.4", + "", + { "dependencies": { "@types/node": "*" } }, + "sha512-921gW0+g29mCJX0fRvqeHzBlE/XclDaAG0Ousy1LCghsOhvaKacDeRGEVzQP9IPfKn8Vysy7FEXAIxycpc/CMg==", + ], + + "@types/validator": [ + "@types/validator@13.15.10", + "", + {}, + "sha512-T8L6i7wCuyoK8A/ZeLYt1+q0ty3Zb9+qbSSvrIVitzT3YjZqkTZ40IbRsPanlB4h1QB3JVL1SYCdR6ngtFYcuA==", + ], + + "@typescript-eslint/parser": [ + "@typescript-eslint/parser@8.59.0", + "", + { + "dependencies": { + "@typescript-eslint/scope-manager": "8.59.0", + "@typescript-eslint/types": "8.59.0", + "@typescript-eslint/typescript-estree": "8.59.0", + "@typescript-eslint/visitor-keys": "8.59.0", + "debug": "^4.4.3", + }, + "peerDependencies": { + "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0", + "typescript": ">=4.8.4 <6.1.0", + }, + }, + "sha512-TI1XGwKbDpo9tRW8UDIXCOeLk55qe9ZFGs8MTKU6/M08HWTw52DD/IYhfQtOEhEdPhLMT26Ka/x7p70nd3dzDg==", + ], + + "@typescript-eslint/project-service": [ + "@typescript-eslint/project-service@8.59.0", + "", + { + "dependencies": { + "@typescript-eslint/tsconfig-utils": "^8.59.0", + "@typescript-eslint/types": "^8.59.0", + "debug": "^4.4.3", + }, + "peerDependencies": { "typescript": ">=4.8.4 <6.1.0" }, + }, + "sha512-Lw5ITrR5s5TbC19YSvlr63ZfLaJoU6vtKTHyB0GQOpX0W7d5/Ir6vUahWi/8Sps/nOukZQ0IB3SmlxZnjaKVnw==", + ], + + "@typescript-eslint/scope-manager": [ + "@typescript-eslint/scope-manager@8.59.0", + "", + { + "dependencies": { + "@typescript-eslint/types": "8.59.0", + "@typescript-eslint/visitor-keys": "8.59.0", + }, + }, + "sha512-UzR16Ut8IpA3Mc4DbgAShlPPkVm8xXMWafXxB0BocaVRHs8ZGakAxGRskF7FId3sdk9lgGD73GSFaWmWFDE4dg==", + ], + + "@typescript-eslint/tsconfig-utils": [ + "@typescript-eslint/tsconfig-utils@8.59.0", + "", + { "peerDependencies": { "typescript": ">=4.8.4 <6.1.0" } }, + "sha512-91Sbl3s4Kb3SybliIY6muFBmHVv+pYXfybC4Oolp3dvk8BvIE3wOPc+403CWIT7mJNkfQRGtdqghzs2+Z91Tqg==", + ], + + "@typescript-eslint/types": [ + "@typescript-eslint/types@8.59.0", + "", + {}, + "sha512-nLzdsT1gdOgFxxxwrlNVUBzSNBEEHJ86bblmk4QAS6stfig7rcJzWKqCyxFy3YRRHXDWEkb2NralA1nOYkkm/A==", + ], + + "@typescript-eslint/typescript-estree": [ + "@typescript-eslint/typescript-estree@8.59.0", + "", + { + "dependencies": { + "@typescript-eslint/project-service": "8.59.0", + "@typescript-eslint/tsconfig-utils": "8.59.0", + "@typescript-eslint/types": "8.59.0", + "@typescript-eslint/visitor-keys": "8.59.0", + "debug": "^4.4.3", + "minimatch": "^10.2.2", + "semver": "^7.7.3", + "tinyglobby": "^0.2.15", + "ts-api-utils": "^2.5.0", + }, + "peerDependencies": { "typescript": ">=4.8.4 <6.1.0" }, + }, + "sha512-O9Re9P1BmBLFJyikRbQpLku/QA3/AueZNO9WePLBwQrvkixTmDe8u76B6CYUAITRl/rHawggEqUGn5QIkVRLMw==", + ], + + "@typescript-eslint/visitor-keys": [ + "@typescript-eslint/visitor-keys@8.59.0", + "", + { + "dependencies": { + "@typescript-eslint/types": "8.59.0", + "eslint-visitor-keys": "^5.0.0", + }, + }, + "sha512-/uejZt4dSere1bx12WLlPfv8GktzcaDtuJ7s42/HEZ5zGj9oxRaD4bj7qwSunXkf+pbAhFt2zjpHYUiT5lHf0Q==", + ], + + "@vercel/blob": [ + "@vercel/blob@2.3.3", + "", + { + "dependencies": { + "async-retry": "^1.3.3", + "is-buffer": "^2.0.5", + "is-node-process": "^1.2.0", + "throttleit": "^2.1.0", + "undici": "^6.23.0", + }, + }, + "sha512-MtD7VLo6hU07eHR7bmk5SIMD290q574UaNYTe46qeyRT+hWrCy26CoAqfd7PnIefVXvRehRZBzukxuTO9iGTVg==", + ], + + "@vitest/expect": [ + "@vitest/expect@4.1.5", + "", + { + "dependencies": { + "@standard-schema/spec": "^1.1.0", + "@types/chai": "^5.2.2", + "@vitest/spy": "4.1.5", + "@vitest/utils": "4.1.5", + "chai": "^6.2.2", + "tinyrainbow": "^3.1.0", + }, + }, + "sha512-PWBaRY5JoKuRnHlUHfpV/KohFylaDZTupcXN1H9vYryNLOnitSw60Mw9IAE2r67NbwwzBw/Cc/8q9BK3kIX8Kw==", + ], + + "@vitest/mocker": [ + "@vitest/mocker@4.1.5", + "", + { + "dependencies": { + "@vitest/spy": "4.1.5", + "estree-walker": "^3.0.3", + "magic-string": "^0.30.21", + }, + "peerDependencies": { + "msw": "^2.4.9", + "vite": "^6.0.0 || ^7.0.0 || ^8.0.0", + }, + "optionalPeers": ["msw", "vite"], + }, + "sha512-/x2EmFC4mT4NNzqvC3fmesuV97w5FC903KPmey4gsnJiMQ3Be1IlDKVaDaG8iqaLFHqJ2FVEkxZk5VmeLjIItw==", + ], + + "@vitest/pretty-format": [ + "@vitest/pretty-format@4.1.5", + "", + { "dependencies": { "tinyrainbow": "^3.1.0" } }, + "sha512-7I3q6l5qr03dVfMX2wCo9FxwSJbPdwKjy2uu/YPpU3wfHvIL4QHwVRp57OfGrDFeUJ8/8QdfBKIV12FTtLn00g==", + ], + + "@vitest/runner": [ + "@vitest/runner@4.1.5", + "", + { "dependencies": { "@vitest/utils": "4.1.5", "pathe": "^2.0.3" } }, + "sha512-2D+o7Pr82IEO46YPpoA/YU0neeyr6FTerQb5Ro7BUnBuv6NQtT/kmVnczngiMEBhzgqz2UZYl5gArejsyERDSQ==", + ], + + "@vitest/snapshot": [ + "@vitest/snapshot@4.1.5", + "", + { + "dependencies": { + "@vitest/pretty-format": "4.1.5", + "@vitest/utils": "4.1.5", + "magic-string": "^0.30.21", + "pathe": "^2.0.3", + }, + }, + "sha512-zypXEt4KH/XgKGPUz4eC2AvErYx0My5hfL8oDb1HzGFpEk1P62bxSohdyOmvz+d9UJwanI68MKwr2EquOaOgMQ==", + ], + + "@vitest/spy": [ + "@vitest/spy@4.1.5", + "", + {}, + "sha512-2lNOsh6+R2Idnf1TCZqSwYlKN2E/iDlD8sgU59kYVl+OMDmvldO1VDk39smRfpUNwYpNRVn3w4YfuC7KfbBnkQ==", + ], + + "@vitest/utils": [ + "@vitest/utils@4.1.5", + "", + { + "dependencies": { + "@vitest/pretty-format": "4.1.5", + "convert-source-map": "^2.0.0", + "tinyrainbow": "^3.1.0", + }, + }, + "sha512-76wdkrmfXfqGjueGgnb45ITPyUi1ycZ4IHgC2bhPDUfWHklY/q3MdLOAB+TF1e6xfl8NxNY0ZYaPCFNWSsw3Ug==", + ], + + "acorn": [ + "acorn@8.15.0", + "", + { "bin": { "acorn": "bin/acorn" } }, + "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==", + ], + + "acorn-import-attributes": [ + "acorn-import-attributes@1.9.5", + "", + { "peerDependencies": { "acorn": "^8" } }, + "sha512-n02Vykv5uA3eHGM/Z2dQrcD56kL8TyDb2p1+0P83PClMnC/nc+anbQRhIOWnSq4Ke/KvDPrY3C9hDtC/A3eHnQ==", + ], + + "acorn-jsx": [ + "acorn-jsx@5.3.2", + "", + { "peerDependencies": { "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0" } }, + "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==", + ], + + "ajv": [ + "ajv@6.14.0", + "", + { + "dependencies": { + "fast-deep-equal": "^3.1.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2", + }, + }, + "sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw==", + ], + + "ansi-styles": [ + "ansi-styles@4.3.0", + "", + { "dependencies": { "color-convert": "^2.0.1" } }, + "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + ], + + "array-differ": [ + "array-differ@3.0.0", + "", + {}, + "sha512-THtfYS6KtME/yIAhKjZ2ul7XI96lQGHRputJQHO80LAWQnuGP4iCIN8vdMRboGbIEYBwU33q8Tch1os2+X0kMg==", + ], + + "array-union": [ + "array-union@2.1.0", + "", + {}, + "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==", + ], + + "arrify": [ + "arrify@2.0.1", + "", + {}, + "sha512-3duEwti880xqi4eAMN8AyR4a0ByT90zoYdLlevfrvU43vb0YZwZVfxOgxWrLXXXpyugL0hNZc9G6BiB5B3nUug==", + ], + + "assert": [ + "assert@2.1.0", + "", + { + "dependencies": { + "call-bind": "^1.0.2", + "is-nan": "^1.3.2", + "object-is": "^1.1.5", + "object.assign": "^4.1.4", + "util": "^0.12.5", + }, + }, + "sha512-eLHpSK/Y4nhMJ07gDaAzoX/XAKS8PSaojml3M0DM4JpV1LAi5JOJ/p6H/XWrl8L+DzVEvVCW1z3vWAaB9oTsQw==", + ], + + "assertion-error": [ + "assertion-error@2.0.1", + "", + {}, + "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==", + ], + + "async-retry": [ + "async-retry@1.3.3", + "", + { "dependencies": { "retry": "0.13.1" } }, + "sha512-wfr/jstw9xNi/0teMHrRW7dsz3Lt5ARhYNZ2ewpadnhaIp5mbALhOAP+EAdsC7t4Z6wqsDVv9+W6gm1Dk9mEyw==", + ], + + "available-typed-arrays": [ + "available-typed-arrays@1.0.7", + "", + { "dependencies": { "possible-typed-array-names": "^1.0.0" } }, + "sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==", + ], + + "balanced-match": [ + "balanced-match@4.0.4", + "", + {}, + "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==", + ], + + "brace-expansion": [ + "brace-expansion@5.0.5", + "", + { "dependencies": { "balanced-match": "^4.0.2" } }, + "sha512-VZznLgtwhn+Mact9tfiwx64fA9erHH/MCXEUfB/0bX/6Fz6ny5EGTXYltMocqg4xFAQZtnO3DHWWXi8RiuN7cQ==", + ], + + "bun-types": [ + "bun-types@1.3.12", + "", + { "dependencies": { "@types/node": "*" } }, + "sha512-HqOLj5PoFajAQciOMRiIZGNoKxDJSr6qigAttOX40vJuSp6DN/CxWp9s3C1Xwm4oH7ybueITwiaOcWXoYVoRkA==", + ], + + "call-bind": [ + "call-bind@1.0.9", + "", + { + "dependencies": { + "call-bind-apply-helpers": "^1.0.2", + "es-define-property": "^1.0.1", + "get-intrinsic": "^1.3.0", + "set-function-length": "^1.2.2", + }, + }, + "sha512-a/hy+pNsFUTR+Iz8TCJvXudKVLAnz/DyeSUo10I5yvFDQJBFU2s9uqQpoSrJlroHUKoKqzg+epxyP9lqFdzfBQ==", + ], + + "call-bind-apply-helpers": [ + "call-bind-apply-helpers@1.0.2", + "", + { "dependencies": { "es-errors": "^1.3.0", "function-bind": "^1.1.2" } }, + "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==", + ], + + "call-bound": [ + "call-bound@1.0.4", + "", + { + "dependencies": { + "call-bind-apply-helpers": "^1.0.2", + "get-intrinsic": "^1.3.0", + }, + }, + "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==", + ], + + "chai": [ + "chai@6.2.2", + "", + {}, + "sha512-NUPRluOfOiTKBKvWPtSD4PhFvWCqOi0BGStNWs57X9js7XGTprSmFoz5F0tWhR4WPjNeR9jXqdC7/UpSJTnlRg==", + ], + + "chalk": [ + "chalk@4.1.2", + "", + { + "dependencies": { "ansi-styles": "^4.1.0", "supports-color": "^7.1.0" }, + }, + "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + ], + + "chance": [ + "chance@1.1.13", + "", + {}, + "sha512-V6lQCljcLznE7tUYUM9EOAnnKXbctE6j/rdQkYOHIWbfGQbrzTsAXNW9CdU5XCo4ArXQCj/rb6HgxPlmGJcaUg==", + ], + + "char-regex": [ + "char-regex@1.0.2", + "", + {}, + "sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw==", + ], + + "charenc": [ + "charenc@0.0.2", + "", + {}, + "sha512-yrLQ/yVUFXkzg7EDQsPieE/53+0RlaWTs+wBrvW36cyilJ2SaDWfl4Yj7MtLTXleV9uEKefbAGUPv2/iWSooRA==", + ], + + "chownr": [ + "chownr@3.0.0", + "", + {}, + "sha512-+IxzY9BZOQd/XuYPRmrvEVjF/nqj5kgT4kEq7VofrDoM1MxoRjEWkrCC3EtLi59TVawxTAn+orJwFQcrqEN1+g==", + ], + + "class-validator": [ + "class-validator@0.14.3", + "", + { + "dependencies": { + "@types/validator": "^13.15.3", + "libphonenumber-js": "^1.11.1", + "validator": "^13.15.20", + }, + }, + "sha512-rXXekcjofVN1LTOSw+u4u9WXVEUvNBVjORW154q/IdmYWy1nMbOU9aNtZB0t8m+FJQ9q91jlr2f9CwwUFdFMRA==", + ], + + "color-convert": [ + "color-convert@2.0.1", + "", + { "dependencies": { "color-name": "~1.1.4" } }, + "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + ], + + "color-name": [ + "color-name@1.1.4", + "", + {}, + "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + ], + + "commander": [ + "commander@12.1.0", + "", + {}, + "sha512-Vw8qHK3bZM9y/P10u3Vib8o/DdkvA2OtPtZvD871QKjy74Wj1WSKFILMPRPSdUSx5RFK1arlJzEtA4PkFgnbuA==", + ], + + "concat-map": [ + "concat-map@0.0.1", + "", + {}, + "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==", + ], + + "convert-source-map": [ + "convert-source-map@2.0.0", + "", + {}, + "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==", + ], + + "cross-spawn": [ + "cross-spawn@7.0.6", + "", + { + "dependencies": { + "path-key": "^3.1.0", + "shebang-command": "^2.0.0", + "which": "^2.0.1", + }, + }, + "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==", + ], + + "crypt": [ + "crypt@0.0.2", + "", + {}, + "sha512-mCxBlsHFYh9C+HVpiEacem8FEBnMXgU9gy4zmNC+SXAZNB/1idgp/aulFJ4FgCi7GPEVbfyng092GqL2k2rmow==", + ], + + "curve25519-js": [ + "curve25519-js@0.0.4", + "", + {}, + "sha512-axn2UMEnkhyDUPWOwVKBMVIzSQy2ejH2xRGy1wq81dqRwApXfIzfbE3hIX0ZRFBIihf/KDqK158DLwESu4AK1w==", + ], + + "debug": [ + "debug@4.4.3", + "", + { "dependencies": { "ms": "^2.1.3" } }, + "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + ], + + "deep-is": [ + "deep-is@0.1.4", + "", + {}, + "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==", + ], + + "define-data-property": [ + "define-data-property@1.1.4", + "", + { + "dependencies": { + "es-define-property": "^1.0.0", + "es-errors": "^1.3.0", + "gopd": "^1.0.1", + }, + }, + "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==", + ], + + "define-properties": [ + "define-properties@1.2.1", + "", + { + "dependencies": { + "define-data-property": "^1.0.1", + "has-property-descriptors": "^1.0.0", + "object-keys": "^1.1.1", + }, + }, + "sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==", + ], + + "detect-libc": [ + "detect-libc@2.1.2", + "", + {}, + "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==", + ], + + "dunder-proto": [ + "dunder-proto@1.0.1", + "", + { + "dependencies": { + "call-bind-apply-helpers": "^1.0.1", + "es-errors": "^1.3.0", + "gopd": "^1.2.0", + }, + }, + "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==", + ], + + "env-paths": [ + "env-paths@4.0.0", + "", + { "dependencies": { "is-safe-filename": "^0.1.0" } }, + "sha512-pxP8eL2SwwaTRi/KHYwLYXinDs7gL3jxFcBYmEdYfZmZXbaVDvdppd0XBU8qVz03rDfKZMXg1omHCbsJjZrMsw==", + ], + + "es-define-property": [ + "es-define-property@1.0.1", + "", + {}, + "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==", + ], + + "es-errors": [ + "es-errors@1.3.0", + "", + {}, + "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==", + ], + + "es-module-lexer": [ + "es-module-lexer@2.0.0", + "", + {}, + "sha512-5POEcUuZybH7IdmGsD8wlf0AI55wMecM9rVBTI/qEAy2c1kTOm3DjFYjrBdI2K3BaJjJYfYFeRtM0t9ssnRuxw==", + ], + + "es-object-atoms": [ + "es-object-atoms@1.1.1", + "", + { "dependencies": { "es-errors": "^1.3.0" } }, + "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==", + ], + + "escape-string-regexp": [ + "escape-string-regexp@4.0.0", + "", + {}, + "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", + ], + + "eslint": [ + "eslint@10.2.1", + "", + { + "dependencies": { + "@eslint-community/eslint-utils": "^4.8.0", + "@eslint-community/regexpp": "^4.12.2", + "@eslint/config-array": "^0.23.5", + "@eslint/config-helpers": "^0.5.5", + "@eslint/core": "^1.2.1", + "@eslint/plugin-kit": "^0.7.1", + "@humanfs/node": "^0.16.6", + "@humanwhocodes/module-importer": "^1.0.1", + "@humanwhocodes/retry": "^0.4.2", + "@types/estree": "^1.0.6", + "ajv": "^6.14.0", + "cross-spawn": "^7.0.6", + "debug": "^4.3.2", + "escape-string-regexp": "^4.0.0", + "eslint-scope": "^9.1.2", + "eslint-visitor-keys": "^5.0.1", + "espree": "^11.2.0", + "esquery": "^1.7.0", + "esutils": "^2.0.2", + "fast-deep-equal": "^3.1.3", + "file-entry-cache": "^8.0.0", + "find-up": "^5.0.0", + "glob-parent": "^6.0.2", + "ignore": "^5.2.0", + "imurmurhash": "^0.1.4", + "is-glob": "^4.0.0", + "json-stable-stringify-without-jsonify": "^1.0.1", + "minimatch": "^10.2.4", + "natural-compare": "^1.4.0", + "optionator": "^0.9.3", + }, + "peerDependencies": { "jiti": "*" }, + "optionalPeers": ["jiti"], + "bin": { "eslint": "bin/eslint.js" }, + }, + "sha512-wiyGaKsDgqXvF40P8mDwiUp/KQjE1FdrIEJsM8PZ3XCiniTMXS3OHWWUe5FI5agoCnr8x4xPrTDZuxsBlNHl+Q==", + ], + + "eslint-plugin-simple-import-sort": [ + "eslint-plugin-simple-import-sort@13.0.0", + "", + { "peerDependencies": { "eslint": ">=5.0.0" } }, + "sha512-McAc+/Nlvcg4byY/CABGH8kqnefWBj8s3JA2okEtz8ixbECQgU46p0HkTUKa4YS7wvgGceimlc34p1nXqbWqtA==", + ], + + "eslint-scope": [ + "eslint-scope@8.4.0", + "", + { "dependencies": { "esrecurse": "^4.3.0", "estraverse": "^5.2.0" } }, + "sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg==", + ], + + "eslint-visitor-keys": [ + "eslint-visitor-keys@4.2.1", + "", + {}, + "sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==", + ], + + "espree": [ + "espree@11.2.0", + "", + { + "dependencies": { + "acorn": "^8.16.0", + "acorn-jsx": "^5.3.2", + "eslint-visitor-keys": "^5.0.1", + }, + }, + "sha512-7p3DrVEIopW1B1avAGLuCSh1jubc01H2JHc8B4qqGblmg5gI9yumBgACjWo4JlIc04ufug4xJ3SQI8HkS/Rgzw==", + ], + + "esprima": [ + "esprima@4.0.1", + "", + { + "bin": { + "esparse": "./bin/esparse.js", + "esvalidate": "./bin/esvalidate.js", + }, + }, + "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==", + ], + + "esquery": [ + "esquery@1.7.0", + "", + { "dependencies": { "estraverse": "^5.1.0" } }, + "sha512-Ap6G0WQwcU/LHsvLwON1fAQX9Zp0A2Y6Y/cJBl9r/JbW90Zyg4/zbG6zzKa2OTALELarYHmKu0GhpM5EO+7T0g==", + ], + + "esrecurse": [ + "esrecurse@4.3.0", + "", + { "dependencies": { "estraverse": "^5.2.0" } }, + "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==", + ], + + "estraverse": [ + "estraverse@5.3.0", + "", + {}, + "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==", + ], + + "estree-walker": [ + "estree-walker@3.0.3", + "", + { "dependencies": { "@types/estree": "^1.0.0" } }, + "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==", + ], + + "esutils": [ + "esutils@2.0.3", + "", + {}, + "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==", + ], + + "expect-type": [ + "expect-type@1.3.0", + "", + {}, + "sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==", + ], + + "fast-deep-equal": [ + "fast-deep-equal@3.1.3", + "", + {}, + "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==", + ], + + "fast-json-stable-stringify": [ + "fast-json-stable-stringify@2.1.0", + "", + {}, + "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==", + ], + + "fast-levenshtein": [ + "fast-levenshtein@2.0.6", + "", + {}, + "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==", + ], + + "fdir": [ + "fdir@6.5.0", + "", + { + "peerDependencies": { "picomatch": "^3 || ^4" }, + "optionalPeers": ["picomatch"], + }, + "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==", + ], + + "fflate": [ + "fflate@0.8.2", + "", + {}, + "sha512-cPJU47OaAoCbg0pBvzsgpTPhmhqI5eJjh/JIu8tPj5q+T7iLvW/JAYUqmE7KOB4R1ZyEhzBaIQpQpardBF5z8A==", + ], + + "file-entry-cache": [ + "file-entry-cache@8.0.0", + "", + { "dependencies": { "flat-cache": "^4.0.0" } }, + "sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==", + ], + + "find-up": [ + "find-up@5.0.0", + "", + { "dependencies": { "locate-path": "^6.0.0", "path-exists": "^4.0.0" } }, + "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", + ], + + "flat-cache": [ + "flat-cache@4.0.1", + "", + { "dependencies": { "flatted": "^3.2.9", "keyv": "^4.5.4" } }, + "sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==", + ], + + "flatted": [ + "flatted@3.4.2", + "", + {}, + "sha512-PjDse7RzhcPkIJwy5t7KPWQSZ9cAbzQXcafsetQoD7sOJRQlGikNbx7yZp2OotDnJyrDcbyRq3Ttb18iYOqkxA==", + ], + + "for-each": [ + "for-each@0.3.5", + "", + { "dependencies": { "is-callable": "^1.2.7" } }, + "sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg==", + ], + + "fsevents": [ + "fsevents@2.3.3", + "", + { "os": "darwin" }, + "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + ], + + "function-bind": [ + "function-bind@1.1.2", + "", + {}, + "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==", + ], + + "generator-function": [ + "generator-function@2.0.1", + "", + {}, + "sha512-SFdFmIJi+ybC0vjlHN0ZGVGHc3lgE0DxPAT0djjVg+kjOnSqclqmj0KQ7ykTOLP6YxoqOvuAODGdcHJn+43q3g==", + ], + + "get-intrinsic": [ + "get-intrinsic@1.3.0", + "", + { + "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", + }, + }, + "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==", + ], + + "get-proto": [ + "get-proto@1.0.1", + "", + { + "dependencies": { + "dunder-proto": "^1.0.1", + "es-object-atoms": "^1.0.0", + }, + }, + "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==", + ], + + "glob-parent": [ + "glob-parent@6.0.2", + "", + { "dependencies": { "is-glob": "^4.0.3" } }, + "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==", + ], + + "gopd": [ + "gopd@1.2.0", + "", + {}, + "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==", + ], + + "has-flag": [ + "has-flag@4.0.0", + "", + {}, + "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + ], + + "has-property-descriptors": [ + "has-property-descriptors@1.0.2", + "", + { "dependencies": { "es-define-property": "^1.0.0" } }, + "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==", + ], + + "has-symbols": [ + "has-symbols@1.1.0", + "", + {}, + "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==", + ], + + "has-tostringtag": [ + "has-tostringtag@1.0.2", + "", + { "dependencies": { "has-symbols": "^1.0.3" } }, + "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==", + ], + + "hasown": [ + "hasown@2.0.2", + "", + { "dependencies": { "function-bind": "^1.1.2" } }, + "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==", + ], + + "ignore": [ + "ignore@5.3.2", + "", + {}, + "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==", + ], + + "imurmurhash": [ + "imurmurhash@0.1.4", + "", + {}, + "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==", + ], + + "inherits": [ + "inherits@2.0.4", + "", + {}, + "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", + ], + + "inversify": [ + "inversify@6.1.4", + "", + { + "dependencies": { + "@inversifyjs/common": "1.3.3", + "@inversifyjs/core": "1.3.4", + }, + }, + "sha512-PbxrZH/gTa1fpPEEGAjJQzK8tKMIp5gRg6EFNJlCtzUcycuNdmhv3uk5P8Itm/RIjgHJO16oQRLo9IHzQN51bA==", + ], + + "is-arguments": [ + "is-arguments@1.2.0", + "", + { + "dependencies": { "call-bound": "^1.0.2", "has-tostringtag": "^1.0.2" }, + }, + "sha512-7bVbi0huj/wrIAOzb8U1aszg9kdi3KN/CyU19CTI7tAoZYEZoL9yCDXpbXN+uPsuWnP02cyug1gleqq+TU+YCA==", + ], + + "is-buffer": [ + "is-buffer@2.0.5", + "", + {}, + "sha512-i2R6zNFDwgEHJyQUtJEk0XFi1i0dPFn/oqjK3/vPCcDeJvW5NQ83V8QbicfF1SupOaB0h8ntgBC2YiE7dfyctQ==", + ], + + "is-callable": [ + "is-callable@1.2.7", + "", + {}, + "sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==", + ], + + "is-extglob": [ + "is-extglob@2.1.1", + "", + {}, + "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==", + ], + + "is-generator-function": [ + "is-generator-function@1.1.2", + "", + { + "dependencies": { + "call-bound": "^1.0.4", + "generator-function": "^2.0.0", + "get-proto": "^1.0.1", + "has-tostringtag": "^1.0.2", + "safe-regex-test": "^1.1.0", + }, + }, + "sha512-upqt1SkGkODW9tsGNG5mtXTXtECizwtS2kA161M+gJPc1xdb/Ax629af6YrTwcOeQHbewrPNlE5Dx7kzvXTizA==", + ], + + "is-glob": [ + "is-glob@4.0.3", + "", + { "dependencies": { "is-extglob": "^2.1.1" } }, + "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", + ], + + "is-nan": [ + "is-nan@1.3.2", + "", + { + "dependencies": { + "call-bind": "^1.0.0", + "define-properties": "^1.1.3", + }, + }, + "sha512-E+zBKpQ2t6MEo1VsonYmluk9NxGrbzpeeLC2xIViuO2EjU2xsXsBPwTr3Ykv9l08UYEVEdWeRZNouaZqF6RN0w==", + ], + + "is-network-error": [ + "is-network-error@1.3.1", + "", + {}, + "sha512-6QCxa49rQbmUWLfk0nuGqzql9U8uaV2H6279bRErPBHe/109hCzsLUBUHfbEtvLIHBd6hyXbgedBSHevm43Edw==", + ], + + "is-node-process": [ + "is-node-process@1.2.0", + "", + {}, + "sha512-Vg4o6/fqPxIjtxgUH5QLJhwZ7gW5diGCVlXpuUfELC62CuxM1iHcRe51f2W1FDy04Ai4KJkagKjx3XaqyfRKXw==", + ], + + "is-regex": [ + "is-regex@1.2.1", + "", + { + "dependencies": { + "call-bound": "^1.0.2", + "gopd": "^1.2.0", + "has-tostringtag": "^1.0.2", + "hasown": "^2.0.2", + }, + }, + "sha512-MjYsKHO5O7mCsmRGxWcLWheFqN9DJ/2TmngvjKXihe6efViPqc274+Fx/4fYj/r03+ESvBdTXK0V6tA3rgez1g==", + ], + + "is-safe-filename": [ + "is-safe-filename@0.1.1", + "", + {}, + "sha512-4SrR7AdnY11LHfDKTZY1u6Ga3RuxZdl3YKWWShO5iyuG5h8QS4GD2tOb04peBJ5I7pXbR+CGBNEhTcwK+FzN3g==", + ], + + "is-typed-array": [ + "is-typed-array@1.1.15", + "", + { "dependencies": { "which-typed-array": "^1.1.16" } }, + "sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==", + ], + + "isexe": [ + "isexe@2.0.0", + "", + {}, + "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", + ], + + "javascript-obfuscator": [ + "javascript-obfuscator@5.4.1", + "", + { + "dependencies": { + "@javascript-obfuscator/escodegen": "2.4.1", + "@javascript-obfuscator/estraverse": "5.4.0", + "@vercel/blob": ">=0.23.0", + "acorn": "8.15.0", + "acorn-import-attributes": "^1.9.5", + "assert": "2.1.0", + "chalk": "4.1.2", + "chance": "1.1.13", + "class-validator": "0.14.3", + "commander": "12.1.0", + "env-paths": "4.0.0", + "eslint-scope": "8.4.0", + "eslint-visitor-keys": "4.2.1", + "fast-deep-equal": "3.1.3", + "inversify": "6.1.4", + "js-string-escape": "1.0.1", + "md5": "2.3.0", + "multimatch": "5.0.0", + "process": "0.11.10", + "reflect-metadata": "0.2.2", + "string-template": "1.0.0", + "stringz": "2.1.0", + "tslib": "2.8.1", + }, + "bin": { "javascript-obfuscator": "bin/javascript-obfuscator" }, + }, + "sha512-HoG2vdmo0xM37YQtcjYXNBTlRvypW5G6gtTMFrCBzLkVMLWQy97+XISDNL1DUMfKQQ6Njp8SddfPJix1h2FhVg==", + ], + + "js-string-escape": [ + "js-string-escape@1.0.1", + "", + {}, + "sha512-Smw4xcfIQ5LVjAOuJCvN/zIodzA/BBSsluuoSykP+lUvScIi4U6RJLfwHet5cxFnCswUjISV8oAXaqaJDY3chg==", + ], + + "json-buffer": [ + "json-buffer@3.0.1", + "", + {}, + "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==", + ], + + "json-schema-traverse": [ + "json-schema-traverse@0.4.1", + "", + {}, + "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==", + ], + + "json-stable-stringify-without-jsonify": [ + "json-stable-stringify-without-jsonify@1.0.1", + "", + {}, + "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==", + ], + + "keyv": [ + "keyv@4.5.4", + "", + { "dependencies": { "json-buffer": "3.0.1" } }, + "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==", + ], + + "levn": [ + "levn@0.4.1", + "", + { "dependencies": { "prelude-ls": "^1.2.1", "type-check": "~0.4.0" } }, + "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==", + ], + + "libphonenumber-js": [ + "libphonenumber-js@1.12.41", + "", + {}, + "sha512-lsmMmGXBxXIK/VMLEj0kL6MtUs1kBGj1nTCzi6zgQoG1DEwqwt2DQyHxcLykceIxAnfE3hya7NuIh6PpC6S3fA==", + ], + + "lightningcss": [ + "lightningcss@1.32.0", + "", + { + "dependencies": { "detect-libc": "^2.0.3" }, + "optionalDependencies": { + "lightningcss-android-arm64": "1.32.0", + "lightningcss-darwin-arm64": "1.32.0", + "lightningcss-darwin-x64": "1.32.0", + "lightningcss-freebsd-x64": "1.32.0", + "lightningcss-linux-arm-gnueabihf": "1.32.0", + "lightningcss-linux-arm64-gnu": "1.32.0", + "lightningcss-linux-arm64-musl": "1.32.0", + "lightningcss-linux-x64-gnu": "1.32.0", + "lightningcss-linux-x64-musl": "1.32.0", + "lightningcss-win32-arm64-msvc": "1.32.0", + "lightningcss-win32-x64-msvc": "1.32.0", + }, + }, + "sha512-NXYBzinNrblfraPGyrbPoD19C1h9lfI/1mzgWYvXUTe414Gz/X1FD2XBZSZM7rRTrMA8JL3OtAaGifrIKhQ5yQ==", + ], + + "lightningcss-android-arm64": [ + "lightningcss-android-arm64@1.32.0", + "", + { "os": "android", "cpu": "arm64" }, + "sha512-YK7/ClTt4kAK0vo6w3X+Pnm0D2cf2vPHbhOXdoNti1Ga0al1P4TBZhwjATvjNwLEBCnKvjJc2jQgHXH0NEwlAg==", + ], + + "lightningcss-darwin-arm64": [ + "lightningcss-darwin-arm64@1.32.0", + "", + { "os": "darwin", "cpu": "arm64" }, + "sha512-RzeG9Ju5bag2Bv1/lwlVJvBE3q6TtXskdZLLCyfg5pt+HLz9BqlICO7LZM7VHNTTn/5PRhHFBSjk5lc4cmscPQ==", + ], + + "lightningcss-darwin-x64": [ + "lightningcss-darwin-x64@1.32.0", + "", + { "os": "darwin", "cpu": "x64" }, + "sha512-U+QsBp2m/s2wqpUYT/6wnlagdZbtZdndSmut/NJqlCcMLTWp5muCrID+K5UJ6jqD2BFshejCYXniPDbNh73V8w==", + ], + + "lightningcss-freebsd-x64": [ + "lightningcss-freebsd-x64@1.32.0", + "", + { "os": "freebsd", "cpu": "x64" }, + "sha512-JCTigedEksZk3tHTTthnMdVfGf61Fky8Ji2E4YjUTEQX14xiy/lTzXnu1vwiZe3bYe0q+SpsSH/CTeDXK6WHig==", + ], + + "lightningcss-linux-arm-gnueabihf": [ + "lightningcss-linux-arm-gnueabihf@1.32.0", + "", + { "os": "linux", "cpu": "arm" }, + "sha512-x6rnnpRa2GL0zQOkt6rts3YDPzduLpWvwAF6EMhXFVZXD4tPrBkEFqzGowzCsIWsPjqSK+tyNEODUBXeeVHSkw==", + ], + + "lightningcss-linux-arm64-gnu": [ + "lightningcss-linux-arm64-gnu@1.32.0", + "", + { "os": "linux", "cpu": "arm64" }, + "sha512-0nnMyoyOLRJXfbMOilaSRcLH3Jw5z9HDNGfT/gwCPgaDjnx0i8w7vBzFLFR1f6CMLKF8gVbebmkUN3fa/kQJpQ==", + ], + + "lightningcss-linux-arm64-musl": [ + "lightningcss-linux-arm64-musl@1.32.0", + "", + { "os": "linux", "cpu": "arm64" }, + "sha512-UpQkoenr4UJEzgVIYpI80lDFvRmPVg6oqboNHfoH4CQIfNA+HOrZ7Mo7KZP02dC6LjghPQJeBsvXhJod/wnIBg==", + ], + + "lightningcss-linux-x64-gnu": [ + "lightningcss-linux-x64-gnu@1.32.0", + "", + { "os": "linux", "cpu": "x64" }, + "sha512-V7Qr52IhZmdKPVr+Vtw8o+WLsQJYCTd8loIfpDaMRWGUZfBOYEJeyJIkqGIDMZPwPx24pUMfwSxxI8phr/MbOA==", + ], + + "lightningcss-linux-x64-musl": [ + "lightningcss-linux-x64-musl@1.32.0", + "", + { "os": "linux", "cpu": "x64" }, + "sha512-bYcLp+Vb0awsiXg/80uCRezCYHNg1/l3mt0gzHnWV9XP1W5sKa5/TCdGWaR/zBM2PeF/HbsQv/j2URNOiVuxWg==", + ], + + "lightningcss-win32-arm64-msvc": [ + "lightningcss-win32-arm64-msvc@1.32.0", + "", + { "os": "win32", "cpu": "arm64" }, + "sha512-8SbC8BR40pS6baCM8sbtYDSwEVQd4JlFTOlaD3gWGHfThTcABnNDBda6eTZeqbofalIJhFx0qKzgHJmcPTnGdw==", + ], + + "lightningcss-win32-x64-msvc": [ + "lightningcss-win32-x64-msvc@1.32.0", + "", + { "os": "win32", "cpu": "x64" }, + "sha512-Amq9B/SoZYdDi1kFrojnoqPLxYhQ4Wo5XiL8EVJrVsB8ARoC1PWW6VGtT0WKCemjy8aC+louJnjS7U18x3b06Q==", + ], + + "locate-path": [ + "locate-path@6.0.0", + "", + { "dependencies": { "p-locate": "^5.0.0" } }, + "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", + ], + + "lodash": [ + "lodash@4.18.1", + "", + {}, + "sha512-dMInicTPVE8d1e5otfwmmjlxkZoUpiVLwyeTdUsi/Caj/gfzzblBcCE5sRHV/AsjuCmxWrte2TNGSYuCeCq+0Q==", + ], + + "long": [ + "long@5.3.2", + "", + {}, + "sha512-mNAgZ1GmyNhD7AuqnTG3/VQ26o760+ZYBPKjPvugO8+nLbYfX6TVpJPseBvopbdY+qpZ/lKUnmEc1LeZYS3QAA==", + ], + + "magic-string": [ + "magic-string@0.30.21", + "", + { "dependencies": { "@jridgewell/sourcemap-codec": "^1.5.5" } }, + "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==", + ], + + "math-intrinsics": [ + "math-intrinsics@1.1.0", + "", + {}, + "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==", + ], + + "md5": [ + "md5@2.3.0", + "", + { + "dependencies": { + "charenc": "0.0.2", + "crypt": "0.0.2", + "is-buffer": "~1.1.6", + }, + }, + "sha512-T1GITYmFaKuO91vxyoQMFETst+O71VUPEU3ze5GNzDm0OWdP8v1ziTaAEPUr/3kLsY3Sftgz242A1SetQiDL7g==", + ], + + "minimatch": [ + "minimatch@10.2.5", + "", + { "dependencies": { "brace-expansion": "^5.0.5" } }, + "sha512-MULkVLfKGYDFYejP07QOurDLLQpcjk7Fw+7jXS2R2czRQzR56yHRveU5NDJEOviH+hETZKSkIk5c+T23GjFUMg==", + ], + + "minipass": [ + "minipass@7.1.3", + "", + {}, + "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==", + ], + + "minizlib": [ + "minizlib@3.1.0", + "", + { "dependencies": { "minipass": "^7.1.2" } }, + "sha512-KZxYo1BUkWD2TVFLr0MQoM8vUUigWD3LlD83a/75BqC+4qE0Hb1Vo5v1FgcfaNXvfXzr+5EhQ6ing/CaBijTlw==", + ], + + "ms": [ + "ms@2.1.3", + "", + {}, + "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + ], + + "multimatch": [ + "multimatch@5.0.0", + "", + { + "dependencies": { + "@types/minimatch": "^3.0.3", + "array-differ": "^3.0.0", + "array-union": "^2.1.0", + "arrify": "^2.0.1", + "minimatch": "^3.0.4", + }, + }, + "sha512-ypMKuglUrZUD99Tk2bUQ+xNQj43lPEfAeX2o9cTteAmShXy2VHDJpuwu1o0xqoKCt9jLVAvwyFKdLTPXKAfJyA==", + ], + + "nanoid": [ + "nanoid@3.3.11", + "", + { "bin": { "nanoid": "bin/nanoid.cjs" } }, + "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==", + ], + + "natural-compare": [ + "natural-compare@1.4.0", + "", + {}, + "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==", + ], + + "object-is": [ + "object-is@1.1.6", + "", + { + "dependencies": { + "call-bind": "^1.0.7", + "define-properties": "^1.2.1", + }, + }, + "sha512-F8cZ+KfGlSGi09lJT7/Nd6KJZ9ygtvYC0/UYYLI9nmQKLMnydpB9yvbv9K1uSkEu7FU9vYPmVwLg328tX+ot3Q==", + ], + + "object-keys": [ + "object-keys@1.1.1", + "", + {}, + "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==", + ], + + "object.assign": [ + "object.assign@4.1.7", + "", + { + "dependencies": { + "call-bind": "^1.0.8", + "call-bound": "^1.0.3", + "define-properties": "^1.2.1", + "es-object-atoms": "^1.0.0", + "has-symbols": "^1.1.0", + "object-keys": "^1.1.1", + }, + }, + "sha512-nK28WOo+QIjBkDduTINE4JkF/UJJKyf2EJxvJKfblDpyg0Q+pkOHNTL0Qwy6NP6FhE/EnzV73BxxqcJaXY9anw==", + ], + + "obug": [ + "obug@2.1.1", + "", + {}, + "sha512-uTqF9MuPraAQ+IsnPf366RG4cP9RtUi7MLO1N3KEc+wb0a6yKpeL0lmk2IB1jY5KHPAlTc6T/JRdC/YqxHNwkQ==", + ], + + "optionator": [ + "optionator@0.9.4", + "", + { + "dependencies": { + "deep-is": "^0.1.3", + "fast-levenshtein": "^2.0.6", + "levn": "^0.4.1", + "prelude-ls": "^1.2.1", + "type-check": "^0.4.0", + "word-wrap": "^1.2.5", + }, + }, + "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==", + ], + + "p-limit": [ + "p-limit@3.1.0", + "", + { "dependencies": { "yocto-queue": "^0.1.0" } }, + "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", + ], + + "p-locate": [ + "p-locate@5.0.0", + "", + { "dependencies": { "p-limit": "^3.0.2" } }, + "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", + ], + + "p-retry": [ + "p-retry@6.2.1", + "", + { + "dependencies": { + "@types/retry": "0.12.2", + "is-network-error": "^1.0.0", + "retry": "^0.13.1", + }, + }, + "sha512-hEt02O4hUct5wtwg4H4KcWgDdm+l1bOaEy/hWzd8xtXB9BqxTWBBhb+2ImAtH4Cv4rPjV76xN3Zumqk3k3AhhQ==", + ], + + "path-exists": [ + "path-exists@4.0.0", + "", + {}, + "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", + ], + + "path-key": [ + "path-key@3.1.1", + "", + {}, + "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", + ], + + "pathe": [ + "pathe@2.0.3", + "", + {}, + "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==", + ], + + "picocolors": [ + "picocolors@1.1.1", + "", + {}, + "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==", + ], + + "picomatch": [ + "picomatch@4.0.4", + "", + {}, + "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==", + ], + + "possible-typed-array-names": [ + "possible-typed-array-names@1.1.0", + "", + {}, + "sha512-/+5VFTchJDoVj3bhoqi6UeymcD00DAwb1nJwamzPvHEszJ4FpF6SNNbUbOS8yI56qHzdV8eK0qEfOSiodkTdxg==", + ], + + "postcss": [ + "postcss@8.5.10", + "", + { + "dependencies": { + "nanoid": "^3.3.11", + "picocolors": "^1.1.1", + "source-map-js": "^1.2.1", + }, + }, + "sha512-pMMHxBOZKFU6HgAZ4eyGnwXF/EvPGGqUr0MnZ5+99485wwW41kW91A4LOGxSHhgugZmSChL5AlElNdwlNgcnLQ==", + ], + + "prelude-ls": [ + "prelude-ls@1.2.1", + "", + {}, + "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==", + ], + + "process": [ + "process@0.11.10", + "", + {}, + "sha512-cdGef/drWFoydD1JsMzuFf8100nZl+GT+yacc2bEced5f9Rjk4z+WtFUTBu9PhOi9j/jfmBPu0mMEY4wIdAF8A==", + ], + + "protobufjs": [ + "protobufjs@7.5.6", + "", + { + "dependencies": { + "@protobufjs/aspromise": "^1.1.2", + "@protobufjs/base64": "^1.1.2", + "@protobufjs/codegen": "^2.0.5", + "@protobufjs/eventemitter": "^1.1.0", + "@protobufjs/fetch": "^1.1.0", + "@protobufjs/float": "^1.0.2", + "@protobufjs/inquire": "^1.1.1", + "@protobufjs/path": "^1.1.2", + "@protobufjs/pool": "^1.1.0", + "@protobufjs/utf8": "^1.1.1", + "@types/node": ">=13.7.0", + "long": "^5.0.0", + }, + }, + "sha512-M71sTMB146U3u0di3yup8iM+zv8yPRNQVr1KK4tyBitl3qFvEGucq/rGDRShD2rsJhtN02RJaJ7j5X5hmy8SJg==", + ], + + "punycode": [ + "punycode@2.3.1", + "", + {}, + "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==", + ], + + "reflect-metadata": [ + "reflect-metadata@0.2.2", + "", + {}, + "sha512-urBwgfrvVP/eAyXx4hluJivBKzuEbSQs9rKWCrCkbSxNv8mxPcUZKeuoF3Uy4mJl3Lwprp6yy5/39VWigZ4K6Q==", + ], + + "retry": [ + "retry@0.13.1", + "", + {}, + "sha512-XQBQ3I8W1Cge0Seh+6gjj03LbmRFWuoszgK9ooCpwYIrhhoO80pfq4cUkU5DkknwfOfFteRwlZ56PYOGYyFWdg==", + ], + + "rolldown": [ + "rolldown@1.0.0-rc.16", + "", + { + "dependencies": { + "@oxc-project/types": "=0.126.0", + "@rolldown/pluginutils": "1.0.0-rc.16", + }, + "optionalDependencies": { + "@rolldown/binding-android-arm64": "1.0.0-rc.16", + "@rolldown/binding-darwin-arm64": "1.0.0-rc.16", + "@rolldown/binding-darwin-x64": "1.0.0-rc.16", + "@rolldown/binding-freebsd-x64": "1.0.0-rc.16", + "@rolldown/binding-linux-arm-gnueabihf": "1.0.0-rc.16", + "@rolldown/binding-linux-arm64-gnu": "1.0.0-rc.16", + "@rolldown/binding-linux-arm64-musl": "1.0.0-rc.16", + "@rolldown/binding-linux-ppc64-gnu": "1.0.0-rc.16", + "@rolldown/binding-linux-s390x-gnu": "1.0.0-rc.16", + "@rolldown/binding-linux-x64-gnu": "1.0.0-rc.16", + "@rolldown/binding-linux-x64-musl": "1.0.0-rc.16", + "@rolldown/binding-openharmony-arm64": "1.0.0-rc.16", + "@rolldown/binding-wasm32-wasi": "1.0.0-rc.16", + "@rolldown/binding-win32-arm64-msvc": "1.0.0-rc.16", + "@rolldown/binding-win32-x64-msvc": "1.0.0-rc.16", + }, + "bin": { "rolldown": "bin/cli.mjs" }, + }, + "sha512-rzi5WqKzEZw3SooTt7cgm4eqIoujPIyGcJNGFL7iPEuajQw7vxMHUkXylu4/vhCkJGXsgRmxqMKXUpT6FEgl0g==", + ], + + "safe-regex-test": [ + "safe-regex-test@1.1.0", + "", + { + "dependencies": { + "call-bound": "^1.0.2", + "es-errors": "^1.3.0", + "is-regex": "^1.2.1", + }, + }, + "sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw==", + ], + + "semver": [ + "semver@7.7.3", + "", + { "bin": { "semver": "bin/semver.js" } }, + "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==", + ], + + "set-function-length": [ + "set-function-length@1.2.2", + "", + { + "dependencies": { + "define-data-property": "^1.1.4", + "es-errors": "^1.3.0", + "function-bind": "^1.1.2", + "get-intrinsic": "^1.2.4", + "gopd": "^1.0.1", + "has-property-descriptors": "^1.0.2", + }, + }, + "sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==", + ], + + "shebang-command": [ + "shebang-command@2.0.0", + "", + { "dependencies": { "shebang-regex": "^3.0.0" } }, + "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", + ], + + "shebang-regex": [ + "shebang-regex@3.0.0", + "", + {}, + "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", + ], + + "siginfo": [ + "siginfo@2.0.0", + "", + {}, + "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==", + ], + + "source-map": [ + "source-map@0.6.1", + "", + {}, + "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + ], + + "source-map-js": [ + "source-map-js@1.2.1", + "", + {}, + "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==", + ], + + "stackback": [ + "stackback@0.0.2", + "", + {}, + "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==", + ], + + "std-env": [ + "std-env@4.1.0", + "", + {}, + "sha512-Rq7ybcX2RuC55r9oaPVEW7/xu3tj8u4GeBYHBWCychFtzMIr86A7e3PPEBPT37sHStKX3+TiX/Fr/ACmJLVlLQ==", + ], + + "string-template": [ + "string-template@1.0.0", + "", + {}, + "sha512-SLqR3GBUXuoPP5MmYtD7ompvXiG87QjT6lzOszyXjTM86Uu7At7vNnt2xgyTLq5o9T4IxTYFyGxcULqpsmsfdg==", + ], + + "stringz": [ + "stringz@2.1.0", + "", + { "dependencies": { "char-regex": "^1.0.2" } }, + "sha512-KlywLT+MZ+v0IRepfMxRtnSvDCMc3nR1qqCs3m/qIbSOWkNZYT8XHQA31rS3TnKp0c5xjZu3M4GY/2aRKSi/6A==", + ], + + "supports-color": [ + "supports-color@7.2.0", + "", + { "dependencies": { "has-flag": "^4.0.0" } }, + "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + ], + + "tar": [ + "tar@7.5.13", + "", + { + "dependencies": { + "@isaacs/fs-minipass": "^4.0.0", + "chownr": "^3.0.0", + "minipass": "^7.1.2", + "minizlib": "^3.1.0", + "yallist": "^5.0.0", + }, + }, + "sha512-tOG/7GyXpFevhXVh8jOPJrmtRpOTsYqUIkVdVooZYJS/z8WhfQUX8RJILmeuJNinGAMSu1veBr4asSHFt5/hng==", + ], + + "throttleit": [ + "throttleit@2.1.0", + "", + {}, + "sha512-nt6AMGKW1p/70DF/hGBdJB57B8Tspmbp5gfJ8ilhLnt7kkr2ye7hzD6NVG8GGErk2HWF34igrL2CXmNIkzKqKw==", + ], + + "tinybench": [ + "tinybench@2.9.0", + "", + {}, + "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==", + ], + + "tinyexec": [ + "tinyexec@1.1.1", + "", + {}, + "sha512-VKS/ZaQhhkKFMANmAOhhXVoIfBXblQxGX1myCQ2faQrfmobMftXeJPcZGp0gS07ocvGJWDLZGyOZDadDBqYIJg==", + ], + + "tinyglobby": [ + "tinyglobby@0.2.16", + "", + { "dependencies": { "fdir": "^6.5.0", "picomatch": "^4.0.4" } }, + "sha512-pn99VhoACYR8nFHhxqix+uvsbXineAasWm5ojXoN8xEwK5Kd3/TrhNn1wByuD52UxWRLy8pu+kRMniEi6Eq9Zg==", + ], + + "tinyrainbow": [ + "tinyrainbow@3.1.0", + "", + {}, + "sha512-Bf+ILmBgretUrdJxzXM0SgXLZ3XfiaUuOj/IKQHuTXip+05Xn+uyEYdVg0kYDipTBcLrCVyUzAPz7QmArb0mmw==", + ], + + "ts-api-utils": [ + "ts-api-utils@2.5.0", + "", + { "peerDependencies": { "typescript": ">=4.8.4" } }, + "sha512-OJ/ibxhPlqrMM0UiNHJ/0CKQkoKF243/AEmplt3qpRgkW8VG7IfOS41h7V8TjITqdByHzrjcS/2si+y4lIh8NA==", + ], + + "tslib": [ + "tslib@2.8.1", + "", + {}, + "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==", + ], + + "type-check": [ + "type-check@0.4.0", + "", + { "dependencies": { "prelude-ls": "^1.2.1" } }, + "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==", + ], + + "typescript": [ + "typescript@5.9.3", + "", + { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, + "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==", + ], + + "undici": [ + "undici@6.25.0", + "", + {}, + "sha512-ZgpWDC5gmNiuY9CnLVXEH8rl50xhRCuLNA97fAUnKi8RRuV4E6KG31pDTsLVUKnohJE0I3XDrTeEydAXRw47xg==", + ], + + "undici-types": [ + "undici-types@7.16.0", + "", + {}, + "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw==", + ], + + "uri-js": [ + "uri-js@4.4.1", + "", + { "dependencies": { "punycode": "^2.1.0" } }, + "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==", + ], + + "util": [ + "util@0.12.5", + "", + { + "dependencies": { + "inherits": "^2.0.3", + "is-arguments": "^1.0.4", + "is-generator-function": "^1.0.7", + "is-typed-array": "^1.1.3", + "which-typed-array": "^1.1.2", + }, + }, + "sha512-kZf/K6hEIrWHI6XqOFUiiMa+79wE/D8Q+NCNAWclkyg3b4d2k7s0QGepNjiABc+aR3N1PAyHL7p6UcLY6LmrnA==", + ], + + "uuid": [ + "uuid@13.0.1", + "", + { "bin": { "uuid": "dist-node/bin/uuid" } }, + "sha512-9ezox2roIft6ExBVTVqibSd5dc5/47Sw/uY6b4SjQUT2TzQ0tltNquWA46y4xPQmdZYqvnio22SgWd41M86+jw==", + ], + + "validator": [ + "validator@13.15.35", + "", + {}, + "sha512-TQ5pAGhd5whStmqWvYF4OjQROlmv9SMFVt37qoCBdqRffuuklWYQlCNnEs2ZaIBD1kZRNnikiZOS1eqgkar0iw==", + ], + + "vite": [ + "vite@8.0.9", + "", + { + "dependencies": { + "lightningcss": "^1.32.0", + "picomatch": "^4.0.4", + "postcss": "^8.5.10", + "rolldown": "1.0.0-rc.16", + "tinyglobby": "^0.2.16", + }, + "optionalDependencies": { "fsevents": "~2.3.3" }, + "peerDependencies": { + "@types/node": "^20.19.0 || >=22.12.0", + "@vitejs/devtools": "^0.1.0", + "esbuild": "^0.27.0 || ^0.28.0", + "jiti": ">=1.21.0", + "less": "^4.0.0", + "sass": "^1.70.0", + "sass-embedded": "^1.70.0", + "stylus": ">=0.54.8", + "sugarss": "^5.0.0", + "terser": "^5.16.0", + "tsx": "^4.8.1", + "yaml": "^2.4.2", + }, + "optionalPeers": [ + "@types/node", + "@vitejs/devtools", + "esbuild", + "jiti", + "less", + "sass", + "sass-embedded", + "stylus", + "sugarss", + "terser", + "tsx", + "yaml", + ], + "bin": { "vite": "bin/vite.js" }, + }, + "sha512-t7g7GVRpMXjNpa67HaVWI/8BWtdVIQPCL2WoozXXA7LBGEFK4AkkKkHx2hAQf5x1GZSlcmEDPkVLSGahxnEEZw==", + ], + + "vitest": [ + "vitest@4.1.5", + "", + { + "dependencies": { + "@vitest/expect": "4.1.5", + "@vitest/mocker": "4.1.5", + "@vitest/pretty-format": "4.1.5", + "@vitest/runner": "4.1.5", + "@vitest/snapshot": "4.1.5", + "@vitest/spy": "4.1.5", + "@vitest/utils": "4.1.5", + "es-module-lexer": "^2.0.0", + "expect-type": "^1.3.0", + "magic-string": "^0.30.21", + "obug": "^2.1.1", + "pathe": "^2.0.3", + "picomatch": "^4.0.3", + "std-env": "^4.0.0-rc.1", + "tinybench": "^2.9.0", + "tinyexec": "^1.0.2", + "tinyglobby": "^0.2.15", + "tinyrainbow": "^3.1.0", + "vite": "^6.0.0 || ^7.0.0 || ^8.0.0", + "why-is-node-running": "^2.3.0", + }, + "peerDependencies": { + "@edge-runtime/vm": "*", + "@opentelemetry/api": "^1.9.0", + "@types/node": "^20.0.0 || ^22.0.0 || >=24.0.0", + "@vitest/browser-playwright": "4.1.5", + "@vitest/browser-preview": "4.1.5", + "@vitest/browser-webdriverio": "4.1.5", + "@vitest/coverage-istanbul": "4.1.5", + "@vitest/coverage-v8": "4.1.5", + "@vitest/ui": "4.1.5", + "happy-dom": "*", + "jsdom": "*", + }, + "optionalPeers": [ + "@edge-runtime/vm", + "@opentelemetry/api", + "@types/node", + "@vitest/browser-playwright", + "@vitest/browser-preview", + "@vitest/browser-webdriverio", + "@vitest/coverage-istanbul", + "@vitest/coverage-v8", + "@vitest/ui", + "happy-dom", + "jsdom", + ], + "bin": { "vitest": "vitest.mjs" }, + }, + "sha512-9Xx1v3/ih3m9hN+SbfkUyy0JAs72ap3r7joc87XL6jwF0jGg6mFBvQ1SrwaX+h8BlkX6Hz9shdd1uo6AF+ZGpg==", + ], + + "which": [ + "which@2.0.2", + "", + { + "dependencies": { "isexe": "^2.0.0" }, + "bin": { "node-which": "./bin/node-which" }, + }, + "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + ], + + "which-typed-array": [ + "which-typed-array@1.1.20", + "", + { + "dependencies": { + "available-typed-arrays": "^1.0.7", + "call-bind": "^1.0.8", + "call-bound": "^1.0.4", + "for-each": "^0.3.5", + "get-proto": "^1.0.1", + "gopd": "^1.2.0", + "has-tostringtag": "^1.0.2", + }, + }, + "sha512-LYfpUkmqwl0h9A2HL09Mms427Q1RZWuOHsukfVcKRq9q95iQxdw0ix1JQrqbcDR9PH1QDwf5Qo8OZb5lksZ8Xg==", + ], + + "why-is-node-running": [ + "why-is-node-running@2.3.0", + "", + { + "dependencies": { "siginfo": "^2.0.0", "stackback": "0.0.2" }, + "bin": { "why-is-node-running": "cli.js" }, + }, + "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==", + ], + + "word-wrap": [ + "word-wrap@1.2.5", + "", + {}, + "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==", + ], + + "yallist": [ + "yallist@5.0.0", + "", + {}, + "sha512-YgvUTfwqyc7UXVMrB+SImsVYSmTS8X/tSrtdNZMImM+n7+QTriRXyXim0mBrTXNeqzVF0KWGgHPeiyViFFrNDw==", + ], + + "yocto-queue": [ + "yocto-queue@0.1.0", + "", + {}, + "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", + ], + + "zod": [ + "zod@3.25.76", + "", + {}, + "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==", + ], + + "@eslint-community/eslint-utils/eslint-visitor-keys": [ + "eslint-visitor-keys@3.4.3", + "", + {}, + "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==", + ], + + "@javascript-obfuscator/escodegen/optionator": [ + "optionator@0.8.3", + "", + { + "dependencies": { + "deep-is": "~0.1.3", + "fast-levenshtein": "~2.0.6", + "levn": "~0.3.0", + "prelude-ls": "~1.1.2", + "type-check": "~0.3.2", + "word-wrap": "~1.2.3", + }, + }, + "sha512-+IW9pACdk3XWmmTXG8m3upGUJst5XRGzxMRjXzAuJ1XnIFNvfhjjIuYkDvysnPQ7qzqVzLt78BCruntqRhWQbA==", + ], + + "@types/bun/bun-types": [ + "bun-types@1.3.5", + "", + { "dependencies": { "@types/node": "*" } }, + "sha512-inmAYe2PFLs0SUbFOWSVD24sg1jFlMPxOjOSSCYqUgn4Hsc3rDc7dFvfVYjFPNHtov6kgUeulV4SxbuIV/stPw==", + ], + + "@typescript-eslint/visitor-keys/eslint-visitor-keys": [ + "eslint-visitor-keys@5.0.1", + "", + {}, + "sha512-tD40eHxA35h0PEIZNeIjkHoDR4YjjJp34biM0mDvplBe//mB+IHCqHDGV7pxF+7MklTvighcCPPZC7ynWyjdTA==", + ], + + "eslint/eslint-scope": [ + "eslint-scope@9.1.2", + "", + { + "dependencies": { + "@types/esrecurse": "^4.3.1", + "@types/estree": "^1.0.8", + "esrecurse": "^4.3.0", + "estraverse": "^5.2.0", + }, + }, + "sha512-xS90H51cKw0jltxmvmHy2Iai1LIqrfbw57b79w/J7MfvDfkIkFZ+kj6zC3BjtUwh150HsSSdxXZcsuv72miDFQ==", + ], + + "eslint/eslint-visitor-keys": [ + "eslint-visitor-keys@5.0.1", + "", + {}, + "sha512-tD40eHxA35h0PEIZNeIjkHoDR4YjjJp34biM0mDvplBe//mB+IHCqHDGV7pxF+7MklTvighcCPPZC7ynWyjdTA==", + ], + + "espree/acorn": [ + "acorn@8.16.0", + "", + { "bin": { "acorn": "bin/acorn" } }, + "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==", + ], + + "espree/eslint-visitor-keys": [ + "eslint-visitor-keys@5.0.1", + "", + {}, + "sha512-tD40eHxA35h0PEIZNeIjkHoDR4YjjJp34biM0mDvplBe//mB+IHCqHDGV7pxF+7MklTvighcCPPZC7ynWyjdTA==", + ], + + "md5/is-buffer": [ + "is-buffer@1.1.6", + "", + {}, + "sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==", + ], + + "multimatch/minimatch": [ + "minimatch@3.1.5", + "", + { "dependencies": { "brace-expansion": "^1.1.7" } }, + "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==", + ], + + "@javascript-obfuscator/escodegen/optionator/levn": [ + "levn@0.3.0", + "", + { "dependencies": { "prelude-ls": "~1.1.2", "type-check": "~0.3.2" } }, + "sha512-0OO4y2iOHix2W6ujICbKIaEQXvFQHue65vUG3pb5EUomzPI90z9hsA1VsO/dbIIpC53J8gxM9Q4Oho0jrCM/yA==", + ], + + "@javascript-obfuscator/escodegen/optionator/prelude-ls": [ + "prelude-ls@1.1.2", + "", + {}, + "sha512-ESF23V4SKG6lVSGZgYNpbsiaAkdab6ZgOxe52p7+Kid3W3u3bxR4Vfd/o21dmN7jSt0IwgZ4v5MUd26FEtXE9w==", + ], + + "@javascript-obfuscator/escodegen/optionator/type-check": [ + "type-check@0.3.2", + "", + { "dependencies": { "prelude-ls": "~1.1.2" } }, + "sha512-ZCmOJdvOWDBYJlzAoFkC+Q0+bUyEOS1ltgp1MGU03fqHG+dbi9tBFU2Rd9QKiDZFAYrhPh2JUf7rZRIuHRKtOg==", + ], + + "multimatch/minimatch/brace-expansion": [ + "brace-expansion@1.1.14", + "", + { "dependencies": { "balanced-match": "^1.0.0", "concat-map": "0.0.1" } }, + "sha512-MWPGfDxnyzKU7rNOW9SP/c50vi3xrmrua/+6hfPbCS2ABNWfx24vPidzvC7krjU/RTo235sV776ymlsMtGKj8g==", + ], + + "multimatch/minimatch/brace-expansion/balanced-match": [ + "balanced-match@1.0.2", + "", + {}, + "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==", + ], + }, +} diff --git a/bunfig.toml b/bunfig.toml new file mode 100644 index 0000000..ac52ec5 --- /dev/null +++ b/bunfig.toml @@ -0,0 +1,6 @@ +[bundle] + [bundle.loaders] + ".py" = "text" + +[test] +preload = ["./tests/setup.ts"] \ No newline at end of file diff --git a/eslint.config.js b/eslint.config.js new file mode 100644 index 0000000..3879b18 --- /dev/null +++ b/eslint.config.js @@ -0,0 +1,31 @@ +import simpleImportSort from "eslint-plugin-simple-import-sort"; + +export default [ + // Global ignores MUST be alone in their own object to apply project-wide. + { + ignores: [ + "dist/**", + "dist_obf/**", + "dist_obfplus/**", + "build/**", + "coverage/**", + "node_modules/**", + ".bun-temp/**", + ".bun-temp-cli/**", + "**/*.d.ts", + ], + }, + + // Actual lint config for TS/TSX files. + { + files: ["**/*.ts", "**/*.tsx"], + languageOptions: { + parser: (await import("@typescript-eslint/parser")).default, + }, + plugins: { "simple-import-sort": simpleImportSort }, + rules: { + "simple-import-sort/imports": "error", + "simple-import-sort/exports": "error", + }, + }, +];