From 86f0c0e4c38ce5d24f67af6be65be4bf71266d2f Mon Sep 17 00:00:00 2001 From: MoD Date: Fri, 6 Mar 2026 00:24:49 +0200 Subject: [PATCH] Merging protocol docs --- .gitmodules | 3 + docs/api-reference/index.md | 6 +- docs/build/quick-start/index.md | 2 +- docs/contracts/addresses.md | 44 + docs/contracts/api-reference/_category_.json | 9 + docs/contracts/api-reference/app-registry.md | 114 + docs/contracts/api-reference/faucet.md | 168 + .../api-reference/interfaces/_category_.json | 9 + .../api-reference/interfaces/ilock.md | 232 + .../api-reference/interfaces/islash.md | 70 + docs/contracts/api-reference/locker.md | 170 + docs/contracts/api-reference/node-registry.md | 63 + docs/contracts/api-reference/treasury.md | 77 + .../api-reference/yellow-governor.md | 257 + docs/contracts/api-reference/yellow-token.md | 46 + docs/contracts/faq.md | 148 + docs/contracts/index.md | 180 + docs/contracts/integration/_category_.json | 9 + docs/contracts/integration/deployment.md | 123 + docs/contracts/integration/events.md | 115 + docs/contracts/integration/ui-spec.md | 98 + docs/contracts/protocol/_category_.json | 9 + docs/contracts/protocol/governance.md | 101 + docs/contracts/protocol/overview.md | 76 + docs/contracts/protocol/slashing.md | 83 + docs/contracts/protocol/staking.md | 94 + docs/contracts/protocol/treasury.md | 68 + docs/contracts/sdk/_category_.json | 9 + docs/contracts/sdk/api-reference.md | 89 + docs/contracts/sdk/examples.md | 311 ++ docs/contracts/sdk/getting-started.md | 92 + docs/guides/index.md | 2 +- docs/guides/migration-guide.md | 32 +- docs/guides/multi-party-app-sessions.mdx | 8 +- docs/learn/advanced/managing-session-keys.mdx | 4 +- docs/learn/core-concepts/app-sessions.mdx | 2 +- .../core-concepts/challenge-response.mdx | 4 +- docs/learn/core-concepts/message-envelope.mdx | 4 +- docs/learn/core-concepts/session-keys.mdx | 2 +- .../core-concepts/state-channels-vs-l1-l2.mdx | 6 +- docs/learn/getting-started/key-terms.mdx | 4 +- docs/learn/getting-started/prerequisites.mdx | 2 +- docs/learn/getting-started/quickstart.mdx | 24 +- docs/learn/index.mdx | 2 +- .../introduction/architecture-at-a-glance.mdx | 6 +- .../learn/introduction/what-yellow-solves.mdx | 4 +- docs/manuals/request-asset-support.md | 2 +- docs/manuals/request-blockchain-support.md | 4 +- docs/manuals/running-clearnode-locally.md | 4 +- docs/protocol/app-layer/_category_.json | 6 + .../{ => app-layer}/off-chain/_category_.json | 2 +- .../off-chain/app-sessions.mdx | 0 .../off-chain/authentication.mdx | 0 .../off-chain/channel-methods.mdx | 4 +- .../off-chain/message-format.mdx | 0 .../{ => app-layer}/off-chain/overview.mdx | 0 .../{ => app-layer}/off-chain/queries.mdx | 2 +- .../{ => app-layer}/off-chain/transfers.mdx | 0 .../app-layer/on-chain/_category_.json | 6 + .../on-chain/channel-lifecycle.mdx | 2 +- .../on-chain/data-structures.mdx | 6 +- .../{ => app-layer}/on-chain/overview.mdx | 4 +- .../{ => app-layer}/on-chain/security.mdx | 14 +- .../on-chain/signature-formats.mdx | 6 +- docs/protocol/architecture.mdx | 53 +- docs/protocol/communication-flows.mdx | 12 +- .../_category_.json | 2 +- .../decentralized-layer/cluster-lifecycle.mdx | 118 + .../decentralized-layer/elastic-security.mdx | 131 + .../decentralized-layer/liquidity-layer.mdx | 118 + .../protocol/decentralized-layer/overview.mdx | 110 + .../protocol-lifecycle.mdx | 194 + .../protocol/decentralized-layer/security.mdx | 97 + docs/protocol/glossary.mdx | 70 +- docs/protocol/implementation-checklist.mdx | 32 +- docs/protocol/introduction.mdx | 79 +- docs/protocol/protocol-reference.mdx | 6 +- docs/protocol/terminology.mdx | 24 +- docusaurus.config.ts | 10 + package-lock.json | 4439 +++++++++-------- package.json | 10 +- scripts/sync-contracts-docs.js | 348 ++ sidebars.ts | 8 + src/constants/tooltipDefinitions.ts | 8 +- src/pages/whitepaper.md | 4 +- vendors/yellow | 1 + 86 files changed, 6758 insertions(+), 2159 deletions(-) create mode 100644 .gitmodules create mode 100644 docs/contracts/addresses.md create mode 100644 docs/contracts/api-reference/_category_.json create mode 100644 docs/contracts/api-reference/app-registry.md create mode 100644 docs/contracts/api-reference/faucet.md create mode 100644 docs/contracts/api-reference/interfaces/_category_.json create mode 100644 docs/contracts/api-reference/interfaces/ilock.md create mode 100644 docs/contracts/api-reference/interfaces/islash.md create mode 100644 docs/contracts/api-reference/locker.md create mode 100644 docs/contracts/api-reference/node-registry.md create mode 100644 docs/contracts/api-reference/treasury.md create mode 100644 docs/contracts/api-reference/yellow-governor.md create mode 100644 docs/contracts/api-reference/yellow-token.md create mode 100644 docs/contracts/faq.md create mode 100644 docs/contracts/index.md create mode 100644 docs/contracts/integration/_category_.json create mode 100644 docs/contracts/integration/deployment.md create mode 100644 docs/contracts/integration/events.md create mode 100644 docs/contracts/integration/ui-spec.md create mode 100644 docs/contracts/protocol/_category_.json create mode 100644 docs/contracts/protocol/governance.md create mode 100644 docs/contracts/protocol/overview.md create mode 100644 docs/contracts/protocol/slashing.md create mode 100644 docs/contracts/protocol/staking.md create mode 100644 docs/contracts/protocol/treasury.md create mode 100644 docs/contracts/sdk/_category_.json create mode 100644 docs/contracts/sdk/api-reference.md create mode 100644 docs/contracts/sdk/examples.md create mode 100644 docs/contracts/sdk/getting-started.md create mode 100644 docs/protocol/app-layer/_category_.json rename docs/protocol/{ => app-layer}/off-chain/_category_.json (83%) rename docs/protocol/{ => app-layer}/off-chain/app-sessions.mdx (100%) rename docs/protocol/{ => app-layer}/off-chain/authentication.mdx (100%) rename docs/protocol/{ => app-layer}/off-chain/channel-methods.mdx (98%) rename docs/protocol/{ => app-layer}/off-chain/message-format.mdx (100%) rename docs/protocol/{ => app-layer}/off-chain/overview.mdx (100%) rename docs/protocol/{ => app-layer}/off-chain/queries.mdx (99%) rename docs/protocol/{ => app-layer}/off-chain/transfers.mdx (100%) create mode 100644 docs/protocol/app-layer/on-chain/_category_.json rename docs/protocol/{ => app-layer}/on-chain/channel-lifecycle.mdx (99%) rename docs/protocol/{ => app-layer}/on-chain/data-structures.mdx (95%) rename docs/protocol/{ => app-layer}/on-chain/overview.mdx (85%) rename docs/protocol/{ => app-layer}/on-chain/security.mdx (90%) rename docs/protocol/{ => app-layer}/on-chain/signature-formats.mdx (81%) rename docs/protocol/{on-chain => decentralized-layer}/_category_.json (66%) create mode 100644 docs/protocol/decentralized-layer/cluster-lifecycle.mdx create mode 100644 docs/protocol/decentralized-layer/elastic-security.mdx create mode 100644 docs/protocol/decentralized-layer/liquidity-layer.mdx create mode 100644 docs/protocol/decentralized-layer/overview.mdx create mode 100644 docs/protocol/decentralized-layer/protocol-lifecycle.mdx create mode 100644 docs/protocol/decentralized-layer/security.mdx create mode 100644 scripts/sync-contracts-docs.js create mode 160000 vendors/yellow diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..9ce8463 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "vendors/yellow"] + path = vendors/yellow + url = git@github.com:layer-3/yellow.git diff --git a/docs/api-reference/index.md b/docs/api-reference/index.md index 2b535a7..caeb7ac 100644 --- a/docs/api-reference/index.md +++ b/docs/api-reference/index.md @@ -2,7 +2,7 @@ sidebar_position: 9 title: API Reference description: Complete Yellow SDK method documentation with examples and type definitions -keywords: [api reference, methods, types, nitrolite client, documentation] +keywords: [api reference, methods, types, virtualapp client, documentation] displayed_sidebar: apiSidebar --- @@ -10,7 +10,7 @@ displayed_sidebar: apiSidebar Complete reference for all Yellow SDK methods, types, and utilities. -## NitroliteRPC Functions +## VirtualAppRPC Functions ### Message Creation @@ -260,4 +260,4 @@ const SESSION_STATUS = { }; ``` -This API reference provides everything you need to integrate NitroliteRPC into your applications with confidence and precision. \ No newline at end of file +This API reference provides everything you need to integrate VirtualAppRPC into your applications with confidence and precision. \ No newline at end of file diff --git a/docs/build/quick-start/index.md b/docs/build/quick-start/index.md index 3cab60d..d397f78 100644 --- a/docs/build/quick-start/index.md +++ b/docs/build/quick-start/index.md @@ -3,7 +3,7 @@ sidebar_position: 2 sidebar_label: Quick Start title: Quick Start description: Build your first Yellow App in 5 minutes - a complete beginner's guide -keywords: [yellow sdk, quick start, tutorial, nitrolite, state channels, beginner guide] +keywords: [yellow sdk, quick start, tutorial, virtualapp, state channels, beginner guide] displayed_sidebar: buildSidebar --- diff --git a/docs/contracts/addresses.md b/docs/contracts/addresses.md new file mode 100644 index 0000000..b205a36 --- /dev/null +++ b/docs/contracts/addresses.md @@ -0,0 +1,44 @@ +--- +title: "Deployed Addresses" +description: "Mainnet and testnet contract addresses for Yellow Network." +sidebar_position: 2 +displayed_sidebar: contractsSidebar +--- + +# Deployed Addresses + +## Ethereum Mainnet (Chain ID: 1) + +| Contract | Address | +|---|---| +| YellowToken | [`0x236eB848C95b231299B4AA9f56c73D6893462720`](https://etherscan.io/address/0x236eB848C95b231299B4AA9f56c73D6893462720) | +| NodeRegistry | — | +| AppRegistry | — | +| YellowGovernor | — | +| TimelockController | — | +| Treasury | — | +| Faucet | — | + +## Sepolia Testnet (Chain ID: 11155111) + +| Contract | Address | +|---|---| +| YellowToken | [`0x236eB848C95b231299B4AA9f56c73D6893462720`](https://sepolia.etherscan.io/address/0x236eB848C95b231299B4AA9f56c73D6893462720) | +| NodeRegistry | — | +| AppRegistry | — | +| YellowGovernor | — | +| TimelockController | — | +| Treasury | — | +| Faucet | [`0x914abaDC0e36e03f29e4F1516951125c774dBAc8`](https://sepolia.etherscan.io/address/0x914abaDC0e36e03f29e4F1516951125c774dBAc8) | + +## Using in Code + +```ts +import { addresses } from "@yellow-org/contracts"; + +// Mainnet +addresses[1].yellowToken + +// Sepolia +addresses[11155111].faucet +``` diff --git a/docs/contracts/api-reference/_category_.json b/docs/contracts/api-reference/_category_.json new file mode 100644 index 0000000..1e709a2 --- /dev/null +++ b/docs/contracts/api-reference/_category_.json @@ -0,0 +1,9 @@ +{ + "label": "Contract API Reference", + "position": 4, + "link": { + "type": "generated-index" + }, + "collapsible": false, + "collapsed": false +} diff --git a/docs/contracts/api-reference/app-registry.md b/docs/contracts/api-reference/app-registry.md new file mode 100644 index 0000000..d50ed36 --- /dev/null +++ b/docs/contracts/api-reference/app-registry.md @@ -0,0 +1,114 @@ +--- +title: "AppRegistry" +description: "App builder registry with slashing." +sidebar_position: 4 +displayed_sidebar: contractsSidebar +--- + +# AppRegistry +[Git Source](https://github.com/layer-3/yellow/blob/f97fcc52ddfdc5918cb91b2af5538abb0060ee27/src/AppRegistry.sol) + +**Inherits:** +[Locker](/src/Locker.sol/abstract.Locker.md), [ISlash](/src/interfaces/ISlash.sol/interface.ISlash.md), AccessControl + +**Title:** +AppRegistry + +Registry for app builders who post YELLOW as a service quality guarantee. +Authorised adjudicators can slash a participant's balance as penalty for misbehaviour. + +Access control: +- `DEFAULT_ADMIN_ROLE` is held by the TimelockController (parameter administration) and +can grant or revoke `ADJUDICATOR_ROLE` to multiple addresses. +- `ADJUDICATOR_ROLE` holders can call `slash`. +No collateral weight for parameter administration — this registry is purely for +collateral management and slashing. See NodeRegistry for the parameter-administration-enabled +variant used by node operators. +Slashing can occur in both Locked and Unlocking states. + + +## State Variables +### ADJUDICATOR_ROLE + +```solidity +bytes32 public constant ADJUDICATOR_ROLE = keccak256("ADJUDICATOR_ROLE") +``` + + +### slashCooldown +Minimum time (seconds) that must elapse between any two slash calls. + + +```solidity +uint256 public slashCooldown +``` + + +### lastSlashTimestamp +Timestamp of the last successful slash. + + +```solidity +uint256 public lastSlashTimestamp +``` + + +## Functions +### constructor + + +```solidity +constructor(address asset_, uint256 unlockPeriod_, address admin_) Locker(asset_, unlockPeriod_); +``` + +### setSlashCooldown + +Sets the global cooldown between slash calls. + + +```solidity +function setSlashCooldown(uint256 newCooldown) external onlyRole(DEFAULT_ADMIN_ROLE); +``` +**Parameters** + +|Name|Type|Description| +|----|----|-----------| +|`newCooldown`|`uint256`|The new cooldown in seconds (0 disables the cooldown).| + + +### slash + +Reduces a user's locked balance and transfers the slashed tokens +to the specified recipient. Callable only by an authorised adjudicator. + + +```solidity +function slash(address user, uint256 amount, address recipient, bytes calldata decision) + external + onlyRole(ADJUDICATOR_ROLE) + nonReentrant; +``` +**Parameters** + +|Name|Type|Description| +|----|----|-----------| +|`user`|`address`| The user to slash.| +|`amount`|`uint256`| The amount of tokens to slash.| +|`recipient`|`address`|The address that receives the slashed tokens (cannot be the caller).| +|`decision`|`bytes`| Off-chain reference to the dispute decision.| + + +## Events +### SlashCooldownUpdated + +```solidity +event SlashCooldownUpdated(uint256 oldCooldown, uint256 newCooldown); +``` + +## Errors +### SlashCooldownActive + +```solidity +error SlashCooldownActive(uint256 availableAt); +``` + diff --git a/docs/contracts/api-reference/faucet.md b/docs/contracts/api-reference/faucet.md new file mode 100644 index 0000000..eb4b4b3 --- /dev/null +++ b/docs/contracts/api-reference/faucet.md @@ -0,0 +1,168 @@ +--- +title: "Faucet" +description: "Testnet token faucet." +sidebar_position: 7 +displayed_sidebar: contractsSidebar +--- + +# Faucet +[Git Source](https://github.com/layer-3/yellow/blob/f97fcc52ddfdc5918cb91b2af5538abb0060ee27/src/Faucet.sol) + +**Title:** +Faucet — YELLOW testnet token faucet + +Dispenses a fixed amount of YELLOW per call with a per-address cooldown. + + +## State Variables +### TOKEN + +```solidity +IERC20 public immutable TOKEN +``` + + +### owner + +```solidity +address public owner +``` + + +### dripAmount + +```solidity +uint256 public dripAmount +``` + + +### cooldown + +```solidity +uint256 public cooldown +``` + + +### lastDrip + +```solidity +mapping(address => uint256) public lastDrip +``` + + +## Functions +### onlyOwner + + +```solidity +modifier onlyOwner() ; +``` + +### _onlyOwner + + +```solidity +function _onlyOwner() internal view; +``` + +### constructor + + +```solidity +constructor(IERC20 _token, uint256 _dripAmount, uint256 _cooldown) ; +``` +**Parameters** + +|Name|Type|Description| +|----|----|-----------| +|`_token`|`IERC20`| YELLOW token address| +|`_dripAmount`|`uint256`|Amount dispensed per drip (in wei)| +|`_cooldown`|`uint256`| Seconds between drips per address| + + +### drip + +Drip YELLOW to msg.sender. + + +```solidity +function drip() external; +``` + +### dripTo + +Drip YELLOW to a specified address (for batch use). + + +```solidity +function dripTo(address recipient) external; +``` + +### _dripTo + + +```solidity +function _dripTo(address recipient) internal; +``` + +### setDripAmount + +Owner can update the drip amount. + + +```solidity +function setDripAmount(uint256 _dripAmount) external onlyOwner; +``` + +### setCooldown + +Owner can update the cooldown period. + + +```solidity +function setCooldown(uint256 _cooldown) external onlyOwner; +``` + +### setOwner + +Owner can transfer ownership. + + +```solidity +function setOwner(address _owner) external onlyOwner; +``` + +### withdraw + +Owner can withdraw remaining tokens. + + +```solidity +function withdraw(uint256 amount) external onlyOwner; +``` + +## Events +### Dripped + +```solidity +event Dripped(address indexed recipient, uint256 amount); +``` + +### DripAmountUpdated + +```solidity +event DripAmountUpdated(uint256 newAmount); +``` + +### CooldownUpdated + +```solidity +event CooldownUpdated(uint256 newCooldown); +``` + +### OwnerUpdated + +```solidity +event OwnerUpdated(address indexed newOwner); +``` + diff --git a/docs/contracts/api-reference/interfaces/_category_.json b/docs/contracts/api-reference/interfaces/_category_.json new file mode 100644 index 0000000..baf0620 --- /dev/null +++ b/docs/contracts/api-reference/interfaces/_category_.json @@ -0,0 +1,9 @@ +{ + "label": "Interfaces", + "position": 8, + "link": { + "type": "generated-index" + }, + "collapsible": false, + "collapsed": false +} diff --git a/docs/contracts/api-reference/interfaces/ilock.md b/docs/contracts/api-reference/interfaces/ilock.md new file mode 100644 index 0000000..5cc6ea4 --- /dev/null +++ b/docs/contracts/api-reference/interfaces/ilock.md @@ -0,0 +1,232 @@ +--- +title: "ILock" +description: "Lock/unlock/withdraw interface." +sidebar_position: 1 +displayed_sidebar: contractsSidebar +--- + +# ILock +[Git Source](https://github.com/layer-3/yellow/blob/f97fcc52ddfdc5918cb91b2af5538abb0060ee27/src/interfaces/ILock.sol) + +**Title:** +ILock + +Single-asset vault with a time-locked withdrawal mechanism. +Users lock tokens, initiate an unlock, and withdraw after the waiting period. +State machine per user: +lock(amount) unlock() withdraw() +Idle ─────────────► Locked ─────────────► Unlocking ──────────► Idle +│ │ +lock(amount) adds to balance, relock() +stays Locked returns to Locked + + +## Functions +### asset + +The address of the single ERC-20 token this vault accepts. + + +```solidity +function asset() external view returns (address); +``` + +### lockStateOf + +Returns the current lock state for a user. + + +```solidity +function lockStateOf(address user) external view returns (LockState); +``` + +### balanceOf + +Returns the locked balance for a user. + + +```solidity +function balanceOf(address user) external view returns (uint256); +``` + +### unlockTimestampOf + +Returns the timestamp when withdraw() becomes callable (0 if not unlocking). + + +```solidity +function unlockTimestampOf(address user) external view returns (uint256); +``` + +### lock + +Transfers `amount` tokens from the caller into the vault, crediting `target`. +Can be called multiple times to add to an existing Locked balance. +Reverts with AlreadyUnlocking if `target` is in the Unlocking state. + + +```solidity +function lock(address target, uint256 amount) external; +``` + +### unlock + +Starts the waiting period for the caller's full balance. +Reverts with NotLocked if the caller has no balance. +Reverts with AlreadyUnlocking if unlock() was already called. + + +```solidity +function unlock() external; +``` + +### relock + +Cancels an in-progress unlock and returns to Locked state. +Restores collateral weight. Reverts with NotUnlocking if not unlocking. + + +```solidity +function relock() external; +``` + +### withdraw + +Transfers the caller's full balance to `destination`. +Reverts with NotUnlocking if unlock() was not called. +Reverts with UnlockPeriodNotElapsed if the waiting period has not elapsed. + + +```solidity +function withdraw(address destination) external; +``` + +## Events +### Locked + +```solidity +event Locked(address indexed user, uint256 deposited, uint256 newBalance); +``` + +**Parameters** + +|Name|Type|Description| +|----|----|-----------| +|`user`|`address`|The user that locked tokens.| +|`deposited`|`uint256`|The amount of tokens deposited in this call.| +|`newBalance`|`uint256`|The cumulative locked balance after this call.| + +### UnlockInitiated + +```solidity +event UnlockInitiated(address indexed user, uint256 balance, uint256 availableAt); +``` + +**Parameters** + +|Name|Type|Description| +|----|----|-----------| +|`user`|`address`|The user that initiated unlock.| +|`balance`|`uint256`| The full balance queued for withdrawal.| +|`availableAt`|`uint256`|Timestamp when withdraw() becomes callable.| + +### Relocked + +```solidity +event Relocked(address indexed user, uint256 balance); +``` + +**Parameters** + +|Name|Type|Description| +|----|----|-----------| +|`user`|`address`|The user that cancelled an unlock and relocked.| +|`balance`|`uint256`|The balance that was relocked.| + +### Withdrawn + +```solidity +event Withdrawn(address indexed user, uint256 balance); +``` + +**Parameters** + +|Name|Type|Description| +|----|----|-----------| +|`user`|`address`|The user that withdrew.| +|`balance`|`uint256`|The amount withdrawn.| + +## Errors +### InvalidAddress +The address supplied is the zero address. + + +```solidity +error InvalidAddress(); +``` + +### InvalidAmount +Amount must be greater than zero. + + +```solidity +error InvalidAmount(); +``` + +### InvalidPeriod +Unlock period must be greater than zero. + + +```solidity +error InvalidPeriod(); +``` + +### NotLocked +Caller has no locked balance. + + +```solidity +error NotLocked(); +``` + +### NotUnlocking +unlock() was not called before withdraw(), or waiting period has not elapsed. + + +```solidity +error NotUnlocking(); +``` + +### AlreadyUnlocking +Caller is already in the Unlocking state. + + +```solidity +error AlreadyUnlocking(); +``` + +### UnlockPeriodNotElapsed +Waiting period has not elapsed yet. + + +```solidity +error UnlockPeriodNotElapsed(uint256 availableAt); +``` + +**Parameters** + +|Name|Type|Description| +|----|----|-----------| +|`availableAt`|`uint256`|Timestamp when withdraw() becomes callable.| + +## Enums +### LockState + +```solidity +enum LockState { + Idle, + Locked, + Unlocking +} +``` + diff --git a/docs/contracts/api-reference/interfaces/islash.md b/docs/contracts/api-reference/interfaces/islash.md new file mode 100644 index 0000000..ff4b6ed --- /dev/null +++ b/docs/contracts/api-reference/interfaces/islash.md @@ -0,0 +1,70 @@ +--- +title: "ISlash" +description: "Slashing interface." +sidebar_position: 2 +displayed_sidebar: contractsSidebar +--- + +# ISlash +[Git Source](https://github.com/layer-3/yellow/blob/f97fcc52ddfdc5918cb91b2af5538abb0060ee27/src/interfaces/ISlash.sol) + +**Title:** +ISlash + +Slashing interface for registries whose participants can be penalised +by an authorised adjudicator. + + +## Functions +### slash + +Reduces a user's locked balance and transfers the slashed tokens +to the specified recipient. Callable only by an authorised adjudicator. + + +```solidity +function slash(address user, uint256 amount, address recipient, bytes calldata decision) external; +``` +**Parameters** + +|Name|Type|Description| +|----|----|-----------| +|`user`|`address`| The user to slash.| +|`amount`|`uint256`| The amount of tokens to slash.| +|`recipient`|`address`|The address that receives the slashed tokens (cannot be the caller).| +|`decision`|`bytes`| Off-chain reference to the dispute decision.| + + +## Events +### Slashed + +```solidity +event Slashed(address indexed user, uint256 amount, address indexed recipient, bytes decision); +``` + +**Parameters** + +|Name|Type|Description| +|----|----|-----------| +|`user`|`address`| The user whose balance was slashed.| +|`amount`|`uint256`| The amount of tokens slashed.| +|`recipient`|`address`|The address that received the slashed tokens.| +|`decision`|`bytes`| Off-chain reference to the dispute decision.| + +## Errors +### InsufficientBalance +The user does not have enough balance to cover the slash. + + +```solidity +error InsufficientBalance(); +``` + +### RecipientIsAdjudicator +The recipient cannot be the adjudicator calling slash. + + +```solidity +error RecipientIsAdjudicator(); +``` + diff --git a/docs/contracts/api-reference/locker.md b/docs/contracts/api-reference/locker.md new file mode 100644 index 0000000..586883c --- /dev/null +++ b/docs/contracts/api-reference/locker.md @@ -0,0 +1,170 @@ +--- +title: "Locker" +description: "Abstract lock/unlock/withdraw state machine." +sidebar_position: 2 +displayed_sidebar: contractsSidebar +--- + +# Locker +[Git Source](https://github.com/layer-3/yellow/blob/f97fcc52ddfdc5918cb91b2af5538abb0060ee27/src/Locker.sol) + +**Inherits:** +[ILock](/src/interfaces/ILock.sol/interface.ILock.md), ReentrancyGuard + +**Title:** +Locker + +Abstract single-asset vault with a time-locked withdrawal mechanism. +Subcontracts define the unlock period and may add parameter administration or slashing logic. + +ASSET is immutably set to YellowToken, a standard ERC-20 with a fixed supply +and no mint, burn, fee-on-transfer, or rebasing mechanics. +Workflow: +1. lock(amount) — deposit tokens; can top-up while in Locked state. +2. unlock() — start the countdown. +3. withdraw() — after the period elapses, receive the full balance. + + +## State Variables +### ASSET + +```solidity +address public immutable ASSET +``` + + +### UNLOCK_PERIOD + +```solidity +uint256 public immutable UNLOCK_PERIOD +``` + + +### _balances + +```solidity +mapping(address user => uint256 balance) internal _balances +``` + + +### _unlockTimestamps + +```solidity +mapping(address user => uint256 unlockTimestamp) internal _unlockTimestamps +``` + + +## Functions +### constructor + + +```solidity +constructor(address asset_, uint256 unlockPeriod_) ; +``` + +### asset + +The address of the single ERC-20 token this vault accepts. + + +```solidity +function asset() external view returns (address); +``` + +### lockStateOf + +Returns the current lock state for a user. + + +```solidity +function lockStateOf(address user) public view returns (LockState); +``` + +### balanceOf + +Returns the locked balance for a user. + + +```solidity +function balanceOf(address user) external view returns (uint256); +``` + +### unlockTimestampOf + +Returns the timestamp when withdraw() becomes callable (0 if not unlocking). + + +```solidity +function unlockTimestampOf(address user) external view returns (uint256); +``` + +### lock + +Transfers `amount` tokens from the caller into the vault, crediting `target`. +Can be called multiple times to add to an existing Locked balance. +Reverts with AlreadyUnlocking if `target` is in the Unlocking state. + + +```solidity +function lock(address target, uint256 amount) external nonReentrant; +``` + +### unlock + +Starts the waiting period for the caller's full balance. +Reverts with NotLocked if the caller has no balance. +Reverts with AlreadyUnlocking if unlock() was already called. + + +```solidity +function unlock() external; +``` + +### relock + +Cancels an in-progress unlock and returns to Locked state. +Restores collateral weight. Reverts with NotUnlocking if not unlocking. + + +```solidity +function relock() external; +``` + +### withdraw + +Transfers the caller's full balance to `destination`. +Reverts with NotUnlocking if unlock() was not called. +Reverts with UnlockPeriodNotElapsed if the waiting period has not elapsed. + + +```solidity +function withdraw(address destination) external nonReentrant; +``` + +### _afterLock + +Hook called after tokens are locked. Override to add custom logic (e.g. collateral weight). + + +```solidity +function _afterLock(address target, uint256 amount) internal virtual; +``` + +### _afterUnlock + +Hook called after unlock is initiated. Override to add custom logic. + + +```solidity +function _afterUnlock(address account, uint256 balance) internal virtual; +``` + +### _afterRelock + +Hook called after relock. Override to add custom logic. + + +```solidity +function _afterRelock(address account, uint256 balance) internal virtual; +``` + diff --git a/docs/contracts/api-reference/node-registry.md b/docs/contracts/api-reference/node-registry.md new file mode 100644 index 0000000..fe94345 --- /dev/null +++ b/docs/contracts/api-reference/node-registry.md @@ -0,0 +1,63 @@ +--- +title: "NodeRegistry" +description: "Node operator registry with voting power." +sidebar_position: 3 +displayed_sidebar: contractsSidebar +--- + +# NodeRegistry +[Git Source](https://github.com/layer-3/yellow/blob/f97fcc52ddfdc5918cb91b2af5538abb0060ee27/src/NodeRegistry.sol) + +**Inherits:** +[Locker](/src/Locker.sol/abstract.Locker.md), Votes + +**Title:** +NodeRegistry + +Node operator registry. Operators post YELLOW tokens as a mandatory +functional security deposit to operate clearnode infrastructure. +Extends OZ Votes to provide collateral-weight accounting for +protocol parameter administration by active node operators. +Auto-self-delegates on first lock so collateral weight is immediately active. + +Collateral weight units are granted on lock and removed on unlock/relock via hooks. + + +## Functions +### constructor + + +```solidity +constructor(address asset_, uint256 unlockPeriod_) Locker(asset_, unlockPeriod_) EIP712(NAME, VERSION); +``` + +### _afterLock + + +```solidity +function _afterLock(address target, uint256 amount) internal override; +``` + +### _afterUnlock + + +```solidity +function _afterUnlock(address account, uint256 balance) internal override; +``` + +### _afterRelock + + +```solidity +function _afterRelock(address account, uint256 balance) internal override; +``` + +### _getVotingUnits + +Returns the locked collateral as weight units for the OZ Votes system. + + +```solidity +function _getVotingUnits(address account) internal view override returns (uint256); +``` + diff --git a/docs/contracts/api-reference/treasury.md b/docs/contracts/api-reference/treasury.md new file mode 100644 index 0000000..3411c4e --- /dev/null +++ b/docs/contracts/api-reference/treasury.md @@ -0,0 +1,77 @@ +--- +title: "Treasury" +description: "Secure vault for Foundation assets." +sidebar_position: 6 +displayed_sidebar: contractsSidebar +--- + +# Treasury +[Git Source](https://github.com/layer-3/yellow/blob/f97fcc52ddfdc5918cb91b2af5538abb0060ee27/src/Treasury.sol) + +**Inherits:** +Ownable2Step, ReentrancyGuard + +**Title:** +Treasury + +Secure vault for Layer-3 Foundation assets. + + +## State Variables +### name +Human-readable label for this treasury (e.g. "Grants", "Operations"). + + +```solidity +string public name +``` + + +## Functions +### constructor + + +```solidity +constructor(address initialOwner, string memory name_) Ownable(initialOwner); +``` + +### transfer + +Moves funds out of the treasury. + + +```solidity +function transfer(address token, address to, uint256 amount) external onlyOwner nonReentrant; +``` +**Parameters** + +|Name|Type|Description| +|----|----|-----------| +|`token`|`address`|Use address(0) for ETH, otherwise ERC20 address.| +|`to`|`address`|Destination address.| +|`amount`|`uint256`|Amount to transfer (for ERC20 fee-on-transfer tokens, the event emits the actual amount received by `to`).| + + +### renounceOwnership + +Prevent accidental ownership renouncement which would permanently lock funds. + + +```solidity +function renounceOwnership() public pure override; +``` + +### receive + + +```solidity +receive() external payable; +``` + +## Events +### Transferred + +```solidity +event Transferred(address indexed token, address indexed to, uint256 amount); +``` + diff --git a/docs/contracts/api-reference/yellow-governor.md b/docs/contracts/api-reference/yellow-governor.md new file mode 100644 index 0000000..b7dc230 --- /dev/null +++ b/docs/contracts/api-reference/yellow-governor.md @@ -0,0 +1,257 @@ +--- +title: "YellowGovernor" +description: "OpenZeppelin Governor for protocol parameters." +sidebar_position: 5 +displayed_sidebar: contractsSidebar +--- + +# YellowGovernor +[Git Source](https://github.com/layer-3/yellow/blob/f97fcc52ddfdc5918cb91b2af5538abb0060ee27/src/Governor.sol) + +**Inherits:** +Governor, GovernorSettings, GovernorCountingSimple, GovernorVotes, GovernorVotesQuorumFraction, GovernorTimelockControl, GovernorPreventLateQuorum, GovernorProposalGuardian + +**Title:** +YellowGovernor + +Protocol parameter administration for the Yellow Network. +Collateral weight is derived from YELLOW tokens posted as security +deposits in the NodeRegistry by active node operators. +Proposals are queued through a TimelockController before execution. +Enforces a minimum quorum floor so quorum never drops below a +meaningful absolute value even if total locked collateral shrinks. +Includes late-quorum protection to prevent last-minute manipulation +of outcomes without giving other operators time to react. +A proposal guardian (Foundation multisig) can cancel any proposal +as an emergency brake; removable via parameter administration. + + +## State Variables +### _quorumFloorHistory + +```solidity +Checkpoints.Trace208 private _quorumFloorHistory +``` + + +## Functions +### constructor + + +```solidity +constructor( + IVotes locker_, + TimelockController timelock_, + uint48 votingDelay_, + uint32 votingPeriod_, + uint256 proposalThreshold_, + uint256 quorumNumerator_, + uint256 quorumFloor_, + uint48 voteExtension_, + address proposalGuardian_ +) + Governor("YellowGovernor") + GovernorSettings(votingDelay_, votingPeriod_, proposalThreshold_) + GovernorVotes(locker_) + GovernorVotesQuorumFraction(quorumNumerator_) + GovernorTimelockControl(timelock_) + GovernorPreventLateQuorum(voteExtension_); +``` + +### quorumFloor + +Returns the current minimum absolute quorum. + + +```solidity +function quorumFloor() public view returns (uint256); +``` + +### quorumFloor + +Returns the quorum floor at a specific timepoint (snapshotted). + + +```solidity +function quorumFloor(uint256 timepoint) public view returns (uint256); +``` + +### setQuorumFloor + +Update the quorum floor. Only callable via parameter administration. + +Reverts if newFloor exceeds the current total collateral weight supply. + + +```solidity +function setQuorumFloor(uint256 newFloor) public onlyGovernance; +``` + +### _updateQuorumFloor + + +```solidity +function _updateQuorumFloor(uint256 newFloor) internal; +``` + +### votingDelay + + +```solidity +function votingDelay() public view override(Governor, GovernorSettings) returns (uint256); +``` + +### votingPeriod + + +```solidity +function votingPeriod() public view override(Governor, GovernorSettings) returns (uint256); +``` + +### proposalThreshold + + +```solidity +function proposalThreshold() public view override(Governor, GovernorSettings) returns (uint256); +``` + +### quorum + + +```solidity +function quorum(uint256 blockNumber) public view override(Governor, GovernorVotesQuorumFraction) returns (uint256); +``` + +### state + + +```solidity +function state(uint256 proposalId) public view override(Governor, GovernorTimelockControl) returns (ProposalState); +``` + +### proposalDeadline + + +```solidity +function proposalDeadline(uint256 proposalId) + public + view + override(Governor, GovernorPreventLateQuorum) + returns (uint256); +``` + +### proposalNeedsQueuing + + +```solidity +function proposalNeedsQueuing(uint256 proposalId) + public + view + override(Governor, GovernorTimelockControl) + returns (bool); +``` + +### _queueOperations + + +```solidity +function _queueOperations( + uint256 proposalId, + address[] memory targets, + uint256[] memory values, + bytes[] memory calldatas, + bytes32 descriptionHash +) internal override(Governor, GovernorTimelockControl) returns (uint48); +``` + +### _executeOperations + + +```solidity +function _executeOperations( + uint256 proposalId, + address[] memory targets, + uint256[] memory values, + bytes[] memory calldatas, + bytes32 descriptionHash +) internal override(Governor, GovernorTimelockControl); +``` + +### _cancel + + +```solidity +function _cancel( + address[] memory targets, + uint256[] memory values, + bytes[] memory calldatas, + bytes32 descriptionHash +) internal override(Governor, GovernorTimelockControl) returns (uint256); +``` + +### _executor + + +```solidity +function _executor() internal view override(Governor, GovernorTimelockControl) returns (address); +``` + +### clock + + +```solidity +function clock() public view override(Governor, GovernorVotes) returns (uint48); +``` + +### CLOCK_MODE + +forge-lint: disable-next-line(mixed-case-function) + + +```solidity +function CLOCK_MODE() public view override(Governor, GovernorVotes) returns (string memory); +``` + +### _tallyUpdated + + +```solidity +function _tallyUpdated(uint256 proposalId) internal override(Governor, GovernorPreventLateQuorum); +``` + +### _validateCancel + + +```solidity +function _validateCancel(uint256 proposalId, address caller) + internal + view + override(Governor, GovernorProposalGuardian) + returns (bool); +``` + +### _getVotes + + +```solidity +function _getVotes(address account, uint256 timepoint, bytes memory params) + internal + view + override(Governor, GovernorVotes) + returns (uint256); +``` + +## Events +### QuorumFloorUpdated + +```solidity +event QuorumFloorUpdated(uint256 oldFloor, uint256 newFloor); +``` + +## Errors +### QuorumFloorExceedsTotalSupply + +```solidity +error QuorumFloorExceedsTotalSupply(uint256 newFloor, uint256 totalSupply); +``` + diff --git a/docs/contracts/api-reference/yellow-token.md b/docs/contracts/api-reference/yellow-token.md new file mode 100644 index 0000000..4b2e46a --- /dev/null +++ b/docs/contracts/api-reference/yellow-token.md @@ -0,0 +1,46 @@ +--- +title: "YellowToken" +description: "ERC-20 token with fixed 10B supply." +sidebar_position: 1 +displayed_sidebar: contractsSidebar +--- + +# YellowToken +[Git Source](https://github.com/layer-3/yellow/blob/f97fcc52ddfdc5918cb91b2af5538abb0060ee27/src/Token.sol) + +**Inherits:** +ERC20Permit + +Yellow Network utility token. ERC20 with permit functionality. +Fixed 10 billion supply minted entirely to the treasury at deployment. + + +## State Variables +### SUPPLY_CAP + +```solidity +uint256 public constant SUPPLY_CAP = 10_000_000_000 ether +``` + + +## Functions +### constructor + + +```solidity +constructor(address treasury) ERC20Permit("Yellow") ERC20("Yellow", "YELLOW"); +``` +**Parameters** + +|Name|Type|Description| +|----|----|-----------| +|`treasury`|`address`|Address that receives the entire minted supply.| + + +## Errors +### InvalidAddress + +```solidity +error InvalidAddress(); +``` + diff --git a/docs/contracts/faq.md b/docs/contracts/faq.md new file mode 100644 index 0000000..5a78b69 --- /dev/null +++ b/docs/contracts/faq.md @@ -0,0 +1,148 @@ +--- +title: "FAQ" +description: "Frequently asked questions about Yellow Network smart contracts." +sidebar_position: 7 +displayed_sidebar: contractsSidebar +--- + +# Frequently Asked Questions + +## General + +### What is Yellow Network? + +Yellow Network is a decentralised clearing and settlement infrastructure that operates as a Layer-3 overlay on top of existing blockchains. It enables businesses — brokers, exchanges, and application developers — to move digital assets across multiple blockchain networks (Ethereum, Base, Arbitrum, Linea, BNB, and Polygon) through a unified peer-to-peer ledger, without relying on a centralised intermediary. All goods and services are supplied by Layer3 Fintech Ltd. + +### What is YELLOW? + +YELLOW is the native utility token of the Yellow Network, only intended to provide access to the goods and services supplied by Layer3 Fintech Ltd. — including clearing network access, SDK and developer tools, broker registration, node operation, AppRegistry, and dispute resolution. + +### What contracts are involved? + +| Contract | Role | +|---|---| +| **YellowToken** | ERC-20 token (fixed 10B supply, no mint/burn) | +| **NodeRegistry** | Node operators post YELLOW as a mandatory functional security deposit | +| **AppRegistry** | App builders post YELLOW as a service quality guarantee, subject to slashing | +| **YellowGovernor** | Protocol parameter administration by active node operators | +| **TimelockController** | Enforces a delay before parameter changes execute | +| **Treasury** | Holds Layer3 Foundation assets (ETH and ERC-20s) | + +--- + +## NodeRegistry (Node Operators) + +### How do I register as a node operator? + +1. Approve the NodeRegistry to spend your YELLOW tokens. +2. Call `lock(yourAddress, amount)` on the NodeRegistry. + +This posts YELLOW as a mandatory functional security deposit required to operate a clearnode on the Yellow Network using Layer3 Fintech Ltd.'s open-source software. + +### Can I add more tokens to my security deposit? + +Yes. Call `lock(yourAddress, amount)` again while in the **Locked** state. You cannot top up while in the **Unlocking** state. + +### Can I delegate my collateral weight? + +Yes. Call `delegate(theirAddress)` on the NodeRegistry. This delegates your collateral weight for the purpose of protocol parameter administration. You can change your delegate at any time. + +### How do I withdraw my security deposit? + +Two-step process: + +``` +unlock() → wait 14 days → withdraw(destination) +``` + +1. Call `unlock()` to start the countdown. +2. After the period elapses, call `withdraw(destination)` to receive your full balance. + +Your collateral weight is removed from parameter administration the moment you call `unlock()`. + +### Can I cancel an unlock? + +Yes. Call `relock()` before withdrawing. Your tokens stay locked and collateral weight is restored. + +--- + +## AppRegistry (App Builders) + +### How does it differ from NodeRegistry? + +Same lock/unlock/withdraw state machine, but **no parameter administration weight**. AppRegistry is purely for collateral management and slashing. App builders post YELLOW as a service quality guarantee for applications registered on the Yellow Network. + +### What is slashing? + +If an app builder violates protocol rules, an address with `ADJUDICATOR_ROLE` can call `slash(user, amount, recipient, decision)` to confiscate part or all of their locked collateral. Slashed tokens are transferred to the specified recipient. + +### Can I be slashed while unlocking? + +Yes. Slashing applies in both **Locked** and **Unlocking** states. If your entire balance is slashed, your state resets to **Idle**. + +### What is the slash cooldown? + +A global rate-limit on slashing. When set (via parameter administration), only one slash can occur per cooldown window. This prevents a rogue adjudicator from draining all users in a single transaction, giving active node operators time to revoke the role. + +--- + +## Protocol Parameter Administration + +### Who can create a parameter change proposal? + +Any active node operator with at least **10 million YELLOW** in collateral weight (the default proposal threshold). Holding YELLOW alone does not grant this ability — it requires actively operating clearnode infrastructure. + +### What does the proposal lifecycle look like? + +``` +Propose → Delay (~1 day) → Operator Consensus (~1 week) → Queue → Timelock (~2 days) → Execute +``` + +### How do operators signal support? + +Call `castVote(proposalId, support)` on the Governor: + +- `0` = Against +- `1` = For +- `2` = Abstain + +### What is quorum? + +The minimum collateral weight required for a proposal to be valid. Calculated as `max(4% of total locked collateral, 100M YELLOW)`. The floor prevents proposals from passing with very few participants when total locked collateral is low. + +### Can a proposal be cancelled? + +- The **proposer** can cancel while the proposal is Pending. +- The **proposal guardian** (Foundation multisig) can cancel any proposal as an emergency brake. + +--- + +## Treasury + +### What can the Treasury hold? + +ETH and any ERC-20 token. + +### How are funds transferred from the Treasury? + +Call `transfer(token, to, amount)` where `token` is `address(0)` for ETH or an ERC-20 address. + +If the Treasury is owned by the TimelockController, this requires a parameter administration proposal. If owned directly by the Foundation, the owner can call it directly. + +--- + +## Parameters + +| Parameter | Default | Changeable via | +|---|---|---| +| Total YELLOW supply | 10,000,000,000 | Fixed (no mint/burn) | +| Proposal threshold | 10,000,000 YELLOW | Parameter administration | +| Proposal delay | ~1 day (7,200 blocks) | Parameter administration | +| Consensus period | ~1 week (50,400 blocks) | Parameter administration | +| Quorum | 4% of locked collateral | Parameter administration | +| Quorum floor | 100,000,000 YELLOW | Parameter administration | +| Deadline extension | ~2 days (14,400 blocks) | Parameter administration | +| NodeRegistry unlock period | 14 days | Immutable (set at deploy) | +| AppRegistry unlock period | 14 days | Immutable (set at deploy) | +| Timelock delay | 2 days | Parameter administration | +| Slash cooldown | 0 (disabled) | Parameter administration | diff --git a/docs/contracts/index.md b/docs/contracts/index.md new file mode 100644 index 0000000..b3602af --- /dev/null +++ b/docs/contracts/index.md @@ -0,0 +1,180 @@ +--- +title: "Smart Contracts" +description: "Overview of Yellow Network smart contracts, governance, and on-chain infrastructure." +sidebar_position: 1 +displayed_sidebar: contractsSidebar +--- + +# What Is Yellow Network? + +A plain-language guide to Yellow Network, the YELLOW token, and how the system works. + +--- + +## The Problem + +Today's crypto ecosystem is fragmented. Assets live on dozens of separate blockchains — Ethereum, Arbitrum, Base, Polygon, BNB Chain, Linea, and more. If you want to move value between them, you typically rely on bridges (slow, often hacked) or centralised exchanges (single points of failure). Developers building apps face the same issue: they have to pick one chain and lose access to users and liquidity on every other chain. + +There is no shared infrastructure that lets brokers, exchanges, and applications transact across all of these networks in real time — the way internet service providers share a common routing layer to move data. + +## The Solution + +Yellow Network is that shared infrastructure. It is a **clearing and settlement layer** that sits on top of existing blockchains (a "Layer 3") and lets participants move digital assets across multiple chains through a single, unified system — without trusting a central intermediary. + +Think of it like the interbank clearing system (SWIFT, ACH) but for crypto: independent operators run the network, transactions clear in sub-second time off-chain, and final settlement is anchored to the security of public blockchains. + +All of the software, tools, and services that make up Yellow Network are developed, maintained, and supplied by **Layer3 Fintech Ltd.** + +--- + +## How It Works — The Three Layers + +Yellow Network has a three-layer architecture. Each layer has a distinct role: + +### Layer 1 — The Blockchain Foundation + +This is the base: public blockchains like Ethereum, Base, Arbitrum, Linea, BNB Chain, and Polygon. Yellow deploys smart contracts on each of these chains to handle: + +- **Asset custody** — when you deposit assets into Yellow Network, they are held in audited smart contracts on the blockchain, not by a company or individual. +- **Node registration** — node operators register on-chain by posting YELLOW tokens as a security deposit. +- **Dispute enforcement** — if someone cheats, the blockchain is the final court. Fraud proofs are submitted on-chain, and the cheater's collateral is automatically seized. + +You can think of Layer 1 as the vault and the judge — it holds the real assets and enforces the rules. + +### Layer 2 — The Clearnet (Off-Chain Ledger) + +This is where the speed comes from. Instead of recording every transaction on a blockchain (which is slow and expensive), Yellow Network runs an off-chain peer-to-peer ledger called the **Yellow Clearnet**. + +Here's how it works: + +1. **Independent node operators** run open-source software (called a "clearnode") on their own servers. There is no central server — the network is formed by these independent operators. + +2. **Every user account is guarded by a group of nodes**, not a single one. These nodes are selected algorithmically based on proximity in a shared address space (using a system called Kademlia, the same technology behind BitTorrent). The group collectively manages the account using **threshold cryptography** — meaning a supermajority of the group must agree before any balance can change. No single node can steal funds. + +3. **Security scales with value.** A small account might be guarded by 3 nodes. A high-value account could be guarded by up to 256. The protocol automatically ensures that the total collateral posted by the nodes guarding an account always exceeds the value in that account — so cheating always costs more than it gains. + +4. **A separate ring of watcher nodes** independently verifies every transaction. If the primary group tries to process a fraudulent transaction, the watchers catch it, produce a cryptographic fraud proof, and submit it to the blockchain. The cheating nodes lose their collateral automatically. + +The result: transactions clear in sub-second time (compared to minutes or hours on-chain), while retaining the security guarantees of the underlying blockchains. + +### Layer 3 — Applications + +On top of the Clearnet, developers build applications using the **Yellow SDK**. This is the user-facing layer: + +- **Yellow App Store** — a registry of applications built on the network. +- **Developer tools** — the SDK abstracts away the complexity of state channels, multi-chain settlement, and cryptographic signing. A developer can build an app that works across six blockchains without dealing with any of that directly. +- **Dispute resolution** — if there is a disagreement between a user and an application, independent arbitration forums can adjudicate the dispute, with outcomes enforced on-chain. + +--- + +## What Actually Happens When You Use It + +Here is a concrete example of a cross-chain transfer: + +1. **Alice** has 100 USDC on Ethereum deposited into Yellow Network. +2. She wants to send 50 USDC to **Bob**, who uses Base. +3. Alice's node cluster debits her account and produces a signed certificate. +4. The certificate is routed through the peer-to-peer network to Bob's node cluster. +5. Bob's cluster verifies the certificate and credits Bob's account. +6. Bob can now withdraw 50 USDC on Base (or any other supported chain). + +This entire process takes less than a second. No bridge. No centralised exchange. No on-chain gas fees for the transfer itself. The blockchains are only used for deposits, withdrawals, and dispute resolution. + +--- + +## The YELLOW Token + +YELLOW is the utility token that provides access to the goods and services supplied by Layer3 Fintech Ltd. within the Yellow Network. It has three specific functions: + +### 1. Mandatory Security Deposit for Node Operators + +Every node operator must post YELLOW tokens as collateral to register on the network. This is not optional — it is the mechanism that makes the network secure. + +- **Prevents spam attacks** — you cannot cheaply flood the network with malicious nodes because each one requires real collateral. +- **Deters fraud** — if a node participates in a fraudulent transaction, its collateral is automatically seized ("slashed") through on-chain fraud proofs. +- **Scales with responsibility** — as a node guards higher-value accounts, the protocol requires more collateral at risk. + +The minimum collateral starts at 10,000 YELLOW and scales up to 125,000 YELLOW as the network grows. + +### 2. Service Access Fee + +All network services — clearing, settlement, data delivery, app subscriptions — require the consumption of YELLOW as a service access fee. Users who hold YELLOW pay fees directly at a discounted rate. For users who do not yet hold YELLOW, an optional convenience mechanism allows payment in other assets (like ETH or USDT); independent third-party liquidity providers convert the payment into YELLOW before the protocol consumes it. + +Protocol fees from clearing and trading operations are locked into the collateral of the nodes that processed them — increasing those operators' slashing exposure. This strengthens network security over time. There is no fee distribution to passive token holders. + +### 3. Dispute Resolution Access + +App builders who register applications on the network post YELLOW as a service quality guarantee. Users who have disputes with an application pay a processing fee in YELLOW to access independent arbitration. If the dispute is upheld, the app builder's collateral can be slashed. + +### What YELLOW Is Not + +- It does not represent ownership in Layer3 Fintech Ltd. or any affiliated entity. +- It does not entitle holders to dividends, profit-sharing, or any form of financial return. +- It is not designed to maintain a stable value — there is no peg, no reserve backing, and no stabilisation mechanism. +- Holding YELLOW alone does not grant participation in protocol parameter administration — that requires actively operating a node. + +The total supply is fixed at **10 billion YELLOW**. No new tokens can ever be created, and there is no burn mechanism. + +--- + +## Who Runs the Network? + +Yellow Network is operated by **independent node operators** who run the open-source clearnode software on their own infrastructure. Layer3 Fintech Ltd. develops and maintains the software — but it does not operate the network itself. This is similar to how a software company distributes server software that thousands of independent hosting providers run on their own hardware. + +The protocol's on-chain smart contracts contain configurable parameters (security thresholds, fee levels, supported chains) that need to be updated as the network evolves. These parameters are administered by active node operators through a distributed multi-signature process — replacing what would otherwise be a single administrator key (a security risk). This parameter administration is an operational duty of running a node, not a right that comes with holding the token. + +--- + +## Key Numbers + +| Metric | Value | +|---|---| +| Total YELLOW supply | 10,000,000,000 (fixed) | +| Supported blockchains | Ethereum, Base, Arbitrum, Linea, BNB Chain, Polygon | +| Minimum node collateral | 10,000 YELLOW (scales to 125,000) | +| Max nodes per account | 256 | +| Min nodes per account | 3 | +| Collateral unlock period | 14 days | +| Transaction speed | Sub-second (off-chain clearing) | +| Fee range | 0.1% — 0.4% (dynamic) | + +## Token Allocation + +| Allocation | Percentage | Purpose | +|---|---|---| +| Founders | 10% | Subject to 6-month cliff and 60-month linear vesting | +| Token Sales | 12.5% | Distributed to participants who require YELLOW for service access | +| Community Treasury | 30% | Grants for app builders who consume YELLOW for services | +| Foundation Treasury | 20% | Funds ongoing R&D and delivery of Yellow Network services | +| Network Growth Incentives | 25% | Distributed automatically based on network scale | +| Ecosystem Accessibility Reserve | 2.5% | Ensures YELLOW remains accessible for its intended utility | + +The Foundation controls 50% of total supply (Community Treasury + Foundation Treasury), subject to linear vesting with quarterly reporting on all movements. + +--- + +## Security and Audits + +Yellow Network's smart contracts have been independently audited: + +- **Hacken (2024)** — Security assessment of the Ethereum smart contracts. No critical issues found. [Full report](https://hacken.io/audits/openware-yellow-network/sca-yellow-network-vault-sept-2024/) +- **GuardianAudits (ongoing)** — Auditing the decentralised ledger (Yellow Clearnet). [Reports](https://github.com/GuardianAudits/Audits/tree/main/Yellow%20Network/) + +The core state channel technology builds on academic research from statechannels.org and the VirtualApp framework, developed in collaboration with Consensys and other open-source contributors. + +--- + +## Where to Learn More + +- **Website:** [yellow.org](https://yellow.org/) +- **Developer docs:** [docs.yellow.org](https://docs.yellow.org/) +- **Protocol source code:** [github.com/layer-3/clearnet](https://github.com/layer-3/clearnet) +- **Documentation source:** [github.com/layer-3/docs](https://github.com/layer-3/docs) + +--- + +## Legal Entity + +Yellow Network's goods and services are supplied by **Layer3 Fintech Ltd.**, a company registered in the British Virgin Islands (Registration: 2092094), with its parent entity **Layer3 Foundation** based in the Cayman Islands. The sole director is Paul Parker. The applicable law and competent court for the token offering is Ireland. + +YELLOW is classified as a **utility token** under EU Regulation 2023/1114 (MiCA), Article 3(1)(9) — a token that is only intended to provide access to a good or a service supplied by its issuer. It is not a financial instrument, not an asset-referenced token, not an e-money token, and not a security. diff --git a/docs/contracts/integration/_category_.json b/docs/contracts/integration/_category_.json new file mode 100644 index 0000000..a293399 --- /dev/null +++ b/docs/contracts/integration/_category_.json @@ -0,0 +1,9 @@ +{ + "label": "Integration", + "position": 6, + "link": { + "type": "generated-index" + }, + "collapsible": false, + "collapsed": false +} diff --git a/docs/contracts/integration/deployment.md b/docs/contracts/integration/deployment.md new file mode 100644 index 0000000..560ae51 --- /dev/null +++ b/docs/contracts/integration/deployment.md @@ -0,0 +1,123 @@ +--- +title: "Deployment" +description: "Deploying contracts and configuration." +sidebar_position: 1 +displayed_sidebar: contractsSidebar +--- + +# Deployment + +## Prerequisites + +- [Foundry](https://book.getfoundry.sh/getting-started/installation) +- An `.env` file (see `.env.example`) + +## Scripts + +| Script | Wrapper | Purpose | +|---|---|---| +| `DeployToken.s.sol` | `deploy-token.sh` | Deploy YellowToken | +| `DeployFaucet.s.sol` | `deploy-faucet.sh` | Deploy Faucet (testnet only) | +| `DeployTreasury.s.sol` | — | Deploy Treasury | +| `DeployRegistry.s.sol` | — | Deploy registries + governance | + +## Deployment Order + +1. **YellowToken** — deploy first, get the token address +2. **Registry + Governance** — needs token address; deploys NodeRegistry, AppRegistry, TimelockController, YellowGovernor in one script +3. **Treasury** — independent; can be owned by Foundation or transferred to TimelockController + +## Configuration + +```bash +cp .env.example .env +``` + +### Token + +| Variable | Description | +|---|---| +| `FOUNDATION_ADDRESS` | Receives the initial 10B YELLOW supply | + +### Registry + Governance + +| Variable | Default | Description | +|---|---|---| +| `TOKEN_ADDRESS` | — | Deployed YellowToken address | +| `ADJUDICATOR_ADDRESS` | — | Initial adjudicator for AppRegistry | +| `PROPOSAL_GUARDIAN` | — | Foundation multisig for emergency cancel | +| `VOTING_DELAY` | 7200 | Blocks before voting starts (~1 day) | +| `VOTING_PERIOD` | 50400 | Blocks vote stays open (~1 week) | +| `PROPOSAL_THRESHOLD` | 10M YELLOW | Min voting power to propose | +| `QUORUM_NUMERATOR` | 4 | Quorum as % of locked supply | +| `QUORUM_FLOOR` | 100M YELLOW | Minimum absolute quorum | +| `VOTE_EXTENSION` | 14400 | Late quorum extension (~2 days) | +| `NODE_UNLOCK_PERIOD` | 14 days | NodeRegistry withdrawal delay | +| `APP_UNLOCK_PERIOD` | 14 days | AppRegistry withdrawal delay | +| `TIMELOCK_DELAY` | 172800 | Seconds before execution (2 days) | + +### Treasury + +| Variable | Default | Description | +|---|---|---| +| `FOUNDATION_ADDRESS` | — | Treasury owner | +| `TREASURY_NAME` | "Treasury" | Human-readable label | + +### Faucet (Sepolia only) + +| Variable | Default | Description | +|---|---|---| +| `TOKEN_ADDRESS` | — | Deployed YellowToken address | +| `DRIP_AMOUNT` | 1000 YELLOW | Amount per drip | +| `DRIP_COOLDOWN` | 86400 (1 day) | Seconds between drips | + +## Running + +### Sepolia + +```bash +./script/deploy-token.sh +./script/deploy-faucet.sh +``` + +### Mainnet + +Set `NETWORK="mainnet"` in `.env`, then: + +```bash +./script/deploy-token.sh +``` + +For registry and treasury, run forge directly: + +```bash +forge script script/DeployRegistry.s.sol --rpc-url $RPC --broadcast --verify +forge script script/DeployTreasury.s.sol --rpc-url $RPC --broadcast --verify +``` + +## Post-Deployment + +After deploying the registry + governance stack, the script automatically: + +1. Grants `ADJUDICATOR_ROLE` to the specified adjudicator +2. Transfers AppRegistry `DEFAULT_ADMIN_ROLE` to the TimelockController +3. Renounces the deployer's admin roles on both AppRegistry and TimelockController + +No manual role setup is needed. + +## Updating the SDK + +After deploying new contracts, addresses are extracted automatically from the Forge broadcast artifacts: + +```bash +make sdk-build # extracts ABIs + addresses, builds SDK +make docs # regenerates docs (including addresses page) +``` + +Then publish a new SDK version: + +```bash +make release v=1.1.0 +git push origin master --tags +cd sdk && npm publish +``` diff --git a/docs/contracts/integration/events.md b/docs/contracts/integration/events.md new file mode 100644 index 0000000..1c62073 --- /dev/null +++ b/docs/contracts/integration/events.md @@ -0,0 +1,115 @@ +--- +title: "Events" +description: "Contract events for real-time subscriptions." +sidebar_position: 2 +displayed_sidebar: contractsSidebar +--- + +# Events + +Contract events for real-time UI subscriptions. Use `watchContractEvent` (viem) or `contract.on` (ethers) to listen. + +## Staking Events + +Emitted by both NodeRegistry and AppRegistry (inherited from Locker). + +| Event | Parameters | Indexed | +|---|---|---| +| `Locked` | `user` (address), `deposited` (uint256), `newBalance` (uint256) | `user` | +| `Relocked` | `user` (address), `balance` (uint256) | `user` | +| `UnlockInitiated` | `user` (address), `balance` (uint256), `availableAt` (uint256) | `user` | +| `Withdrawn` | `user` (address), `balance` (uint256) | `user` | + +## Voting Events + +Emitted by NodeRegistry only (inherited from OZ Votes). + +| Event | Parameters | Indexed | +|---|---|---| +| `DelegateChanged` | `delegator` (address), `fromDelegate` (address), `toDelegate` (address) | `delegator`, `fromDelegate`, `toDelegate` | +| `DelegateVotesChanged` | `delegate` (address), `previousVotes` (uint256), `newVotes` (uint256) | `delegate` | +| `EIP712DomainChanged` | | — | + +## Slashing Events + +Emitted by AppRegistry only. + +| Event | Parameters | Indexed | +|---|---|---| +| `RoleAdminChanged` | `role` (bytes32), `previousAdminRole` (bytes32), `newAdminRole` (bytes32) | `role`, `previousAdminRole`, `newAdminRole` | +| `RoleGranted` | `role` (bytes32), `account` (address), `sender` (address) | `role`, `account`, `sender` | +| `RoleRevoked` | `role` (bytes32), `account` (address), `sender` (address) | `role`, `account`, `sender` | +| `SlashCooldownUpdated` | `oldCooldown` (uint256), `newCooldown` (uint256) | — | + +## Governance Events + +Emitted by YellowGovernor. + +| Event | Parameters | Indexed | +|---|---|---| +| `LateQuorumVoteExtensionSet` | `oldVoteExtension` (uint64), `newVoteExtension` (uint64) | — | +| `ProposalCanceled` | `proposalId` (uint256) | — | +| `ProposalCreated` | `proposalId` (uint256), `proposer` (address), `targets` (address[]), `values` (uint256[]), `signatures` (string[]), `calldatas` (bytes[]), `voteStart` (uint256), `voteEnd` (uint256), `description` (string) | — | +| `ProposalExecuted` | `proposalId` (uint256) | — | +| `ProposalExtended` | `proposalId` (uint256), `extendedDeadline` (uint64) | `proposalId` | +| `ProposalGuardianSet` | `oldProposalGuardian` (address), `newProposalGuardian` (address) | — | +| `ProposalQueued` | `proposalId` (uint256), `etaSeconds` (uint256) | — | +| `ProposalThresholdSet` | `oldProposalThreshold` (uint256), `newProposalThreshold` (uint256) | — | +| `QuorumFloorUpdated` | `oldFloor` (uint256), `newFloor` (uint256) | — | +| `QuorumNumeratorUpdated` | `oldQuorumNumerator` (uint256), `newQuorumNumerator` (uint256) | — | +| `TimelockChange` | `oldTimelock` (address), `newTimelock` (address) | — | +| `VoteCast` | `voter` (address), `proposalId` (uint256), `support` (uint8), `weight` (uint256), `reason` (string) | `voter` | +| `VoteCastWithParams` | `voter` (address), `proposalId` (uint256), `support` (uint8), `weight` (uint256), `reason` (string), `params` (bytes) | `voter` | +| `VotingDelaySet` | `oldVotingDelay` (uint256), `newVotingDelay` (uint256) | — | +| `VotingPeriodSet` | `oldVotingPeriod` (uint256), `newVotingPeriod` (uint256) | — | + +## Treasury Events + +Emitted by Treasury. + +| Event | Parameters | Indexed | +|---|---|---| +| `OwnershipTransferStarted` | `previousOwner` (address), `newOwner` (address) | `previousOwner`, `newOwner` | +| `OwnershipTransferred` | `previousOwner` (address), `newOwner` (address) | `previousOwner`, `newOwner` | +| `Transferred` | `token` (address), `to` (address), `amount` (uint256) | `token`, `to` | + +## Faucet Events + +Emitted by Faucet (Sepolia only). + +| Event | Parameters | Indexed | +|---|---|---| +| `CooldownUpdated` | `newCooldown` (uint256) | — | +| `DripAmountUpdated` | `newAmount` (uint256) | — | +| `Dripped` | `recipient` (address), `amount` (uint256) | `recipient` | +| `OwnerUpdated` | `newOwner` (address) | `newOwner` | + +## Subscribing with the SDK + +```ts +import { NodeRegistryAbi, YellowGovernorAbi, addresses } from "@yellow-org/contracts"; + +// Watch locks +publicClient.watchContractEvent({ + address: addresses[1].nodeRegistry!, + abi: NodeRegistryAbi, + eventName: "Locked", + onLogs: (logs) => { + for (const log of logs) { + console.log(`${log.args.user} locked ${log.args.deposited}`); + } + }, +}); + +// Watch proposals +publicClient.watchContractEvent({ + address: addresses[1].governor!, + abi: YellowGovernorAbi, + eventName: "ProposalCreated", + onLogs: (logs) => { + for (const log of logs) { + console.log(`New proposal: ${log.args.proposalId}`); + } + }, +}); +``` diff --git a/docs/contracts/integration/ui-spec.md b/docs/contracts/integration/ui-spec.md new file mode 100644 index 0000000..3acf506 --- /dev/null +++ b/docs/contracts/integration/ui-spec.md @@ -0,0 +1,98 @@ +--- +title: "UI Specification" +description: "Frontend implementation guide." +sidebar_position: 3 +displayed_sidebar: contractsSidebar +--- + +# UI Specification + +Frontend implementation guide for the Yellow Network dApp. All contracts use Solidity 0.8.34 on Ethereum. + +## Recommended Stack + +- **Wallet connection:** wagmi + viem +- **ABIs & addresses:** `@yellow-org/contracts` SDK +- **React hooks:** `useReadContract`, `useWriteContract`, `useWatchContractEvent` + +## Pages + +### 1. Token / Wallet + +- Display connected address, ETH balance, YELLOW balance +- Network switcher (Mainnet / Sepolia) +- On Sepolia: show Faucet drip button with cooldown timer + +**Approval flow:** Before any `lock()`, check `allowance()` and prompt `approve()` (or `permit()` for gasless UX). + +### 2. Collateral + +Both registries share the same ILock state machine. Use a toggle or tabs for Node Operator / App Builder. + +**Idle state:** +- Lock form: amount input + "Post Collateral" button +- Prompt token approval if needed + +**Locked state:** +- Show locked balance (security deposit amount) +- "Top Up" button (calls `lock()` again) +- "Unlock" button (starts countdown) +- NodeRegistry: show collateral weight and delegation + +**Unlocking state:** +- Locked balance + countdown timer (`unlockTimestamp - now`) +- "Relock" button (cancel unlock) +- "Withdraw" button (disabled until countdown = 0) +- Destination address input (default: connected wallet) + +**NodeRegistry-specific:** +- Show "Delegated to: \{address\}" with option to change +- Warning before `unlock()`: "This will remove your collateral weight from parameter administration" +- Display current collateral weight + +### 3. Protocol Parameter Administration + +**Proposal list:** +- Fetch via `ProposalCreated` events +- Show state badge (Pending/Active/Succeeded/Queued/Executed/Defeated/Canceled) +- For Active proposals: support tallies with progress bars, quorum progress + +**Create proposal:** +- Pre-check: user's collateral weight >= proposalThreshold +- Template selector for common actions (treasury transfer, role grant, etc.) +- Custom action builder: target, function, params, value + +**Proposal detail:** +- State-dependent action buttons: Signal Support (Active), Queue (Succeeded), Execute (Queued) +- Support buttons: For / Against / Abstain +- Show "Already signalled" if `hasVoted() == true` +- Timelock countdown when Queued + +### 4. Treasury (admin) + +- Show ETH and YELLOW balances +- If owned by TimelockController: "Create Proposal" shortcut +- If owned directly: transfer form (token, to, amount) + +### 5. Adjudicator Panel (admin) + +- Slash form: user, amount, recipient, decision +- Cooldown status: time remaining until next slash allowed +- Role check: only show if connected wallet has ADJUDICATOR_ROLE + +## State Reads Summary + +| Data | Contract | Function | +|---|---|---| +| YELLOW balance | YellowToken | `balanceOf(address)` | +| Lock state | NodeRegistry/AppRegistry | `lockStateOf(address)` | +| Locked amount | NodeRegistry/AppRegistry | `balanceOf(address)` | +| Unlock countdown | NodeRegistry/AppRegistry | `unlockTimestampOf(address)` | +| Collateral weight | NodeRegistry | `getVotes(address)` | +| Delegate | NodeRegistry | `delegates(address)` | +| Proposal state | YellowGovernor | `state(proposalId)` | +| Support tallies | YellowGovernor | `proposalVotes(proposalId)` | +| Quorum needed | YellowGovernor | `quorum(blockNumber)` | +| Has signalled | YellowGovernor | `hasVoted(proposalId, address)` | +| Treasury owner | Treasury | `owner()` | +| Slash cooldown | AppRegistry | `slashCooldown()`, `lastSlashTimestamp()` | diff --git a/docs/contracts/protocol/_category_.json b/docs/contracts/protocol/_category_.json new file mode 100644 index 0000000..217fd89 --- /dev/null +++ b/docs/contracts/protocol/_category_.json @@ -0,0 +1,9 @@ +{ + "label": "Protocol", + "position": 3, + "link": { + "type": "generated-index" + }, + "collapsible": false, + "collapsed": false +} diff --git a/docs/contracts/protocol/governance.md b/docs/contracts/protocol/governance.md new file mode 100644 index 0000000..bf65e76 --- /dev/null +++ b/docs/contracts/protocol/governance.md @@ -0,0 +1,101 @@ +--- +title: "Governance" +description: "On-chain parameter administration via YellowGovernor." +sidebar_position: 2 +displayed_sidebar: contractsSidebar +--- + +# Protocol Parameter Administration + +The Yellow Network's on-chain smart contracts contain configurable parameters — security thresholds, fee levels, blockchain confirmation requirements — that must be updated as the network evolves. Without a parameter administration mechanism, these contracts would require a centralised administrator key, which is a critical single point of failure. + +Node operator parameter administration replaces this centralised key with distributed multi-signature execution. Parameter changes require collective agreement from multiple independent operators. This is a protocol security mechanism that removes a centralisation risk from the network's infrastructure. + +**Parameter administration is restricted to active node operators** — entities that run clearnode software, maintain collateral above the protocol minimum, and actively process transactions on the network. Holding YELLOW tokens alone does not grant parameter administration participation. A token holder who does not operate network infrastructure has no ability to propose or approve parameter changes, regardless of the quantity of tokens held. + +Parameter administration scope is strictly limited to protocol-level service parameters: security thresholds, fee parameters, supported blockchain integrations, confirmation requirements, and protocol upgrade activation. It does not extend to token supply decisions, treasury allocation, or issuer corporate matters, which remain the responsibility of Layer3 Foundation and Layer3 Fintech Ltd. + +## How It Works On-Chain + +Node operators post YELLOW tokens into the **NodeRegistry** as a mandatory functional security deposit. The NodeRegistry extends OpenZeppelin's `Votes`, which provides the on-chain accounting used to determine whether an operator meets the collateral threshold required to propose parameter changes. + +- **Auto-self-delegation** — on first lock, the operator is automatically set up so their collateral is counted immediately +- **Unlock removes participation** — calling `unlock()` zeroes out the operator's participation weight immediately, even before the unlock period elapses +- **Relock restores participation** — cancelling an unlock via `relock()` restores full participation weight +- **Delegation** — operators can delegate their collateral weight to another address via `delegate(address)` for the purpose of parameter administration + +## Proposal Lifecycle + +``` +Propose ──► [delay] ──► Operator Consensus ──► [consensus period] ──► Queue ──► [timelock delay] ──► Execute +``` + +### States + +| State | Value | Description | +|---|---|---| +| Pending | 0 | Proposal created, waiting for delay period | +| Active | 1 | Operator consensus period is open | +| Canceled | 2 | Proposal was canceled | +| Defeated | 3 | Consensus not reached (quorum not met or more Against) | +| Succeeded | 4 | Consensus reached, ready to queue | +| Queued | 5 | In timelock, waiting for delay | +| Expired | 6 | Queued but not executed in time | +| Executed | 7 | Successfully executed | + +## Governor Extensions + +| Extension | Purpose | +|---|---| +| `GovernorSettings` | Configurable delay, consensus period, and proposal threshold | +| `GovernorCountingSimple` | For / Against / Abstain signalling | +| `GovernorVotes` | Reads collateral weight from the NodeRegistry | +| `GovernorVotesQuorumFraction` | Quorum as percentage of total locked collateral | +| `GovernorTimelockControl` | Routes execution through TimelockController | +| `GovernorPreventLateQuorum` | Extends deadline if quorum reached late | +| `GovernorProposalGuardian` | Foundation emergency cancel | + +## Quorum + +Quorum is calculated as `max(fractionalQuorum, quorumFloor)`: + +- **Fractional quorum** — percentage of total locked collateral (default 4%) +- **Quorum floor** — absolute minimum (default 100M YELLOW) so quorum doesn't collapse if most collateral is withdrawn + +The quorum floor is checkpointed and can be updated via parameter administration (`setQuorumFloor`). + +## Default Parameters + +| Parameter | Default | Description | +|---|---|---| +| Proposal delay | 7,200 blocks (~1 day) | Time before consensus period starts | +| Consensus period | 50,400 blocks (~1 week) | How long operators can signal support | +| Proposal threshold | 10,000,000 YELLOW | Minimum collateral to create a proposal | +| Quorum numerator | 4% | Percentage of locked collateral required | +| Quorum floor | 100,000,000 YELLOW | Absolute minimum quorum | +| Deadline extension | 14,400 blocks (~2 days) | Extended deadline on late quorum | +| Timelock delay | 172,800 seconds (2 days) | Delay before execution | + +## Access Control Flow + +``` +NodeRegistry (collateral weight) ──► YellowGovernor (proposals) ──► TimelockController (delayed execution) + │ + AppRegistry (admin role) + Treasury (if owned by timelock) +``` + +The TimelockController is the actual executor — it holds `DEFAULT_ADMIN_ROLE` on the AppRegistry and can own Treasuries. The Governor is the only proposer/canceller on the timelock. After deployment, the deployer renounces all admin roles, leaving parameter administration fully in the hands of active node operators. + +## Common Parameter Administration Actions + +| Action | Target | Function | +|---|---|---| +| Transfer ETH from Treasury | Treasury | `transfer(address(0), recipient, amount)` | +| Transfer YELLOW from Treasury | Treasury | `transfer(tokenAddr, recipient, amount)` | +| Grant adjudicator role | AppRegistry | `grantRole(ADJUDICATOR_ROLE, address)` | +| Revoke adjudicator role | AppRegistry | `revokeRole(ADJUDICATOR_ROLE, address)` | +| Set slash cooldown | AppRegistry | `setSlashCooldown(seconds)` | +| Update quorum floor | Governor | `setQuorumFloor(newFloor)` | +| Update parameters | Governor | `setVotingDelay`, `setVotingPeriod`, `setProposalThreshold` | +| Set/remove proposal guardian | Governor | `setProposalGuardian(address)` | diff --git a/docs/contracts/protocol/overview.md b/docs/contracts/protocol/overview.md new file mode 100644 index 0000000..5dd9466 --- /dev/null +++ b/docs/contracts/protocol/overview.md @@ -0,0 +1,76 @@ +--- +title: "Protocol Overview" +description: "Architecture, contracts, and how they fit together." +sidebar_position: 1 +displayed_sidebar: contractsSidebar +--- + +# Protocol Overview + +Yellow Network is a decentralised clearing and settlement infrastructure that operates as a Layer-3 overlay on top of existing blockchains. It enables businesses — brokers, exchanges, and application developers — to move digital assets across multiple blockchain networks through a unified peer-to-peer ledger, without relying on a centralised intermediary. + +The YELLOW token is only intended to provide access to the goods and services supplied by Layer3 Fintech Ltd. within the Yellow Network. Node operators post YELLOW as a mandatory functional security deposit to operate clearnode infrastructure. App builders post YELLOW as a service quality guarantee on the AppRegistry. The Treasury holds Foundation assets used to fund continued research, development, and delivery of the goods and services accessible through YELLOW. + +## Architecture + +The Yellow Network operates as a three-layer architecture: + +- **Layer 1 (EVM Settlement)** — Smart contracts deployed on each supported chain (Ethereum, Base, Arbitrum, Linea, BNB, and Polygon) provide on-chain asset custody, the NodeRegistry for node operator registration and collateral management, the AppRegistry for application registration, and collateral slashing enforcement. +- **Layer 2 (Ledger Layer — Yellow Clearnet)** — A distributed peer-to-peer ledger that operates off-chain. Independent node operators form a decentralised network where each user account is guarded by a group of nodes using threshold cryptographic signatures. No single node can unilaterally move funds. +- **Layer 3 (Application Layer)** — Applications built on top of the Ledger Layer, including the Yellow App Store, SDK-built applications, and dispute adjudication through independent arbitration forums. + +### On-Chain Contract Layout + +``` +Node operators post YELLOW ──► NodeRegistry (collateral + parameter admin) + │ +App builders post YELLOW ─────► AppRegistry (collateral + slashing) │ + │ +Foundation ───────────────────► Treasury (Foundation assets) │ + │ + YellowGovernor ──► TimelockController ─────────┘ + (parameter proposals) (delayed execution) +``` + +## Contracts + +| Contract | Purpose | Key Interface | +|---|---|---| +| **YellowToken** | ERC-20 utility token, fixed 10B supply, EIP-2612 permit | `IERC20`, `IERC20Permit` | +| **Locker** | Abstract single-asset vault with time-locked withdrawals | `ILock` | +| **NodeRegistry** | Node operator collateral with protocol parameter administration | `ILock`, `IVotes` | +| **AppRegistry** | App builder collateral with adjudicator slashing | `ILock`, `ISlash`, `AccessControl` | +| **YellowGovernor** | Protocol parameter proposals and operator consensus | `IGovernor` | +| **TimelockController** | Delayed execution of parameter changes | OZ `TimelockController` | +| **Treasury** | Foundation vault for ETH and ERC-20 assets | `Ownable2Step` | +| **Faucet** | Testnet token dispenser (Sepolia only) | — | + +## Token + +- **Fixed supply:** 10,000,000,000 YELLOW (10 billion) — no new tokens can ever be created +- **No mint/burn:** supply is fixed at deployment +- **Permit:** EIP-2612 gasless approvals +- **Utility:** only intended to provide access to Yellow Network services supplied by Layer3 Fintech Ltd. + +## Access Control Summary + +| Role | Held By | Can Do | +|---|---|---| +| NodeRegistry — no roles | Open | Anyone can lock/unlock | +| AppRegistry `DEFAULT_ADMIN_ROLE` | TimelockController | Grant/revoke adjudicators, set slash cooldown | +| AppRegistry `ADJUDICATOR_ROLE` | Adjudicator address(es) | Slash misbehaving app builders | +| Governor proposer | Any active node operator with sufficient collateral | Create parameter change proposals | +| Governor proposal guardian | Foundation multisig | Cancel any proposal (emergency) | +| TimelockController executor | Open (anyone) | Execute queued proposals after delay | +| Treasury owner | Foundation or TimelockController | Transfer funds out | + +## Security Model + +- **Value-at-Risk collateral** — the protocol dynamically ensures that total collateral posted by nodes guarding any account exceeds the value of assets held, making fraud economically irrational +- **Timelock delay** — all parameter changes are delayed (default 2 days), giving participants time to respond +- **Quorum floor** — absolute minimum quorum prevents parameter capture when total locked supply is low +- **Late quorum protection** — deadline extends if quorum is reached late, preventing last-second manipulation +- **Proposal guardian** — Foundation can emergency-cancel proposals; removable via parameter administration +- **Slash cooldown** — rate-limits slashing to prevent batch-draining by a rogue adjudicator +- **Unlock period** — 14-day withdrawal delay prevents flash-loan attacks on the collateral system +- **Ownable2Step** — Treasury ownership transfer requires explicit acceptance diff --git a/docs/contracts/protocol/slashing.md b/docs/contracts/protocol/slashing.md new file mode 100644 index 0000000..394e729 --- /dev/null +++ b/docs/contracts/protocol/slashing.md @@ -0,0 +1,83 @@ +--- +title: "Slashing" +description: "Adjudicator slashing and cooldown mechanism." +sidebar_position: 4 +displayed_sidebar: contractsSidebar +--- + +# Slashing + +The AppRegistry allows authorized adjudicators to slash misbehaving app builders' locked collateral. Slashing transfers tokens from the user's balance to a specified recipient. This mechanism enforces service quality guarantees for applications registered on the Yellow Network. + +## How It Works + +1. An address with `ADJUDICATOR_ROLE` calls `slash(user, amount, recipient, decision)` +2. The user's locked balance is reduced by `amount` +3. `amount` tokens are transferred to `recipient` +4. If the full balance is slashed, the user's state resets to Idle + +## Slash Function + +```solidity +function slash( + address user, // The user to slash + uint256 amount, // Amount to slash + address recipient, // Where slashed tokens go (cannot be the adjudicator) + bytes decision // Off-chain reference to the dispute decision +) external onlyRole(ADJUDICATOR_ROLE) nonReentrant; +``` + +### Rules + +- Only callable by addresses with `ADJUDICATOR_ROLE` +- `recipient` cannot be the calling adjudicator (prevents self-enrichment) +- Slashing works in both **Locked** and **Unlocking** states +- Full slash (entire balance) resets the user to Idle +- Partial slash preserves the current state (Locked stays Locked, Unlocking stays Unlocking) + +## Slash Cooldown + +A global cooldown can be set to rate-limit slashing. This prevents a rogue adjudicator from batch-draining all users in a single transaction. + +```solidity +function setSlashCooldown(uint256 newCooldown) external onlyRole(DEFAULT_ADMIN_ROLE); +``` + +- **Default:** 0 (disabled) +- When set, only one slash can occur per cooldown window globally +- The first slash after deployment (or after cooldown is enabled) is always allowed +- `setSlashCooldown(0)` disables the cooldown + +### The Attack It Prevents + +Without cooldown, a rogue adjudicator can: + +``` +slash(userA, ...) + slash(userB, ...) + slash(userC, ...) // all in one tx +``` + +This drains every user before the admin can revoke the role. + +With cooldown (e.g. 1 hour), only one slash per hour is possible, giving active node operators time to revoke the rogue adjudicator through parameter administration. + +## Role Management + +| Role | Held By | Purpose | +|---|---|---| +| `DEFAULT_ADMIN_ROLE` | TimelockController (parameter administration) | Grant/revoke adjudicators, set cooldown | +| `ADJUDICATOR_ROLE` | Authorized adjudicator(s) | Call `slash()` | + +Roles are managed via parameter administration proposals that execute through the TimelockController: + +- **Grant:** `appRegistry.grantRole(ADJUDICATOR_ROLE, newAdjudicator)` +- **Revoke:** `appRegistry.revokeRole(ADJUDICATOR_ROLE, rogueAdjudicator)` +- **Set cooldown:** `appRegistry.setSlashCooldown(3600)` (1 hour) + +## Events + +| Event | Parameters | When | +|---|---|---| +| `Slashed` | `user`, `amount`, `recipient`, `decision` | User was slashed | +| `SlashCooldownUpdated` | `oldCooldown`, `newCooldown` | Cooldown changed | +| `RoleGranted` | `role`, `account`, `sender` | Adjudicator added | +| `RoleRevoked` | `role`, `account`, `sender` | Adjudicator removed | diff --git a/docs/contracts/protocol/staking.md b/docs/contracts/protocol/staking.md new file mode 100644 index 0000000..f448f84 --- /dev/null +++ b/docs/contracts/protocol/staking.md @@ -0,0 +1,94 @@ +--- +title: "Collateral & Staking" +description: "Lock/unlock state machine for NodeRegistry and AppRegistry." +sidebar_position: 3 +displayed_sidebar: contractsSidebar +--- + +# Collateral + +Both NodeRegistry and AppRegistry implement the `ILock` interface — a single-asset vault with a time-locked withdrawal mechanism. Node operators and app builders post YELLOW tokens as a mandatory functional security deposit, initiate an unlock, wait for the period to elapse, then withdraw. + +Node operators post collateral to register and operate clearnode infrastructure on the Yellow Network using Layer3 Fintech Ltd.'s open-source software. App builders post collateral on the AppRegistry as a service quality guarantee for applications registered on the network. + +## State Machine + +``` + lock(target, amount) unlock() withdraw(destination) + Idle ──────────────────► Locked ──────────► Unlocking ─────────────────► Idle + │ │ + lock() top-up relock() + (stays Locked) (back to Locked) +``` + +### States + +| State | Value | Description | +|---|---|---| +| Idle | 0 | No locked balance | +| Locked | 1 | Tokens are locked as collateral | +| Unlocking | 2 | Countdown started, waiting for unlock period | + +## Functions + +### lock(target, amount) + +Deposits `amount` YELLOW tokens into the vault, crediting `target`. The caller must have approved the registry to spend their tokens. Can be called multiple times to top up while in the Locked state. + +- **Reverts** if `target` is in Unlocking state (`AlreadyUnlocking`) +- **Reverts** if `amount` is zero (`InvalidAmount`) +- Anyone can lock tokens on behalf of another address + +### unlock() + +Starts the withdrawal countdown for the caller's full balance. The unlock period is set at deployment (default 14 days). + +- **Reverts** if caller has no locked balance (`NotLocked`) +- **Reverts** if already unlocking (`AlreadyUnlocking`) +- **NodeRegistry:** immediately removes the operator's collateral weight from parameter administration + +### relock() + +Cancels an in-progress unlock and returns to the Locked state. + +- **Reverts** if not in Unlocking state (`NotUnlocking`) +- **NodeRegistry:** immediately restores the operator's collateral weight + +### withdraw(destination) + +Transfers the caller's full locked balance to `destination` after the unlock period has elapsed. + +- **Reverts** if not in Unlocking state (`NotUnlocking`) +- **Reverts** if countdown hasn't finished (`UnlockPeriodNotElapsed`) +- Resets state to Idle + +## View Functions + +| Function | Returns | Description | +|---|---|---| +| `asset()` | `address` | YELLOW token address | +| `UNLOCK_PERIOD()` | `uint256` | Withdrawal delay in seconds | +| `lockStateOf(address)` | `LockState` | Current state (0/1/2) | +| `balanceOf(address)` | `uint256` | Locked balance | +| `unlockTimestampOf(address)` | `uint256` | When withdrawal becomes available (0 if not unlocking) | + +## NodeRegistry vs AppRegistry + +| Feature | NodeRegistry | AppRegistry | +|---|---|---| +| Purpose | Node operator security deposit | App builder service quality guarantee | +| Parameter admin weight | Yes (OZ `Votes`) | No | +| Auto-self-delegation | Yes (on first lock) | N/A | +| Delegation | Yes (`delegate(address)`) | N/A | +| Slashing | No | Yes (`ADJUDICATOR_ROLE`) | +| Slash cooldown | N/A | Yes (`setSlashCooldown`) | +| Access control | Open | `AccessControl` (admin + adjudicator roles) | + +## Events + +| Event | Parameters | When | +|---|---|---| +| `Locked` | `user`, `deposited`, `newBalance` | Tokens locked as collateral | +| `UnlockInitiated` | `user`, `balance`, `availableAt` | Unlock started | +| `Relocked` | `user`, `balance` | Unlock cancelled | +| `Withdrawn` | `user`, `balance` | Tokens withdrawn | diff --git a/docs/contracts/protocol/treasury.md b/docs/contracts/protocol/treasury.md new file mode 100644 index 0000000..3558c0d --- /dev/null +++ b/docs/contracts/protocol/treasury.md @@ -0,0 +1,68 @@ +--- +title: "Treasury" +description: "Foundation asset management." +sidebar_position: 5 +displayed_sidebar: contractsSidebar +--- + +# Treasury + +The Treasury is a secure vault for Layer3 Foundation assets. It supports ETH and ERC-20 transfers and is protected by `Ownable2Step` to prevent accidental ownership loss. + +The Foundation Treasury is funded by fees from Yellow App Store subscriptions and premium application-layer features, and is used to fund continued research, development, and delivery of the goods and services accessible through YELLOW. Protocol fees from clearing and trading operations are separate and are locked into node operators' collateral (see [Collateral](./staking.md)). + +## Transfer Function + +```solidity +function transfer( + address token, // address(0) for ETH, otherwise ERC-20 address + address to, // destination address + uint256 amount // amount to transfer +) external onlyOwner nonReentrant; +``` + +- Only the owner can call `transfer()` +- For ERC-20 tokens with fee-on-transfer, the event emits the actual amount received +- `renounceOwnership()` is disabled to prevent permanently locking funds + +## Ownership + +The Treasury uses OpenZeppelin's `Ownable2Step`: + +1. Current owner calls `transferOwnership(newOwner)` +2. New owner calls `acceptOwnership()` to complete the transfer + +This two-step process prevents accidentally transferring ownership to an incorrect address. + +### Ownership Models + +**Foundation-owned (direct):** +- The Foundation multisig is the owner +- Can call `transfer()` directly + +**Parameter-administration-owned (via TimelockController):** +- The TimelockController is the owner +- Transfers require a parameter administration proposal: propose, reach operator consensus, queue, execute +- Provides oversight by active node operators over treasury funds + +## Receiving Funds + +The Treasury accepts: +- **ETH** — via the `receive()` function (just send ETH to the contract) +- **ERC-20** — via standard `transfer()` or `transferFrom()` to the contract address + +## Events + +| Event | Parameters | When | +|---|---|---| +| `Transferred` | `token`, `to`, `amount` | Funds moved out | +| `OwnershipTransferred` | `previousOwner`, `newOwner` | Ownership changed | +| `OwnershipTransferStarted` | `previousOwner`, `newOwner` | Transfer initiated | + +## View Functions + +| Function | Returns | Description | +|---|---|---| +| `name()` | `string` | Human-readable label (e.g. "Grants", "Operations") | +| `owner()` | `address` | Current owner | +| `pendingOwner()` | `address` | Address that can accept ownership (0 if none) | diff --git a/docs/contracts/sdk/_category_.json b/docs/contracts/sdk/_category_.json new file mode 100644 index 0000000..6ea8e3e --- /dev/null +++ b/docs/contracts/sdk/_category_.json @@ -0,0 +1,9 @@ +{ + "label": "SDK", + "position": 5, + "link": { + "type": "generated-index" + }, + "collapsible": false, + "collapsed": false +} diff --git a/docs/contracts/sdk/api-reference.md b/docs/contracts/sdk/api-reference.md new file mode 100644 index 0000000..bdbd042 --- /dev/null +++ b/docs/contracts/sdk/api-reference.md @@ -0,0 +1,89 @@ +--- +title: "SDK API Reference" +description: "All exports: ABIs, addresses, and types." +sidebar_position: 2 +displayed_sidebar: contractsSidebar +--- + +# SDK — API Reference + +All exports from `@yellow-org/contracts`. + +## ABIs + +Each ABI is exported as a `const` array for full type inference with viem and wagmi. + +```ts +import { + YellowTokenAbi, + NodeRegistryAbi, + AppRegistryAbi, + YellowGovernorAbi, + TimelockControllerAbi, + TreasuryAbi, + FaucetAbi, + ILockAbi, + ISlashAbi, +} from "@yellow-org/contracts"; +``` + +| Export | Contract | ABI Entries | Description | +|---|---|---|---| +| `YellowTokenAbi` | YellowToken | 33 | ERC-20 + EIP-2612 permit | +| `NodeRegistryAbi` | NodeRegistry | 48 | Staking + voting (ILock + IVotes) | +| `AppRegistryAbi` | AppRegistry | 46 | Collateral + slashing (ILock + ISlash + AccessControl) | +| `YellowGovernorAbi` | YellowGovernor | 98 | Governance (Governor + extensions) | +| `TimelockControllerAbi` | TimelockController | 46 | Delayed execution | +| `TreasuryAbi` | Treasury | 16 | Foundation vault | +| `FaucetAbi` | Faucet | 16 | Testnet faucet | +| `ILockAbi` | ILock | 19 | Lock/unlock interface (shared by both registries) | +| `ISlashAbi` | ISlash | 4 | Slash interface | + +### Interface ABIs + +Use `ILockAbi` to write generic code that works with both NodeRegistry and AppRegistry: + +```ts +import { ILockAbi } from "@yellow-org/contracts"; + +// Works with either registry +const balance = await client.readContract({ + address: registryAddress, + abi: ILockAbi, + functionName: "balanceOf", + args: [userAddress], +}); +``` + +## Addresses + +```ts +import { addresses, type ContractAddresses } from "@yellow-org/contracts"; +``` + +### `addresses` + +`Record>` — deployed addresses keyed by chain ID. + +```ts +addresses[1] // Ethereum Mainnet +addresses[11155111] // Sepolia +``` + +### `ContractAddresses` type + +```ts +type ContractAddresses = { + yellowToken: `0x${string}`; + nodeRegistry: `0x${string}`; + appRegistry: `0x${string}`; + governor: `0x${string}`; + timelock: `0x${string}`; + treasury: `0x${string}`; + faucet?: `0x${string}`; // testnet only +}; +``` + +### Current Addresses + +See [Deployed Addresses](../operations/addresses.md) for the full list. diff --git a/docs/contracts/sdk/examples.md b/docs/contracts/sdk/examples.md new file mode 100644 index 0000000..b00d999 --- /dev/null +++ b/docs/contracts/sdk/examples.md @@ -0,0 +1,311 @@ +--- +title: "Examples" +description: "Code samples for viem, ethers.js, and wagmi." +sidebar_position: 3 +displayed_sidebar: contractsSidebar +--- + +# SDK — Examples + +Practical code samples for common operations using `@yellow-org/contracts`. + +## Setup (viem) + +All examples below use this shared setup: + +```ts +import { createPublicClient, createWalletClient, http, parseEther } from "viem"; +import { mainnet } from "viem/chains"; +import { privateKeyToAccount } from "viem/accounts"; +import { + YellowTokenAbi, + NodeRegistryAbi, + AppRegistryAbi, + YellowGovernorAbi, + TreasuryAbi, + FaucetAbi, + addresses, +} from "@yellow-org/contracts"; + +const addr = addresses[1]; // or addresses[11155111] for Sepolia + +const publicClient = createPublicClient({ + chain: mainnet, + transport: http(), +}); + +const walletClient = createWalletClient({ + chain: mainnet, + transport: http(), + account: privateKeyToAccount("0x..."), +}); +``` + +--- + +## Token + +### Check balance and approve + +```ts +const balance = await publicClient.readContract({ + address: addr.yellowToken!, + abi: YellowTokenAbi, + functionName: "balanceOf", + args: [walletClient.account.address], +}); + +// Approve NodeRegistry to spend tokens for collateral deposit +await walletClient.writeContract({ + address: addr.yellowToken!, + abi: YellowTokenAbi, + functionName: "approve", + args: [addr.nodeRegistry!, parseEther("1000")], +}); +``` + +--- + +## Node Operator Collateral (NodeRegistry) + +### Post security deposit + +```ts +// Post YELLOW as a mandatory functional security deposit to operate a clearnode +await walletClient.writeContract({ + address: addr.nodeRegistry!, + abi: NodeRegistryAbi, + functionName: "lock", + args: [walletClient.account.address, parseEther("1000")], +}); +``` + +### Read lock state + +```ts +const state = await publicClient.readContract({ + address: addr.nodeRegistry!, + abi: NodeRegistryAbi, + functionName: "lockStateOf", + args: [userAddress], +}); +// 0 = Idle, 1 = Locked, 2 = Unlocking + +const locked = await publicClient.readContract({ + address: addr.nodeRegistry!, + abi: NodeRegistryAbi, + functionName: "balanceOf", + args: [userAddress], +}); + +const unlockAt = await publicClient.readContract({ + address: addr.nodeRegistry!, + abi: NodeRegistryAbi, + functionName: "unlockTimestampOf", + args: [userAddress], +}); +``` + +### Unlock, relock, withdraw + +```ts +// Start unlock countdown +await walletClient.writeContract({ + address: addr.nodeRegistry!, + abi: NodeRegistryAbi, + functionName: "unlock", +}); + +// Cancel unlock +await walletClient.writeContract({ + address: addr.nodeRegistry!, + abi: NodeRegistryAbi, + functionName: "relock", +}); + +// Withdraw after period elapses +await walletClient.writeContract({ + address: addr.nodeRegistry!, + abi: NodeRegistryAbi, + functionName: "withdraw", + args: [walletClient.account.address], // destination +}); +``` + +### Delegate collateral weight + +```ts +// Delegate collateral weight for protocol parameter administration +await walletClient.writeContract({ + address: addr.nodeRegistry!, + abi: NodeRegistryAbi, + functionName: "delegate", + args: [delegateeAddress], +}); + +// Check collateral weight +const weight = await publicClient.readContract({ + address: addr.nodeRegistry!, + abi: NodeRegistryAbi, + functionName: "getVotes", + args: [userAddress], +}); +``` + +--- + +## Protocol Parameter Administration + +### Create a proposal + +```ts +import { encodeFunctionData, keccak256, toBytes } from "viem"; + +// Example: transfer 1000 YELLOW from Treasury to a grants recipient +const calldata = encodeFunctionData({ + abi: TreasuryAbi, + functionName: "transfer", + args: [addr.yellowToken!, recipientAddress, parseEther("1000")], +}); + +const description = "Transfer 1000 YELLOW to grants recipient"; + +await walletClient.writeContract({ + address: addr.governor!, + abi: YellowGovernorAbi, + functionName: "propose", + args: [ + [addr.treasury!], // targets + [0n], // values + [calldata], // calldatas + description, + ], +}); +``` + +### Signal support on a proposal + +```ts +// support: 0 = Against, 1 = For, 2 = Abstain +await walletClient.writeContract({ + address: addr.governor!, + abi: YellowGovernorAbi, + functionName: "castVote", + args: [proposalId, 1], // For +}); + +// With reason +await walletClient.writeContract({ + address: addr.governor!, + abi: YellowGovernorAbi, + functionName: "castVoteWithReason", + args: [proposalId, 1, "Necessary parameter update for network scaling"], +}); +``` + +### Queue and execute + +```ts +const descriptionHash = keccak256(toBytes(description)); + +// Queue (after operator consensus is reached) +await walletClient.writeContract({ + address: addr.governor!, + abi: YellowGovernorAbi, + functionName: "queue", + args: [[addr.treasury!], [0n], [calldata], descriptionHash], +}); + +// Execute (after timelock delay) +await walletClient.writeContract({ + address: addr.governor!, + abi: YellowGovernorAbi, + functionName: "execute", + args: [[addr.treasury!], [0n], [calldata], descriptionHash], +}); +``` + +### Read proposal state + +```ts +const state = await publicClient.readContract({ + address: addr.governor!, + abi: YellowGovernorAbi, + functionName: "state", + args: [proposalId], +}); +// 0=Pending, 1=Active, 2=Canceled, 3=Defeated, +// 4=Succeeded, 5=Queued, 6=Expired, 7=Executed + +const [againstWeight, forWeight, abstainWeight] = await publicClient.readContract({ + address: addr.governor!, + abi: YellowGovernorAbi, + functionName: "proposalVotes", + args: [proposalId], +}); +``` + +--- + +## Slashing (AppRegistry — adjudicator) + +```ts +// Slash an app builder's service quality guarantee for protocol violation +await walletClient.writeContract({ + address: addr.appRegistry!, + abi: AppRegistryAbi, + functionName: "slash", + args: [ + userAddress, + parseEther("500"), + treasuryAddress, // recipient + "0x1234abcd", // decision reference + ], +}); +``` + +--- + +## Listening to Events + +```ts +// Watch for new collateral deposits on NodeRegistry +publicClient.watchContractEvent({ + address: addr.nodeRegistry!, + abi: NodeRegistryAbi, + eventName: "Locked", + onLogs: (logs) => { + for (const log of logs) { + console.log(`${log.args.user} posted ${log.args.deposited} collateral`); + } + }, +}); + +// Watch for new parameter proposals +publicClient.watchContractEvent({ + address: addr.governor!, + abi: YellowGovernorAbi, + eventName: "ProposalCreated", + onLogs: (logs) => { + for (const log of logs) { + console.log(`Proposal ${log.args.proposalId} by ${log.args.proposer}`); + } + }, +}); +``` + +--- + +## Faucet (Sepolia) + +```ts +import { sepolia } from "viem/chains"; + +const sepoliaAddr = addresses[11155111]; + +await walletClient.writeContract({ + address: sepoliaAddr.faucet!, + abi: FaucetAbi, + functionName: "drip", +}); +``` diff --git a/docs/contracts/sdk/getting-started.md b/docs/contracts/sdk/getting-started.md new file mode 100644 index 0000000..c49e6d1 --- /dev/null +++ b/docs/contracts/sdk/getting-started.md @@ -0,0 +1,92 @@ +--- +title: "Getting Started" +description: "Install, import, and use the contracts SDK." +sidebar_position: 1 +displayed_sidebar: contractsSidebar +--- + +# SDK — Getting Started + +`@yellow-org/contracts` provides typed ABIs and deployed addresses for all Yellow Network contracts. Works with viem, ethers.js, wagmi, or any EVM library. + +## Install + +```bash +# bun +bun add @yellow-org/contracts + +# npm +npm install @yellow-org/contracts + +# yarn +yarn add @yellow-org/contracts + +# pnpm +pnpm add @yellow-org/contracts +``` + +## Quick Start + +### viem + +```ts +import { createPublicClient, http } from "viem"; +import { mainnet } from "viem/chains"; +import { NodeRegistryAbi, addresses } from "@yellow-org/contracts"; + +const client = createPublicClient({ + chain: mainnet, + transport: http(), +}); + +// Read a node operator's locked collateral — fully typed +const balance = await client.readContract({ + address: addresses[1].nodeRegistry!, + abi: NodeRegistryAbi, + functionName: "balanceOf", + args: ["0x..."], +}); +``` + +### ethers v6 + +```ts +import { Contract, JsonRpcProvider } from "ethers"; +import { NodeRegistryAbi, addresses } from "@yellow-org/contracts"; + +const provider = new JsonRpcProvider("https://eth.llamarpc.com"); + +const nodeRegistry = new Contract( + addresses[1].nodeRegistry!, + NodeRegistryAbi, + provider +); + +const balance = await nodeRegistry.balanceOf("0x..."); +``` + +### wagmi (React) + +```ts +import { useReadContract } from "wagmi"; +import { NodeRegistryAbi, addresses } from "@yellow-org/contracts"; + +function LockedCollateral({ user }: { user: `0x${string}` }) { + const { data: balance } = useReadContract({ + address: addresses[1].nodeRegistry!, + abi: NodeRegistryAbi, + functionName: "balanceOf", + args: [user], + }); + + return {balance?.toString()} YELLOW; +} +``` + +## What's Included + +- **9 ABIs** as `as const` TypeScript arrays (full type inference with viem/wagmi) +- **Deployed addresses** keyed by chain ID +- **ESM + CJS** builds with TypeScript declarations + +See [API Reference](./api-reference.md) for the full export list. diff --git a/docs/guides/index.md b/docs/guides/index.md index 38aec89..6b80a03 100644 --- a/docs/guides/index.md +++ b/docs/guides/index.md @@ -10,4 +10,4 @@ displayed_sidebar: guidesSidebar **[Migration Guide](/docs/guides/migration-guide)** - Guide for migrating from previous versions of the Yellow SDK. -**[Multi-Party App Sessions](/docs/guides/multi-party-app-sessions)** - Learn how to create, manage, and close multi-party application sessions using the Yellow Network and Nitrolite protocol. +**[Multi-Party App Sessions](/docs/guides/multi-party-app-sessions)** - Learn how to create, manage, and close multi-party application sessions using the Yellow Network and VirtualApp protocol. diff --git a/docs/guides/migration-guide.md b/docs/guides/migration-guide.md index 8b782c6..f11d61f 100644 --- a/docs/guides/migration-guide.md +++ b/docs/guides/migration-guide.md @@ -1,7 +1,7 @@ --- sidebar_position: 2 title: Migration Guide -description: Guide to migrate to newer versions of Nitrolite +description: Guide to migrate to newer versions of VirtualApp keywords: [migration, upgrade, breaking changes, nitrolite, erc7824] --- @@ -10,7 +10,7 @@ import TabItem from '@theme/TabItem'; # Migration Guide -If you are coming from an earlier version of Nitrolite, you will need to account for the following breaking changes. +If you are coming from an earlier version of VirtualApp, you will need to account for the following breaking changes. ## 0.5.x Breaking changes @@ -70,9 +70,9 @@ The following operations will return errors if the user has any channel with non The returned error has the following format: `operation denied: non-zero allocation in channel(s) detected owned by wallet
"` -### Nitrolite SDK +### VirtualApp SDK -You should definitely read this section if you are using the Nitrolite SDK. +You should definitely read this section if you are using the VirtualApp SDK. #### Update Authentication @@ -227,7 +227,7 @@ for (const channel of channels) { #### Test State Signatures -If you plan to work with on-chain channels opened PRIOR to v0.5.0, then on NitroliteClient initialization the `stateSigner` you specify must be based on a Session Key used in the channel as participant. Even if this session key is or will expire, you still need to provide a `stateSigner` based on it. +If you plan to work with on-chain channels opened PRIOR to v0.5.0, then on VirtualAppClient initialization the `stateSigner` you specify must be based on a Session Key used in the channel as participant. Even if this session key is or will expire, you still need to provide a `stateSigner` based on it. On the other hand, if you plan to work with channels created SINCE v0.5.0, you can specify the `stateSigner` based on the `walletClient` you have specified. @@ -402,13 +402,13 @@ The 0.3.x release includes breaking changes to the SDK architecture, smart contr **Not ready to migrate?** Unfortunately, at this time Yellow Network does not provide ClearNodes running the previous version of the protocol, so you will need to migrate to the latest version to continue using the Network. -### Nitrolite SDK +### VirtualApp SDK -You should definitely read this section if you are using the Nitrolite SDK. +You should definitely read this section if you are using the VirtualApp SDK. #### Client: Replaced `stateWalletClient` with `StateSigner` -The `stateWalletClient` parameter of `NitroliteClient` has been replaced with a required `stateSigner` parameter that implements the `StateSigner` interface. +The `stateWalletClient` parameter of `VirtualAppClient` has been replaced with a required `stateSigner` parameter that implements the `StateSigner` interface. When initializing the client, you should use either `WalletStateSigner` or `SessionKeyStateSigner` to handle state signing. @@ -417,12 +417,12 @@ When initializing the client, you should use either `WalletStateSigner` or `Sess import { createNitroliteClient } from '@erc7824/nitrolite'; // add-start import { - createNitroliteClient, + createVirtualAppClient, WalletStateSigner } from '@erc7824/nitrolite'; // add-end -const client = createNitroliteClient({ +const client = createVirtualAppClient({ publicClient, walletClient, // remove-next-line @@ -487,7 +487,7 @@ You should update your RPC request creation code to use the new structured forma ```typescript // remove-start -const request = NitroliteRPC.createRequest( +const request = VirtualAppRPC.createRequest( requestId, RPCMethod.GetChannels, [participant, status], @@ -495,7 +495,7 @@ const request = NitroliteRPC.createRequest( ); // remove-end // add-start -const request = NitroliteRPC.createRequest({ +const request = VirtualAppRPC.createRequest({ method: RPCMethod.GetChannels, params: { participant, @@ -565,7 +565,7 @@ export interface CloseChannelResponse extends GenericRPCMessage { The `Signature` struct has been replaced with a simple `Hex` type to support EIP-1271 and EIP-6492 signatures. -Update your signature-handling code to use the new `Hex` type. Still, if using Nitrolite utils correctly, you will not need to change anything, as the utils will handle the conversion for you. +Update your signature-handling code to use the new `Hex` type. Still, if using VirtualApp utils correctly, you will not need to change anything, as the utils will handle the conversion for you. ```typescript // remove-start @@ -607,7 +607,7 @@ export interface PaginationFilters { ### Clearnode API -You should read this section only if you are using the ClearNode API directly, or if you are using the Nitrolite SDK with custom ClearNode API requests. +You should read this section only if you are using the ClearNode API directly, or if you are using the VirtualApp SDK with custom ClearNode API requests. #### Actions: Structured Request Parameters @@ -649,7 +649,7 @@ Update all your ClearNode API requests to use object-based parameters instead of A new `create_channel` method has been added to facilitate the improved single-transaction channel opening flow. -Use this method to request channel creation parameters from the broker, then submit the returned data to the smart contract via Nitrolite SDK or directly. +Use this method to request channel creation parameters from the broker, then submit the returned data to the smart contract via VirtualApp SDK or directly. **Request:** ```json @@ -793,7 +793,7 @@ The metadata fields provide: ### Contracts -You should read this section only if you are using the Nitrolite smart contracts directly. +You should read this section only if you are using the VirtualApp smart contracts directly. #### Action: Replaced `Signature` Struct with `bytes` diff --git a/docs/guides/multi-party-app-sessions.mdx b/docs/guides/multi-party-app-sessions.mdx index 57d19fa..c5ab11e 100644 --- a/docs/guides/multi-party-app-sessions.mdx +++ b/docs/guides/multi-party-app-sessions.mdx @@ -1,7 +1,7 @@ --- sidebar_position: 3 title: Multi-Party Application Sessions -description: Learn how to create, manage, and close multi-party application sessions using the Yellow Network and Nitrolite protocol +description: Learn how to create, manage, and close multi-party application sessions using the Yellow Network and VirtualApp protocol keywords: [app sessions, multi-party, state channels, quorum, voting, signatures, allocations] --- @@ -12,9 +12,9 @@ import TabItem from '@theme/TabItem'; ## Overview -Application sessions in Nitrolite enable multiple participants to interact within a shared off-chain state channel. This is particularly powerful for use cases requiring coordinated actions between parties without on-chain overhead. +Application sessions in VirtualApp enable multiple participants to interact within a shared off-chain state channel. This is particularly powerful for use cases requiring coordinated actions between parties without on-chain overhead. -This tutorial demonstrates how to create, manage, and close a multi-party application session using the Yellow Network and Nitrolite protocol. +This tutorial demonstrates how to create, manage, and close a multi-party application session using the Yellow Network and VirtualApp protocol. :::tip Run the Full Example The complete runnable script for this tutorial is available at: @@ -586,6 +586,6 @@ console.log(`Current weight: ${signatureWeight}, Required: ${quorum}`); ## Further Reading - [App Sessions Core Concepts](/docs/learn/core-concepts/app-sessions) — Understanding app sessions -- [App Session Methods](/docs/protocol/off-chain/app-sessions) — Complete API reference +- [App Session Methods](/docs/protocol/app-layer/off-chain/app-sessions) — Complete API reference - [Client-Side App Session Signing Guide](/docs/guides/client-side-app-session-signing) — Signing implementation details - [Session Keys](/docs/learn/core-concepts/session-keys) — Managing session keys diff --git a/docs/learn/advanced/managing-session-keys.mdx b/docs/learn/advanced/managing-session-keys.mdx index ef0f2ad..f1f4c31 100644 --- a/docs/learn/advanced/managing-session-keys.mdx +++ b/docs/learn/advanced/managing-session-keys.mdx @@ -187,7 +187,7 @@ To immediately invalidate a session key, use the `revoke_session_key` method: - Session key does not exist, belongs to another wallet, or is expired: `"operation denied: provided address is not an active session key of this user"` - Non-"clearnode" session key attempting to revoke another session key: `"operation denied: insufficient permissions for the active session key"` -### Nitrolite SDK +### VirtualApp SDK -The Nitrolite SDK provides a higher-level abstraction for managing session keys. For detailed information on using session keys with the Nitrolite SDK, please refer to the SDK documentation. +The VirtualApp SDK provides a higher-level abstraction for managing session keys. For detailed information on using session keys with the VirtualApp SDK, please refer to the SDK documentation. diff --git a/docs/learn/core-concepts/app-sessions.mdx b/docs/learn/core-concepts/app-sessions.mdx index 48092c1..9532ee8 100644 --- a/docs/learn/core-concepts/app-sessions.mdx +++ b/docs/learn/core-concepts/app-sessions.mdx @@ -175,6 +175,6 @@ Always use `NitroRPC/0.4` for new applications. Protocol version is set at creat For complete method specifications and implementation details: -- **[App Session Methods](/docs/protocol/off-chain/app-sessions.mdx)** — Complete method specifications +- **[App Session Methods](/docs/protocol/app-layer/off-chain/app-sessions.mdx)** — Complete method specifications - **[Communication Flows](/docs/protocol/communication-flows.mdx#app-session-lifecycle-flow)** — Sequence diagrams - **[Implementation Checklist](/docs/protocol/implementation-checklist.mdx#state-management)** — Building app session support diff --git a/docs/learn/core-concepts/challenge-response.mdx b/docs/learn/core-concepts/challenge-response.mdx index 44000bf..4729658 100644 --- a/docs/learn/core-concepts/challenge-response.mdx +++ b/docs/learn/core-concepts/challenge-response.mdx @@ -150,6 +150,6 @@ You can **always** recover your funds according to the latest mutually signed st For technical implementation details: -- **[Channel Lifecycle](/docs/protocol/on-chain/channel-lifecycle.mdx)** — Full state machine -- **[Security Considerations](/docs/protocol/on-chain/security.mdx)** — Threat model and best practices +- **[Channel Lifecycle](/docs/protocol/app-layer/on-chain/channel-lifecycle.mdx)** — Full state machine +- **[Security Considerations](/docs/protocol/app-layer/on-chain/security.mdx)** — Threat model and best practices - **[Communication Flows](/docs/protocol/communication-flows.mdx#challenge-response-closure-flow)** — Sequence diagrams diff --git a/docs/learn/core-concepts/message-envelope.mdx b/docs/learn/core-concepts/message-envelope.mdx index c973ce3..cd812ce 100644 --- a/docs/learn/core-concepts/message-envelope.mdx +++ b/docs/learn/core-concepts/message-envelope.mdx @@ -138,6 +138,6 @@ Always use NitroRPC/0.4 for new implementations. For complete technical specifications: -- **[Message Format](/docs/protocol/off-chain/message-format.mdx)** — Full format specification -- **[Off-Chain Overview](/docs/protocol/off-chain/overview.mdx)** — Protocol architecture +- **[Message Format](/docs/protocol/app-layer/off-chain/message-format.mdx)** — Full format specification +- **[Off-Chain Overview](/docs/protocol/app-layer/off-chain/overview.mdx)** — Protocol architecture - **[Implementation Checklist](/docs/protocol/implementation-checklist.mdx#off-chain-rpc)** — Building RPC support diff --git a/docs/learn/core-concepts/session-keys.mdx b/docs/learn/core-concepts/session-keys.mdx index c52b4cd..7a3b861 100644 --- a/docs/learn/core-concepts/session-keys.mdx +++ b/docs/learn/core-concepts/session-keys.mdx @@ -173,5 +173,5 @@ You can skip session keys entirely and sign every request with your main wallet. ## Next Steps - **[Managing Session Keys](../advanced/managing-session-keys.mdx)** — Create, list, and revoke session keys with full API examples -- **[Authentication Flow](/docs/protocol/off-chain/authentication.mdx)** — Full 3-step authentication protocol +- **[Authentication Flow](/docs/protocol/app-layer/off-chain/authentication.mdx)** — Full 3-step authentication protocol - **[Communication Flows](/docs/protocol/communication-flows.mdx#authentication-flow)** — Sequence diagrams for auth diff --git a/docs/learn/core-concepts/state-channels-vs-l1-l2.mdx b/docs/learn/core-concepts/state-channels-vs-l1-l2.mdx index 94ae9cc..84199eb 100644 --- a/docs/learn/core-concepts/state-channels-vs-l1-l2.mdx +++ b/docs/learn/core-concepts/state-channels-vs-l1-l2.mdx @@ -2,7 +2,7 @@ sidebar_position: 1 title: State Channels vs L1/L2 description: Compare state channels with Layer 1 and Layer 2 scaling solutions -keywords: [state channels, L1, L2, scaling, comparison, rollups, Nitrolite] +keywords: [state channels, L1, L2, scaling, comparison, rollups, VirtualApp] --- import Tooltip from '@site/src/components/Tooltip'; @@ -137,5 +137,5 @@ State channels shine when you have identified participants who will interact fre For technical details on channel implementation: - **[Architecture](/docs/protocol/architecture.mdx)** — System design and fund flows -- **[Channel Lifecycle](/docs/protocol/on-chain/channel-lifecycle.mdx)** — State machine and operations -- **[Data Structures](/docs/protocol/on-chain/data-structures.mdx)** — Channel and state formats +- **[Channel Lifecycle](/docs/protocol/app-layer/on-chain/channel-lifecycle.mdx)** — State machine and operations +- **[Data Structures](/docs/protocol/app-layer/on-chain/data-structures.mdx)** — Channel and state formats diff --git a/docs/learn/getting-started/key-terms.mdx b/docs/learn/getting-started/key-terms.mdx index ba5394f..2a8221a 100644 --- a/docs/learn/getting-started/key-terms.mdx +++ b/docs/learn/getting-started/key-terms.mdx @@ -173,9 +173,9 @@ A **session key** is a temporary cryptographic key that: ## Protocol Components -### Nitrolite +### VirtualApp -**Nitrolite** is the on-chain smart contract protocol: +**VirtualApp** is the on-chain smart contract protocol: - Defines channel data structures - Implements create, close, challenge, resize operations diff --git a/docs/learn/getting-started/prerequisites.mdx b/docs/learn/getting-started/prerequisites.mdx index 2056b9b..0462dfd 100644 --- a/docs/learn/getting-started/prerequisites.mdx +++ b/docs/learn/getting-started/prerequisites.mdx @@ -307,7 +307,7 @@ yellow-app/ ├── src/ │ ├── index.ts # Entry point │ ├── config.ts # Configuration -│ ├── client.ts # Nitrolite client setup +│ ├── client.ts # VirtualApp client setup │ ├── auth.ts # Authentication logic │ └── channels/ │ ├── create.ts # Channel creation diff --git a/docs/learn/getting-started/quickstart.mdx b/docs/learn/getting-started/quickstart.mdx index 857b431..debe91d 100644 --- a/docs/learn/getting-started/quickstart.mdx +++ b/docs/learn/getting-started/quickstart.mdx @@ -5,7 +5,7 @@ description: Get up and running with the Yellow Network SDK in minutes. # Quickstart Guide -This guide provides a step-by-step walkthrough of integrating with the Yellow Network using the Nitrolite SDK. We will build a script to connect to the network, authenticate, manage state channels, and transfer funds. +This guide provides a step-by-step walkthrough of integrating with the Yellow Network using the VirtualApp SDK. We will build a script to connect to the network, authenticate, manage state channels, and transfer funds. ## Prerequisites @@ -44,7 +44,7 @@ curl -XPOST https://clearnet-sandbox.yellow.com/faucet/requestTokens \ ## 2. Initialization -First, we setup the `NitroliteClient` with Viem. This client handles all communication with the Yellow Network nodes and smart contracts. +First, we setup the `VirtualAppClient` with Viem. This client handles all communication with the Yellow Network nodes and smart contracts. ```typescript import { NitroliteClient, WalletStateSigner, createECDSAMessageSigner } from '@erc7824/nitrolite'; @@ -59,8 +59,8 @@ const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`); const publicClient = createPublicClient({ chain: sepolia, transport: http(process.env.ALCHEMY_RPC_URL) }); const walletClient = createWalletClient({ chain: sepolia, transport: http(), account }); -// Initialize Nitrolite Client -const client = new NitroliteClient({ +// Initialize VirtualApp Client +const client = new VirtualAppClient({ publicClient, walletClient, stateSigner: new WalletStateSigner(walletClient), @@ -210,7 +210,7 @@ npx tsx close_all.ts ```typescript import { - NitroliteClient, + VirtualAppClient, WalletStateSigner, createTransferMessage, createGetConfigMessage, @@ -299,8 +299,8 @@ async function fetchConfig(): Promise { try { const response = JSON.parse(event.data.toString()); // Response format: [requestId, method, result, timestamp] - // or NitroliteRPCMessage structure depending on implementation - // Based on types: NitroliteRPCMessage { res: RPCData } + // or VirtualAppRPCMessage structure depending on implementation + // Based on types: VirtualAppRPCMessage { res: RPCData } // RPCData: [RequestID, RPCMethod, object, Timestamp?] if (response.res && response.res[2]) { @@ -323,12 +323,12 @@ async function fetchConfig(): Promise { }); } -// Initialize Nitrolite client +// Initialize VirtualApp client console.log('Fetching configuration...'); const config = await fetchConfig(); console.log('Configuration fetched. Assets count:', config.assets?.length); -const client = new NitroliteClient({ +const client = new VirtualAppClient({ publicClient, walletClient, // Use WalletStateSigner for signing states @@ -886,7 +886,7 @@ if (ws.readyState === WebSocket.OPEN) { ```typescript import { - NitroliteClient, + VirtualAppClient, WalletStateSigner, createECDSAMessageSigner, createEIP712AuthMessageSigner, @@ -946,8 +946,8 @@ async function main() { transport: http(RPC_URL), }); - // Initialize Nitrolite Client - const client = new NitroliteClient({ + // Initialize VirtualApp Client + const client = new VirtualAppClient({ publicClient, walletClient, addresses: { diff --git a/docs/learn/index.mdx b/docs/learn/index.mdx index c364416..89cc6d6 100644 --- a/docs/learn/index.mdx +++ b/docs/learn/index.mdx @@ -32,7 +32,7 @@ Get hands-on with Yellow Network in minutes. **[Quickstart: Your First Channel](./getting-started/quickstart.mdx)** — Create a state channel, perform an off-chain transfer, and verify the transaction in under 10 minutes. -**[Prerequisites & Environment](./getting-started/prerequisites.mdx)** — Set up a complete development environment with Node.js, TypeScript, and the Nitrolite SDK. +**[Prerequisites & Environment](./getting-started/prerequisites.mdx)** — Set up a complete development environment with Node.js, TypeScript, and the VirtualApp SDK. **[Key Terms & Mental Models](./getting-started/key-terms.mdx)** — Build your vocabulary and conceptual framework for understanding state channels. diff --git a/docs/learn/introduction/architecture-at-a-glance.mdx b/docs/learn/introduction/architecture-at-a-glance.mdx index 867eb29..df980db 100644 --- a/docs/learn/introduction/architecture-at-a-glance.mdx +++ b/docs/learn/introduction/architecture-at-a-glance.mdx @@ -2,7 +2,7 @@ sidebar_position: 2 title: Architecture at a Glance description: High-level overview of Yellow Network's three-layer architecture -keywords: [architecture, state channels, Nitrolite, Clearnode, smart contracts] +keywords: [architecture, state channels, VirtualApp, Clearnode, smart contracts] --- import Tooltip from '@site/src/components/Tooltip'; @@ -67,7 +67,7 @@ The on-chain layer provides cryptographic guarantees through smart contracts: ### Custody Contract -The **Custody Contract** is the core of Nitrolite's on-chain implementation. It handles: +The **Custody Contract** is the core of VirtualApp's on-chain implementation. It handles: - **Channel Creation**: Lock funds and establish participant relationships - **Dispute Resolution**: Process challenges and validate states @@ -177,7 +177,7 @@ stateDiagram-v2 ``` :::info Legacy Flow -The diagram above shows the recommended flow where both participants sign the initial state, creating the channel directly in ACTIVE status. A legacy flow also exists where only the creator signs initially (status becomes INITIAL), and other participants call `join()` separately. See [Channel Lifecycle](/docs/protocol/on-chain/channel-lifecycle) for details. +The diagram above shows the recommended flow where both participants sign the initial state, creating the channel directly in ACTIVE status. A legacy flow also exists where only the creator signs initially (status becomes INITIAL), and other participants call `join()` separately. See [Channel Lifecycle](/docs/protocol/app-layer/on-chain/channel-lifecycle) for details. ::: ### Typical Flow diff --git a/docs/learn/introduction/what-yellow-solves.mdx b/docs/learn/introduction/what-yellow-solves.mdx index 5d75095..994980d 100644 --- a/docs/learn/introduction/what-yellow-solves.mdx +++ b/docs/learn/introduction/what-yellow-solves.mdx @@ -54,9 +54,9 @@ State channels let you execute unlimited off-chain operations between on-chain c --- -## The Nitrolite Protocol +## The VirtualApp Protocol -Yellow Network is built on **Nitrolite**, a state channel protocol designed for EVM-compatible chains. Nitrolite provides: +Yellow Network is built on **VirtualApp**, a state channel protocol designed for EVM-compatible chains. VirtualApp provides: - **Fund Custody**: Smart contracts that securely lock and release assets - **Dispute Resolution**: Challenge-response mechanism ensuring fair outcomes diff --git a/docs/manuals/request-asset-support.md b/docs/manuals/request-asset-support.md index 6e16e5a..db9c19c 100644 --- a/docs/manuals/request-asset-support.md +++ b/docs/manuals/request-asset-support.md @@ -14,7 +14,7 @@ This guide is primarily for **project teams, token issuers, and integration part Once an asset is supported in Clearnode: - Users can deposit and withdraw the asset through Clearnode's state channels -- The asset becomes available for instant, off-chain transfers via the Nitrolite protocol +- The asset becomes available for instant, off-chain transfers via the VirtualApp protocol - The asset can be used in cross-chain operations (deposit on one chain, withdraw on another) for blockchains it was configured on - Applications built on Yellow Network can integrate the asset for payments and settlements - The asset's unified balance is tracked across all supported blockchains diff --git a/docs/manuals/request-blockchain-support.md b/docs/manuals/request-blockchain-support.md index 5c74cca..065fe16 100644 --- a/docs/manuals/request-blockchain-support.md +++ b/docs/manuals/request-blockchain-support.md @@ -14,7 +14,7 @@ This guide is primarily for **blockchain integrators, infrastructure teams, and Once a blockchain is supported in Clearnode: - Clearnode can establish RPC connections to the specified blockchain network -- The Nitrolite protocol smart contracts (custody, adjudicator, and balance checker) will be monitored on that chain +- The VirtualApp protocol smart contracts (custody, adjudicator, and balance checker) will be monitored on that chain - Users can deposit and withdraw assets on that blockchain through Clearnode - State channels can leverage that blockchain for on-chain settlement when needed - Assets deployed on the supported blockchain become available for cross-chain clearing @@ -107,7 +107,7 @@ You can submit your request with smart contract addresses set to placeholder val ::: :::info Coming Soon: Cross-Chain Contract Deployment Tool -We are developing a tool to simplify the deployment of Nitrolite protocol smart contracts across multiple blockchains with deterministic addresses. This will enable deploying contracts to the same address on different chains, making configuration management significantly easier. +We are developing a tool to simplify the deployment of VirtualApp protocol smart contracts across multiple blockchains with deterministic addresses. This will enable deploying contracts to the same address on different chains, making configuration management significantly easier. ::: Read on to learn how to specify contract addresses in the configuration. diff --git a/docs/manuals/running-clearnode-locally.md b/docs/manuals/running-clearnode-locally.md index 081389b..42912a4 100644 --- a/docs/manuals/running-clearnode-locally.md +++ b/docs/manuals/running-clearnode-locally.md @@ -1,6 +1,6 @@ # Running Clearnode Locally -This manual explains how to run a Clearnode locally using Docker Compose for development and testing purposes. Clearnode is an open-source implementation of a message broker node developed and maintained by Layer3 Fintech Ltd., providing ledger services for the Nitrolite protocol, which enables efficient off-chain payment channels with on-chain settlement capabilities. Independent node operators run this software on their own infrastructure to provide network services. +This manual explains how to run a Clearnode locally using Docker Compose for development and testing purposes. Clearnode is an open-source implementation of a message broker node developed and maintained by Layer3 Fintech Ltd., providing ledger services for the VirtualApp protocol, which enables efficient off-chain payment channels with on-chain settlement capabilities. Independent node operators run this software on their own infrastructure to provide network services. ## Prerequisites @@ -13,7 +13,7 @@ This manual explains how to run a Clearnode locally using Docker Compose for dev ```bash git clone https://github.com/erc7824/nitrolite.git -cd nitrolite/clearnode +cd virtualapp/clearnode ``` ### 2. Configuration Setup diff --git a/docs/protocol/app-layer/_category_.json b/docs/protocol/app-layer/_category_.json new file mode 100644 index 0000000..bcc7d72 --- /dev/null +++ b/docs/protocol/app-layer/_category_.json @@ -0,0 +1,6 @@ +{ + "label": "App Layer (VirtualApp)", + "position": 5, + "collapsible": false, + "collapsed": false +} diff --git a/docs/protocol/off-chain/_category_.json b/docs/protocol/app-layer/off-chain/_category_.json similarity index 83% rename from docs/protocol/off-chain/_category_.json rename to docs/protocol/app-layer/off-chain/_category_.json index aa6318d..a6fb890 100644 --- a/docs/protocol/off-chain/_category_.json +++ b/docs/protocol/app-layer/off-chain/_category_.json @@ -1,6 +1,6 @@ { "label": "Off-Chain RPC Protocol", - "position": 5, + "position": 2, "collapsible": false, "collapsed": false } diff --git a/docs/protocol/off-chain/app-sessions.mdx b/docs/protocol/app-layer/off-chain/app-sessions.mdx similarity index 100% rename from docs/protocol/off-chain/app-sessions.mdx rename to docs/protocol/app-layer/off-chain/app-sessions.mdx diff --git a/docs/protocol/off-chain/authentication.mdx b/docs/protocol/app-layer/off-chain/authentication.mdx similarity index 100% rename from docs/protocol/off-chain/authentication.mdx rename to docs/protocol/app-layer/off-chain/authentication.mdx diff --git a/docs/protocol/off-chain/channel-methods.mdx b/docs/protocol/app-layer/off-chain/channel-methods.mdx similarity index 98% rename from docs/protocol/off-chain/channel-methods.mdx rename to docs/protocol/app-layer/off-chain/channel-methods.mdx index 51fbce0..744730d 100644 --- a/docs/protocol/off-chain/channel-methods.mdx +++ b/docs/protocol/app-layer/off-chain/channel-methods.mdx @@ -14,7 +14,7 @@ Channel management methods enable clients to create, modify, and close payment c ## Overview -Payment channels are the foundation of the Nitrolite protocol. They lock funds on-chain while enabling instant off-chain operations within a unified balance. +Payment channels are the foundation of the VirtualApp protocol. They lock funds on-chain while enabling instant off-chain operations within a unified balance. ### Channel Lifecycle Summary @@ -591,4 +591,4 @@ Explore other off-chain operations: For protocol fundamentals: - **[Authentication](./authentication)** - Understand authorization and session management - **[Message Format](./message-format)** - Learn request/response structure -- **[On-Chain Protocol](/docs/protocol/on-chain/overview)** - Deep dive into smart contracts +- **[On-Chain Protocol](/docs/protocol/app-layer/on-chain/overview)** - Deep dive into smart contracts diff --git a/docs/protocol/off-chain/message-format.mdx b/docs/protocol/app-layer/off-chain/message-format.mdx similarity index 100% rename from docs/protocol/off-chain/message-format.mdx rename to docs/protocol/app-layer/off-chain/message-format.mdx diff --git a/docs/protocol/off-chain/overview.mdx b/docs/protocol/app-layer/off-chain/overview.mdx similarity index 100% rename from docs/protocol/off-chain/overview.mdx rename to docs/protocol/app-layer/off-chain/overview.mdx diff --git a/docs/protocol/off-chain/queries.mdx b/docs/protocol/app-layer/off-chain/queries.mdx similarity index 99% rename from docs/protocol/off-chain/queries.mdx rename to docs/protocol/app-layer/off-chain/queries.mdx index 17be015..18ec0bd 100644 --- a/docs/protocol/off-chain/queries.mdx +++ b/docs/protocol/app-layer/off-chain/queries.mdx @@ -249,7 +249,7 @@ Lists all app sessions | All participant wallet addresses | `["0x742d35Cc...", "0x8B3192f2..."]` | | `weights` | array\ | Voting weights per participant | `[50, 50, 100]` | diff --git a/docs/protocol/off-chain/transfers.mdx b/docs/protocol/app-layer/off-chain/transfers.mdx similarity index 100% rename from docs/protocol/off-chain/transfers.mdx rename to docs/protocol/app-layer/off-chain/transfers.mdx diff --git a/docs/protocol/app-layer/on-chain/_category_.json b/docs/protocol/app-layer/on-chain/_category_.json new file mode 100644 index 0000000..a75feed --- /dev/null +++ b/docs/protocol/app-layer/on-chain/_category_.json @@ -0,0 +1,6 @@ +{ + "label": "On-Chain Contracts", + "position": 1, + "collapsible": false, + "collapsed": false +} diff --git a/docs/protocol/on-chain/channel-lifecycle.mdx b/docs/protocol/app-layer/on-chain/channel-lifecycle.mdx similarity index 99% rename from docs/protocol/on-chain/channel-lifecycle.mdx rename to docs/protocol/app-layer/on-chain/channel-lifecycle.mdx index c28c9f4..e77838d 100644 --- a/docs/protocol/on-chain/channel-lifecycle.mdx +++ b/docs/protocol/app-layer/on-chain/channel-lifecycle.mdx @@ -88,7 +88,7 @@ The first participantNitrolite are stored as raw `bytes` so the protocol can validate multiple scheme formats. +Signatures in VirtualApp are stored as raw `bytes` so the protocol can validate multiple scheme formats. ```solidity struct Signature { @@ -84,7 +84,7 @@ struct Signature { } ``` -At a minimum Nitrolite currently recognizes the following signature families (see the [Signature Formats](./signature-formats) reference for the full specification): +At a minimum VirtualApp currently recognizes the following signature families (see the [Signature Formats](./signature-formats) reference for the full specification): - **Raw/Pre-EIP-191 ECDSA** – Signs `keccak256(packedState)` without any prefix. - **EIP-191 (version `0x45`)** – Signs a structured message that prefixes the packed state with the Ethereum signed message header and length. @@ -143,7 +143,7 @@ The protocol uses EIP-712 structured data signing with the following domain para ```solidity // EIP-712 Domain -name: "Nitrolite:Custody" +name: "VirtualApp:Custody" version: "0.3.0" ``` diff --git a/docs/protocol/on-chain/overview.mdx b/docs/protocol/app-layer/on-chain/overview.mdx similarity index 85% rename from docs/protocol/on-chain/overview.mdx rename to docs/protocol/app-layer/on-chain/overview.mdx index adadc28..f1dd387 100644 --- a/docs/protocol/on-chain/overview.mdx +++ b/docs/protocol/app-layer/on-chain/overview.mdx @@ -8,7 +8,7 @@ import { tooltipDefinitions } from '@site/src/constants/tooltipDefinitions'; # On-Chain Protocol Overview -The on-chain protocol defines the smart contract interfaces and data structures that form the foundation of Nitrolite's security guarantees. This layer operates on the blockchain and handles: +The on-chain protocol defines the smart contract interfaces and data structures that form the foundation of VirtualApp's security guarantees. This layer operates on the blockchain and handles: - **Fund Custody**: Secure locking and unlocking of participant assets - **Dispute Resolution**: Challenge-response mechanism for disagreements @@ -26,7 +26,7 @@ The on-chain layer MUST provide: 5. **Fund safety** guaranteeing users can always recover their assets :::info EVM Compatibility -The initial version of Nitrolite is designed for EVM-compatible blockchains including Ethereum, Polygon, Base, and other EVM chains. Support for additional networks is continuously expanding. +The initial version of VirtualApp is designed for EVM-compatible blockchains including Ethereum, Polygon, Base, and other EVM chains. Support for additional networks is continuously expanding. ::: ## Contract Interfaces diff --git a/docs/protocol/on-chain/security.mdx b/docs/protocol/app-layer/on-chain/security.mdx similarity index 90% rename from docs/protocol/on-chain/security.mdx rename to docs/protocol/app-layer/on-chain/security.mdx index 245f207..1298fc2 100644 --- a/docs/protocol/on-chain/security.mdx +++ b/docs/protocol/app-layer/on-chain/security.mdx @@ -38,7 +38,7 @@ The protocol operates under the following security assumptions: - **Participants have access to the blockchain** to submit challenges within the challenge period :::info Trust Model -Nitrolite is designed as a **trustless protocol** - no single party can steal funds or prevent others from recovering their legitimate share. +VirtualApp is designed as a **trustless protocol** - no single party can steal funds or prevent others from recovering their legitimate share. ::: ### Protected Against @@ -59,7 +59,7 @@ The protocol cannot protect against: - **Denial of service by blockchain congestion** - may affect ability to respond to challenges :::warning Blockchain Dependency -The security of Nitrolite channels depends on the underlying blockchain's liveness and security. Extended blockchain downtime during a challenge period could prevent parties from responding. +The security of VirtualApp channels depends on the underlying blockchain's liveness and security. Extended blockchain downtime during a challenge period could prevent parties from responding. ::: ## Security Properties @@ -106,7 +106,7 @@ State validity is enforced through [supported signatures](./signature-formats), #### EIP-712 Signature Support -Nitrolite supports **EIP-712 (Typed Structured Data)** signatures in addition to raw ECDSA and EIP-191. This provides significant security and user experience advantages: +VirtualApp supports **EIP-712 (Typed Structured Data)** signatures in addition to raw ECDSA and EIP-191. This provides significant security and user experience advantages: **Security Benefits**: - **Domain Separation**: Signatures are bound to a specific contract and chain, preventing replay attacks across different applications or networks @@ -138,7 +138,7 @@ Sign Message: **Implementation Note**: The protocol accepts **all three formats** (raw ECDSA, EIP-191, EIP-712) for maximum compatibility, but EIP-712 is **strongly recommended** for production applications due to its superior security and UX properties. -Supporting EIP-712 signatures also differentiates Nitrolite by keeping state channel operations wallet-friendly and lowering integration friction compared to protocols limited to raw message signing. +Supporting EIP-712 signatures also differentiates VirtualApp by keeping state channel operations wallet-friendly and lowering integration friction compared to protocols limited to raw message signing. ### Liveness @@ -234,7 +234,7 @@ Challenge griefing is economically costly for the attacker (gas fees) while only **Attack**: Observing pending challenge transaction and front-running with a newer state. **Mitigation**: -- **This is actually desired behavior** in Nitrolite +- **This is actually desired behavior** in VirtualApp - The newest state should always win - Front-running helps ensure the most recent state is used - Both parties benefit from accurate state resolution @@ -293,7 +293,7 @@ Before submitting state on-chain: ::: :::caution Before Implementing Your Own Adjudicator -The Adjudicator is an incredibly important part of the Nitrolite protocol. Yellow Network is built on top of a specific adjudicator, which if changed, will render interoperability and security guarantees impossible. Before starting to implement your own Adjudicator, please be sure to advise the Nitrolite developer team, so that your work is not left out. +The Adjudicator is an incredibly important part of the VirtualApp protocol. Yellow Network is built on top of a specific adjudicator, which if changed, will render interoperability and security guarantees impossible. Before starting to implement your own Adjudicator, please be sure to advise the VirtualApp developer team, so that your work is not left out. ::: ## Security Guarantees Summary @@ -307,7 +307,7 @@ The Adjudicator is a | **No Replay** | Old states cannot be reused | Version number validation | :::success Strong Security Model -Nitrolite provides **strong security guarantees** built on top of Layer 1 blockchain security, while enabling Layer 2 scalability and efficiency. +VirtualApp provides **strong security guarantees** built on top of Layer 1 blockchain security, while enabling Layer 2 scalability and efficiency. ::: ## Emergency Procedures diff --git a/docs/protocol/on-chain/signature-formats.mdx b/docs/protocol/app-layer/on-chain/signature-formats.mdx similarity index 81% rename from docs/protocol/on-chain/signature-formats.mdx rename to docs/protocol/app-layer/on-chain/signature-formats.mdx index 9c6af03..69c6a10 100644 --- a/docs/protocol/on-chain/signature-formats.mdx +++ b/docs/protocol/app-layer/on-chain/signature-formats.mdx @@ -8,7 +8,7 @@ import { tooltipDefinitions } from '@site/src/constants/tooltipDefinitions'; # Signature Formats -Nitrolite treats each signature inside `State.sigs` as an opaque `bytes` value. At verification time the Custody contract inspects that payload to detect which validation flow to run. This page captures the current formats the protocol accepts and how they are evaluated. +VirtualApp treats each signature inside `State.sigs` as an opaque `bytes` value. At verification time the Custody contract inspects that payload to detect which validation flow to run. This page captures the current formats the protocol accepts and how they are evaluated. ## Supported Formats @@ -22,7 +22,7 @@ Nitrolite treats each signature inside `State.sigs` as an opaque `bytes` value. - Payload: `keccak256(\"\\x19Ethereum Signed Message:\\n\" + len(packedState) + packedState)`. - Matches the UX most wallets expose when calling `eth_sign`. -- Nitrolite stores the resulting `(v, r, s)` so adjudicators can re-create the prefixed hash for verification. +- VirtualApp stores the resulting `(v, r, s)` so adjudicators can re-create the prefixed hash for verification. ### EIP-712 Typed Data @@ -40,7 +40,7 @@ Nitrolite treats each signature inside `State.sigs` as an opaque `bytes` value. - Wraps an EIP-1271 signature with deployment bytecode and a detection suffix `0x6492649264926492649264926492649264926492649264926492649264926492`. - Allows a not-yet-deployed ERC-4337 smart wallet to attest to a state. -- During verification Nitrolite simulates or deploys the wallet, then forwards the inner signature to the regular EIP-1271 flow. +- During verification VirtualApp simulates or deploys the wallet, then forwards the inner signature to the regular EIP-1271 flow. ## Verification Order diff --git a/docs/protocol/architecture.mdx b/docs/protocol/architecture.mdx index 0fccecc..3588146 100644 --- a/docs/protocol/architecture.mdx +++ b/docs/protocol/architecture.mdx @@ -10,7 +10,56 @@ import { tooltipDefinitions } from '@site/src/constants/tooltipDefinitions'; ## System Overview -The Nitrolite protocol architecture consists of multiple layers working together to enable scalable, secure state channel operations: +Yellow Protocol consists of two distinct layers — the **Decentralized Layer** for network consensus and settlement, and the **App Layer (VirtualApp)** for state channel operations. Together they enable scalable, secure cross-chain clearing and application hosting. + +### Two-Layer Architecture + +```mermaid +%%{init: { "flowchart": { "htmlLabels": true } }}%% +graph TB + subgraph DL["Decentralized Layer"] + direction LR + DHT["Kademlia DHT"] + BLS["BLS Clusters"] + SECURITY["Elastic Security"] + end + + subgraph AL["App Layer — VirtualApp"] + direction LR + RPC["Nitro RPC"] + CHANNELS["State Channels"] + SESSIONS["YApps / App Sessions"] + end + + subgraph OnChain["On-Chain Contracts"] + direction LR + DL_CONTRACTS["Registry, Custody, Governor"] + AL_CONTRACTS["Custody, Adjudicator"] + end + + subgraph Blockchain["Blockchains"] + CHAIN["Ethereum, Arbitrum, Base, Polygon, Linea, BNB"] + end + + DL --> AL + DL_CONTRACTS --> Blockchain + AL_CONTRACTS --> Blockchain + + style DL fill:#e1f5ff,stroke:#9ad7ff,color:#111 + style AL fill:#fff4e1,stroke:#ffd497,color:#111 + style OnChain fill:#ffe1f5,stroke:#ffbde6,color:#111 + style Blockchain fill:#f0f0f0,stroke:#c9c9c9,color:#111 +``` + +:::info Contract Convergence +Both layers currently deploy their own on-chain contracts. These are expected to be merged into a unified contract suite once testnet concludes. +::: + +For the Decentralized Layer architecture (DHT topology, cluster formation, elastic security), see [Decentralized Layer Overview](./decentralized-layer/overview). + +## App Layer Architecture + +The VirtualApp App Layer architecture consists of multiple components working together to enable state channel operations: ```mermaid %%{init: { "flowchart": { "htmlLabels": true } }}%% @@ -149,7 +198,7 @@ graph LR ## Fund Flow -The following diagram illustrates how funds flow through the Nitrolite protocol: +The following diagram illustrates how funds flow through the VirtualApp protocol: ```mermaid graph TB diff --git a/docs/protocol/communication-flows.mdx b/docs/protocol/communication-flows.mdx index f04f836..4cdcaa3 100644 --- a/docs/protocol/communication-flows.mdx +++ b/docs/protocol/communication-flows.mdx @@ -169,7 +169,7 @@ Response: - Challenge-response prevents replay attacks ::: -**Related Methods**: [`auth_request`](../off-chain/authentication#step-1-auth_request), [`auth_challenge`](../off-chain/authentication#step-2-auth_challenge), [`auth_verify`](../off-chain/authentication#step-3-auth_verify) +**Related Methods**: [`auth_request`](./app-layer/off-chain/authentication#step-1-auth_request), [`auth_challenge`](./app-layer/off-chain/authentication#step-2-auth_challenge), [`auth_verify`](./app-layer/off-chain/authentication#step-3-auth_verify) --- @@ -326,7 +326,7 @@ Contract: - This ensures clearnode is ready to join before user risks funds ::: -**Related Methods**: [`create_channel`](../off-chain/channel-methods#create_channel) +**Related Methods**: [`create_channel`](./app-layer/off-chain/channel-methods#create_channel) --- @@ -477,7 +477,7 @@ Response: - **Receiver account auto-created**: Destination tag/address need not have a prior balance ::: -**Related Methods**: [`transfer`](../off-chain/transfers#transfer) +**Related Methods**: [`transfer`](./app-layer/off-chain/transfers#transfer) --- @@ -611,7 +611,7 @@ sequenceDiagram App sessions enable multi-party applications with custom governance rules. Funds are locked from unified balance for the duration of the session. ::: -**Related Methods**: [`create_app_session`](../off-chain/app-sessions#create_app_session), [`submit_app_state`](../off-chain/app-sessions#submit_app_state), [`close_app_session`](../off-chain/app-sessions#close_app_session) +**Related Methods**: [`create_app_session`](./app-layer/off-chain/app-sessions#create_app_session), [`submit_app_state`](./app-layer/off-chain/app-sessions#submit_app_state), [`close_app_session`](./app-layer/off-chain/app-sessions#close_app_session) --- @@ -679,7 +679,7 @@ sequenceDiagram 6. **Blockchain**: verifies both signatures, closes channel, emits `Closed/Opened`-equivalent event (implementation-specific), releases funds. 7. **Clearnode**: observes event, updates DB, sends `cu` (channel update) and `bu` (balance update) notifications. -**Related Methods**: [`close_channel`](../off-chain/channel-methods#close_channel) +**Related Methods**: [`close_channel`](./app-layer/off-chain/channel-methods#close_channel) --- @@ -746,7 +746,7 @@ Now that you understand how all protocol layers work together: 1. **Review Method Details**: Visit Part 2 (Off-Chain RPC Protocol) for complete method specifications 2. **Explore Reference**: See [Protocol Reference](./protocol-reference) for constants and standards 3. **Implementation Guide**: Check [Implementation Checklist](./implementation-checklist) for best practices -4. **Quick Start**: Follow the [Quick Start Guide](./quick-start) to begin building +4. **Quick Start**: Follow the [Quick Start Guide](/docs/build/quick-start) to begin building :::tip Complete Flows These flows represent the most common operations. For edge cases and error handling, consult the specific method documentation in Part 2. diff --git a/docs/protocol/on-chain/_category_.json b/docs/protocol/decentralized-layer/_category_.json similarity index 66% rename from docs/protocol/on-chain/_category_.json rename to docs/protocol/decentralized-layer/_category_.json index ad50188..ce007e9 100644 --- a/docs/protocol/on-chain/_category_.json +++ b/docs/protocol/decentralized-layer/_category_.json @@ -1,5 +1,5 @@ { - "label": "On-Chain Protocol", + "label": "Decentralized Layer", "position": 4, "collapsible": false, "collapsed": false diff --git a/docs/protocol/decentralized-layer/cluster-lifecycle.mdx b/docs/protocol/decentralized-layer/cluster-lifecycle.mdx new file mode 100644 index 0000000..fe8ea59 --- /dev/null +++ b/docs/protocol/decentralized-layer/cluster-lifecycle.mdx @@ -0,0 +1,118 @@ +--- +sidebar_position: 2 +title: "Cluster Lifecycle" +description: "Signing cluster and replication set formation, node join/leave procedures, and time window invariants." +--- + +# Cluster Lifecycle + +Every account in the Yellow Network is managed by two concentric rings of nodes in the DHT: a **Signing Cluster** for fast transaction processing, and a larger **Replication Set** for independent state verification. + +## Cluster Formation + +### Signing Cluster (C_sign) + +The signing cluster for an account is the set of *k* nodes closest to the account's key in XOR space: + +``` +C_sign = FindClosest(AccountID, k) +``` + +These nodes are responsible for: +- Processing transactions (transfers, swaps, withdrawals) +- Producing BLS threshold signatures (quorum: `t = floor(2k/3) + 1`) +- Broadcasting state updates to the replication set + +The value of *k* is **dynamic** — it scales with the value held in the account. See [Elastic Security](./elastic-security.mdx) for the sizing formula. + +### Replication Set (C_watch) + +The replication set is a strictly larger ring of nodes around the same account: + +``` +C_watch = FindClosest(AccountID, r) + where r = max(r_min, k × f_r) +``` + +Since `FindClosest` returns nodes by XOR distance, the signing cluster is always a subset of the replication set — the *k* signing nodes are the innermost *k* of the *r* replication nodes. + +| Parameter | Value | Description | +|-----------|-------|-------------| +| `r_min` | 12 | Minimum replication set size, even for low-value accounts | +| `f_r` | 4 | Default replication factor — a `k=5` signing cluster has `r=20` watchers | +| max | 256 | Both *k* and *r* are bounded by 256 NodeIDs | + +### State Replication Protocol + +After every epoch, the signing cluster broadcasts state updates to the full replication set: + +1. **Broadcast** — `C_sign` sends the set of Certificates produced during the epoch and the resulting state changes to all `C_watch` nodes. +2. **Verify** — Each watcher verifies every Certificate's BLS threshold signature against the Registry's public keys. This is read-only — the watcher confirms signatures are valid and state changes are consistent. +3. **Apply** — If verification passes, the watcher applies the state changes to its local replica. +4. **Divergence** — If a Certificate's signature is invalid or state changes are inconsistent, the watcher flags a protocol violation. + +`C_watch` nodes do not participate in the signing hot path. Their replicated state trails `C_sign` by at most one epoch — acceptable because the replication set is only activated during the [withdrawal challenge window](./protocol-lifecycle.mdx#phase-iii-withdrawal-ynp--l1). + +## Time Windows + +Node lifecycle is governed by four protocol time windows that ensure temporal consistency for cluster membership and certificate verification. + +| Window | Duration | Purpose | +|--------|----------|---------| +| `CERT_LIFETIME` | 25 minutes | Maximum validity of any certificate. A certificate not consumed within this period MUST be discarded. Enforced on-chain for both `startWithdrawal` and `disputeWithdrawal`. | +| `WARMUP_WINDOW` | 1 hour | After registration, a node syncs state from existing cluster members before becoming eligible to sign or watch. | +| `COOLDOWN_WINDOW` | 1 hour | After unregistration, a node stops signing new certificates. Any certificate signed before departure expires within this window. | +| `EVICTION_WINDOW` | 7 days | After cooldown, the node remains in the Kademlia tree solely for on-chain verification consistency. Once elapsed, the node may be removed. | + +### Critical Invariant + +The time windows are designed to satisfy a strict ordering: + +``` +SubmissionRounds < CERT_LIFETIME < COOLDOWN < COOLDOWN + EVICTION + 24 min < 25 min < 1 hour < 7 days + 1 hour +``` + +Each inequality serves a security purpose: + +1. **24 min < 25 min** — All round-robin submission attempts complete before the certificate expires. +2. **25 min < 1 hour** — Any certificate produced by a departing node expires before its cooldown completes. The node remains in `FindClosest` results for the entire validity period of every certificate it signed. +3. **1 hour < 7 days + 1 hour** — The node stays in the Kademlia tree long enough for any pending on-chain challenge period to elapse with stable cluster membership. + +## Node Join (Registration) + +On registration, a node is inserted into the Kademlia tree but enters a **warmup period**: + +1. The node syncs state from `floor(2k/3) + 1` existing cluster members via a Merkle-verified state snapshot covering all account ledger codes. +2. The node MUST NOT participate in signing ceremonies during warmup. +3. The node MAY appear in `FindClosest` results, but its bitmask bit MUST be `0` (unsigned). +4. **Dual enforcement** — On-chain, `aggregateSignerPubkeys` rejects any signer where `block.timestamp < registeredAt + WARMUP_WINDOW`. + +## Node Leave (Graceful Departure) + +On unregistration, a node MUST NOT sign any new certificates. However: + +1. The node **remains in the Kademlia tree** — it is NOT removed from `FindClosest` results. +2. Any certificate the node previously signed remains verifiable on-chain against the same cluster membership until it expires. +3. After both the cooldown and eviction windows have elapsed, any party MAY trigger removal of the node from the tree. +4. Collateral remains in the Custody contract and must be reclaimed via the standard [Escrow Certificate withdrawal flow](./protocol-lifecycle.mdx#phase-iii-withdrawal-ynp--l1). + +### Signing Cutoff Rule + +The protocol MUST NOT include a node in new signing ceremonies if the remaining time before its cooldown ends is less than `CERT_LIFETIME`. This guarantees that any newly signed certificate will expire before the node's cooldown completes. + +## Crash and Timeout + +- If a node misses heartbeats for **3 consecutive epochs**, it is temporarily disabled (bitmask bit set to `0`). +- If the node remains offline for **30 epochs**, the cluster replaces it with the nearest available NodeID. + +## Fee Distribution + +`C_watch` nodes outside `C_sign` are incentivized through fee sharing: + +| Recipient | Share | Description | +|-----------|-------|-------------| +| `C_sign` validators | 80% | Distributed equally among the *k* signing validators | +| `C_watch \ C_sign` validators | 20% | Distributed equally among the *r - k* replication-only validators | + +On a successful dispute, **25%** of total slashed collateral is distributed equally among all `C_watch` validators whose bit is set in the Dispute Certificate's bitmask. The remaining **75%** is allocated to the protocol treasury. diff --git a/docs/protocol/decentralized-layer/elastic-security.mdx b/docs/protocol/decentralized-layer/elastic-security.mdx new file mode 100644 index 0000000..2ad3c1f --- /dev/null +++ b/docs/protocol/decentralized-layer/elastic-security.mdx @@ -0,0 +1,131 @@ +--- +sidebar_position: 3 +title: "Elastic Security" +description: "Dynamic Quorum Extension, value-at-risk calculation, collateral mechanics, and the security ceiling for high-value accounts." +--- + +# Elastic Security + +Traditional blockchains enforce a uniform security model — a $5 transaction pays for the same level of security as a $5 billion transaction. YNP addresses this with **Value-Proportional Security**: the cluster size protecting an account scales with the economic value it holds. + +## Value-at-Risk Calculation + +Every account has a Total Value (`V_A`) denominated in YELLOW: + +``` +V_A = sum(Balance_i × Price_i) for each asset i +``` + +- **Prices** are derived internally from the [Native Liquidity Pools](./liquidity-layer.mdx) using the manipulation-resistant `P_EMA` (exponential moving average), not spot prices. +- **Recalculation** occurs at the start of every transaction or epoch. + +## Dynamic Quorum Extension (DQE) + +The required signing cluster size *k* for an account is computed dynamically: + +``` +k_required = min(256, max(k_min, (V_A × SafetyMultiplier) / AvgCollateral)) +``` + +| Parameter | Value | Description | +|-----------|-------|-------------| +| `k_min` | 3 | Minimum viable BLS threshold cluster (2-of-3 quorum) | +| `SafetyMultiplier` | 1.2 | Cost-of-corruption must be 1.2x the value-at-risk | +| `AvgCollateral` | dynamic | Network-wide rolling average of all registered NodeID collaterals, recalculated every epoch from Registry contract events | + +### Dual-Layer Sizing + +The DQE formula sizes two parameters independently: + +- **k** is sized for **performance** — consensus latency scales with cluster size. +- **r** (replication set) is sized for **security** — corruption cost scales with the number of independent verifiers. + +The constraint the protocol enforces is: + +``` +CostOfCorruption(r) > V_A +``` + +where the cost of corruption is measured against the **replication set**, not the signing cluster. A successful theft requires either bribing `C_sign` without detection (impossible if `C_watch` is honest) or bribing `floor(2r/3) + 1` of `C_watch` to suppress the Dispute Certificate. + +### Truncation + +When the calculated `k_required` exceeds 256, the protocol truncates the signing cluster to the 256 closest NodeIDs by XOR distance. The replication set *r* is truncated independently at `min(256, k × f_r)`. + +## Security Ceiling (Per-Certificate Value Cap) + +When both *k* and *r* reach the 256-node cap, the dual-layer model degenerates: `C_sign = C_watch`, eliminating independent watchers. To restore the security constraint, the protocol enforces a **per-certificate value cap**: + +``` +SecurityCeiling = CostOfCorruption(r_max) / SafetyMultiplier + = (floor(2 × 256 / 3) + 1) × AvgCollateral / 1.2 + = 171 × AvgCollateral / 1.2 +``` + +**Rule**: No single certificate (Credit, Swap, Escrow) SHALL carry a YELLOW-equivalent value exceeding the Security Ceiling. The YELLOW-equivalent value is: + +``` +V_cert = Amount × P_EMA(Asset → YELLOW) +``` + +### When It Binds + +For accounts where `V_A < SecurityCeiling`, the cap does not bind — DQE scales *k* and *r* normally. The ceiling activates only when `V_A` exceeds what the maximum cluster can secure (i.e., when DQE would require `k > 256`). + +### Consequence for Large Accounts + +A user withdrawing or transferring a balance exceeding the Security Ceiling MUST split the operation into multiple certificates, each individually within the cap. Each withdrawal carries its own challenge period; each transfer its own CreditOp. + +### Velocity Constraint + +For any account, the cumulative YELLOW-equivalent value of all certificates produced within a single challenge period MUST NOT exceed the Security Ceiling. This prevents a corrupted cluster from producing multiple certificates in rapid succession to circumvent the per-certificate cap. + +### Enforcement (Defense in Depth) + +The Security Ceiling is enforced at three independent layers: + +1. **Off-chain — Signing ceremony**: `C_sign` nodes MUST refuse to sign any certificate whose `V_cert` exceeds the ceiling. A certificate requires `floor(2k/3) + 1` honest signatures, so a minority of corrupt nodes cannot produce an oversized certificate. + +2. **Cross-cluster — Recipient validation**: `C_Recipient` MUST reject any incoming CreditOp whose `V_cert` exceeds the ceiling, providing independent enforcement even if the sender's cluster is fully compromised. + +3. **On-chain — Custody backstop**: The Custody contract maintains a governance-updatable `maxWithdrawalAmount[asset]` mapping. `startWithdrawal` MUST revert if `amount > maxWithdrawalAmount[asset]`. The per-asset cap is derived from `SecurityCeiling / P_EMA(Asset)` and updated periodically by governance or an automated keeper. + +## Collateral Mechanics + +Collateral is posted in YELLOW tokens to the Registry contract at registration time and mirrored off-chain in `Balances[1040]`. + +### Minimum Collateral (Node Slot Price) + +The minimum collateral per NodeID follows a continuous curve: + +``` +P_n = P_base × (P_target / P_base) ^ (N_t / N_max) +``` + +| Parameter | Value | Description | +|-----------|-------|-------------| +| `P_base` | 10,000 YELLOW | Minimum at genesis | +| `P_target` | 125,000 YELLOW | Minimum at full network capacity | +| `N_t` | dynamic | Current active NodeIDs | +| `N_max` | 65,536 | Maximum NodeIDs | + +As the network grows from genesis to saturation, the required collateral rises from 10,000 to 125,000 YELLOW. + +### Auto-Compounding + +100% of transaction fees and emission incentive distributions are **auto-compounded** into `Balances[1040]`, allowing nodes to organically grow their stake without manual top-ups. This ensures existing nodes keep pace with the rising slot price as the network grows. + +### Excess Withdrawal + +Collateral above `P_n × buffer` MAY be withdrawn to the operator's available balance via the standard [Escrow Certificate flow](./protocol-lifecycle.mdx#phase-iii-withdrawal-ynp--l1). + +### The Escrow Certificate Gate + +All collateral — whether from a voluntary departure or a slashed operator — remains in the Custody contract after eviction. There is no on-chain function that automatically returns or seizes collateral. Instead, the standard Escrow Certificate withdrawal flow is the **single point of control** for all collateral movement: + +- **Honest operator (voluntary departure)**: After cooldown + eviction, the operator requests an Escrow Certificate for their collateral. The network produces it, and the operator withdraws through the standard challenge-period flow. +- **Slashed operator (dispute)**: After a successful dispute, the network marks the corrupt signers as slashed and **refuses to produce an Escrow Certificate** for their collateral. Their stake is effectively forfeit — no on-chain slashing function is needed because the same certificate gate that protects all withdrawals also enforces slashing. + +### Unbonding Period + +Voluntary withdrawal of collateral requires the full cooldown (1 hour) plus eviction window (7 days) to elapse after unregistration. During this entire period the NodeID remains in the Kademlia tree for verification consistency. diff --git a/docs/protocol/decentralized-layer/liquidity-layer.mdx b/docs/protocol/decentralized-layer/liquidity-layer.mdx new file mode 100644 index 0000000..da9c371 --- /dev/null +++ b/docs/protocol/decentralized-layer/liquidity-layer.mdx @@ -0,0 +1,118 @@ +--- +sidebar_position: 5 +title: "Liquidity Layer" +description: "The embedded Dynamic Peg AMM, fee abstraction with deferred settlement, and LP provisioning." +--- + +# Liquidity Layer + +YNP embeds a **Dynamic Peg AMM** directly into the P2P layer. This serves two purposes: providing internal asset pricing for [Elastic Security](./elastic-security.mdx) calculations, and enabling fee abstraction so users can pay fees in any liquid asset. + +## Pool State + +Each pool is stored by the cluster responsible for `Hash(Sort(TokenA, TokenB))`: + +```go +type LiquidityPool struct { + TokenA AssetID + TokenB AssetID + ReserveA uint256 + ReserveB uint256 + PriceScale uint256 // P_scale — price where liquidity is thickest + PriceEMA uint256 // Exponential moving average of spot price + VirtualPrice uint256 // Strictly monotonically increasing LP value metric + LastSwapTime uint64 // Unix timestamp of most recent swap (for EMA decay) + FeeAccA uint256 + FeeAccB uint256 +} +``` + +**Key invariants**: +- `VirtualPrice` MUST be monotonically non-decreasing across all state transitions. Any operation that would decrease it MUST be rejected. +- `PriceScale` is updated only during the epoch cold path, and only when the profit gate is satisfied. +- `PriceEMA` is updated on every swap using a time-weighted exponential decay. + +## Self-Contained Dynamic Peg AMM + +Unlike constant-product AMMs (`x × y = k`), the Dynamic Peg AMM concentrates liquidity around an algorithmically managed price peg (`P_scale`). Trades near `P_scale` experience minimal slippage; trades far from it experience progressively worse execution. + +### Swap Execution (Hot Path) + +Swap execution is an atomic, single-round BLS process within the pool cluster `C_Pool`: + +**1. Reserve update** — The pool applies the swap against the concentrated invariant curve. + +**2. Dynamic fee calculation** — The fee scales with price deviation: + +``` +Fee_dynamic = Fee_mid + (Fee_out - Fee_mid) × f_distance(P_spot, P_scale) +``` + +| Parameter | Value | Description | +|-----------|-------|-------------| +| `Fee_mid` | 0.1% (10 bps) | Base fee when `P_spot ≈ P_scale` | +| `Fee_out` | 0.4% (40 bps) | Maximum fee at extreme deviation | +| `f_distance` | 0 → 1 | Monotonically increasing function of relative deviation | + +The dynamic fee acts as a **thermodynamic brake** — exponentially bleeding attackers of capital before they can meaningfully shift `P_EMA`. + +**3. EMA update** — After every swap: + +``` +P_EMA' = P_EMA × exp(-Δt/τ) + P_spot × (1 - exp(-Δt/τ)) +``` + +where `Δt` is elapsed seconds since `LastSwapTime` and `τ = 600` seconds (10-minute half-life). + +**4. Certify** — `C_Pool` produces a **Swap Certificate** attesting to the execution, dynamic fee, and updated pool state. + +### Profit-Gated Repagging (Cold Path) + +The mechanism to shift `P_scale` toward `P_EMA` runs during the epoch settlement phase, not on the swap hot path: + +1. **Evaluate** — Once per epoch, `C_Pool` checks divergence between `P_scale` and `P_EMA`. +2. **Threshold** — If `|P_EMA - P_scale| / P_scale < ε` (where `ε = 0.1%`), no repagging occurs. +3. **Simulate** — If divergence exceeds `ε`, the cluster simulates shifting `P_scale` toward `P_EMA` by step size `α` (50% of divergence per epoch, capped at 5% absolute move). +4. **Virtual Price gate** — The repag executes **only if** the new `VirtualPrice >= VirtualPrice_current`. If the shift would decrease VirtualPrice (algorithmic loss for LPs), it is rejected. Accumulated dynamic fees subsidize the shift. +5. **Certify** — A Repag Certificate attests to the `P_scale` update. + +## Fee Abstraction and Deferred Settlement + +Users MAY pay fees in any liquid asset. Fees are **accrued in the original asset** during the transfer hot path and **batch-swapped to YELLOW** during the cold path. + +### Hot Path (Inline with Transfer) + +During a transfer (see [Phase II](./protocol-lifecycle.mdx#phase-ii-internal-transfer-lock-and-certify)): + +1. `C_Sender` calculates the dynamic fee in the transaction asset using `P_EMA` and current `f_distance`. +2. The fee is debited from `Balances[1010][Asset]` and credited to `Balances[3010][Asset]`. +3. No swap occurs. The CreditOp Certificate attests to the fee accrual alongside the transfer. + +### Cold Path (Batched, Once Per Epoch) + +Once per epoch, the cluster settles accrued fees: + +1. **Aggregate** — `C_User` aggregates all `Balances[3010]` entries across assets for each user account. +2. **Batch swap** — `C_User` sends a single BatchSwap request to `C_Pool` (e.g., `Swap(USDT → YELLOW)`, `Swap(ETH → YELLOW)`). +3. **Certify** — `C_Pool` executes the swaps and produces one Swap Certificate for the batch. +4. **Distribute** — The resulting YELLOW is auto-compounded into validator collateral (`Balances[1040]`): + - **80%** to `C_sign` validators — distributed equally among the *k* signing validators + - **20%** to `C_watch \ C_sign` validators — distributed equally among the *r - k* replication-only validators + +``` +DR User / 3010 Accrued Fees fee_original + CR Pool / 1030 Pool Reserve fee_original + +DR Pool / 1030 Pool Reserve fee_yellow YELLOW + CR NodeID:S1..Sk / 1040 Collateral fee_yellow × 0.80 YELLOW (C_sign) + CR NodeID:W1..Wr-k / 1040 Collateral fee_yellow × 0.20 YELLOW (C_watch \ C_sign) +``` + +## LP Provisioning + +Liquidity is added and removed via two additional operation types: + +- **AddLiquidityOp** — Debits user `Balances[1010]` for both assets, credits pool `Balances[1030]`, mints LP shares tracked as `AssetID = keccak256("LP", TokenA, TokenB)`. +- **RemoveLiquidityOp** — Burns LP shares, debits pool `Balances[1030]`, credits user `Balances[1010]` with proportional reserves. + +Both operations produce Certificates and follow double-entry accounting. Initial liquidity for core pairs (USDC/YELLOW, ETH/YELLOW) is seeded by the protocol treasury at genesis. diff --git a/docs/protocol/decentralized-layer/overview.mdx b/docs/protocol/decentralized-layer/overview.mdx new file mode 100644 index 0000000..03f4b91 --- /dev/null +++ b/docs/protocol/decentralized-layer/overview.mdx @@ -0,0 +1,110 @@ +--- +sidebar_position: 1 +title: "Network Overview" +description: "Yellow Network Protocol architecture — Kademlia DHT topology, identity, sharding, and how clearnode clusters manage account state." +--- + +import Tooltip from '@site/src/components/Tooltip'; +import { tooltipDefinitions } from '@site/src/constants/tooltipDefinitions'; + +# Network Overview + +The Yellow Network Protocol (YNP) is a decentralized overlay network that sits on top of existing blockchains as a **Layer 3 clearing and settlement layer**. Where the [App Layer](../app-layer/on-chain/overview.mdx) sections describe the VirtualApp state channel primitives ([on-chain](../app-layer/on-chain/overview.mdx) and [off-chain](../app-layer/off-chain/overview.mdx)), this section describes how the network of clearnodes organizes itself to manage accounts, route transactions, and secure assets across multiple chains. + +## Architecture Layers + +YNP introduces three concepts above the VirtualApp channel layer: + +1. **Structured Overlay (Kademlia DHT)** — Nodes form a peer-to-peer network using XOR-distance routing. Every account and pool is assigned to a deterministic set of nodes based on proximity in the key space. +2. **Cluster-Based Consensus** — Instead of global consensus, small groups of nodes (clusters) use BLS threshold signatures to authorize state changes for the accounts they are responsible for. +3. **Elastic Security** — The size of the cluster protecting an account scales dynamically with the value it holds, ensuring the cost to corrupt a cluster always exceeds the potential profit. + +```mermaid +graph TB + subgraph YNP["Yellow Network Protocol (Layer 3)"] + direction TB + DHT["Kademlia DHT
Topology & Routing"] + CLUSTERS["Signing Clusters
BLS Threshold Consensus"] + ELASTIC["Elastic Security
Dynamic Quorum Extension"] + end + + subgraph VirtualApp["VirtualApp (State Channels)"] + direction LR + OFFCHAIN["Off-Chain RPC"] + ONCHAIN["Custody & Adjudicator"] + end + + subgraph L1["Blockchains"] + CHAINS["Ethereum, Arbitrum, Base, Polygon, ..."] + end + + YNP --> VirtualApp + VirtualApp --> L1 + + style YNP fill:#e1f5ff,stroke:#9ad7ff,color:#111 + style VirtualApp fill:#fff4e1,stroke:#ffd497,color:#111 + style L1 fill:#f0f0f0,stroke:#c9c9c9,color:#111 +``` + +## Topology and Routing + +The network forms a structured overlay using the **Kademlia Distributed Hash Table (DHT)**. + +- **Distance metric**: `d(x, y) = x XOR y` — the XOR of two 256-bit keys. +- **Routing**: Each node maintains a k-bucket routing table. Messages are routed to the *k* nodes closest to a target key in logarithmic hops. +- **Deterministic assignment**: For any 256-bit key, the set of responsible nodes is always `FindClosest(key, k)` — the *k* nodes with the smallest XOR distance to that key. + +This means there is no central coordinator. Any node can determine which cluster is responsible for any account by computing XOR distances against the known node set. + +## Identity and Sharding + +### Account Identity + +Every user account is identified by a canonical 32-byte key derived from their wallet address: + +``` +AccountID = keccak256(WalletAddress) +``` + +This `AccountID` is used for DHT lookups, cluster assignment, and on-chain custody operations. + +### Node Identity + +Node operators register on the host L1 chain (Ethereum) via the Registry contract. Each registration produces a **NodeID** — a 256-bit identity incorporating on-chain randomness to prevent address grinding: + +``` +NodeID = keccak256(NetworkID + ChainID + Address + PrevRandao + Timestamp + Salt) +``` + +| Component | Purpose | +|-----------|---------| +| `NetworkID` | 4-byte deployment identifier (Mainnet: `YNET`, Testnet: `YTES`, Devnet: `YDEV`) — prevents cross-network collisions | +| `PrevRandao` | L1 block randomness at registration time — prevents pre-computation of shard-targeting NodeIDs | +| `Timestamp` | Registration block timestamp — additional entropy | +| `Salt` | Operator-chosen nonce — allows multiple NodeIDs per operator | + +### Sharding Model + +The 256-bit key space is implicitly partitioned by XOR proximity. Each node is responsible for accounts whose `AccountID` is close to its `NodeID`. There are no fixed shard boundaries — as nodes join and leave, responsibility shifts smoothly. + +**Network capacity**: The maximum number of NodeIDs is capped at **65,536**. + +A single node operator MAY register multiple NodeIDs (each with its own collateral), allowing them to participate in multiple clusters across the key space. + +## Signing and Verification + +All state changes in YNP are authorized by **BLS threshold signatures**. A cluster of *k* nodes produces a valid signature only when at least `t = floor(2k/3) + 1` members sign. + +This threshold is universal — it applies to all certificate types (Credit, Swap, Escrow, Dispute) without per-operation variance. + +The signed artifacts are called **Certificates** — the protocol's universal primitive for state change. See [Protocol Lifecycle](./protocol-lifecycle.mdx) for the certificate types and their flows. + +## What's Next + +| Topic | Description | +|-------|-------------| +| [Cluster Lifecycle](./cluster-lifecycle.mdx) | How clusters form, how nodes join and leave, and how replication sets provide independent verification | +| [Elastic Security](./elastic-security.mdx) | Value-proportional cluster sizing, collateral mechanics, and the security ceiling | +| [Protocol Lifecycle](./protocol-lifecycle.mdx) | Deposit, transfer, and withdrawal flows — including the Optimistic Escrow mechanism | +| [Liquidity Layer](./liquidity-layer.mdx) | The embedded AMM, fee abstraction, and LP provisioning | +| [Security Analysis](./security.mdx) | Attack vectors and the multi-layer defense model | diff --git a/docs/protocol/decentralized-layer/protocol-lifecycle.mdx b/docs/protocol/decentralized-layer/protocol-lifecycle.mdx new file mode 100644 index 0000000..f32d046 --- /dev/null +++ b/docs/protocol/decentralized-layer/protocol-lifecycle.mdx @@ -0,0 +1,194 @@ +--- +sidebar_position: 4 +title: "Protocol Lifecycle" +description: "Deposit, internal transfer, and withdrawal flows — including Lock-and-Certify transfers and the Optimistic Escrow withdrawal mechanism with dispute resolution." +--- + +# Protocol Lifecycle + +This section describes the three phases of asset movement through the Yellow Network: deposit from L1, internal transfer between accounts, and withdrawal back to L1. Each phase produces **Certificates** — the protocol's universal primitive for cluster-attested state change. + +## Data Structures + +### Account State + +Each account is keyed by `AccountID = keccak256(WalletAddress)`. The responsible cluster is determined by XOR-distance in the DHT. + +```go +type Account struct { + AccountID [32]byte // keccak256(WalletAddress) + Address [20]byte // L1 wallet address + Nonce uint64 + Balances map[Code]map[AssetID]uint256 // Ledger keyed by chart-of-accounts code + LastUpdate uint64 +} +``` + +### Double-Entry Ledger + +Every state mutation follows **double-entry accounting** — total debits must equal total credits. If they don't, the state is corrupt, detectable by any watcher. + +| Code | Account | Normal Balance | Description | +|------|---------|---------------|-------------| +| 1010 | User Balances | Debit | Available balance per user, per asset | +| 1020 | Escrowed Funds | Debit | Pending withdrawal to L1 | +| 1030 | Pool Reserves | Debit | AMM liquidity pool reserves | +| 1040 | Collateral (YELLOW) | Debit | NodeID stake — mirrors on-chain Registry | +| 2010 | L1 Custody Obligation | Credit | Protocol-level liability per asset | +| 2020 | CreditOp Clearing | Credit | In-flight transfer — zeroed when recipient processes CreditOp | +| 3010 | Accrued Fees | Credit | Unswapped fee revenue per user account | + +### Certificate + +The Certificate is the protocol's universal state-change primitive. Every operation produces a Certificate carrying the responsible cluster's BLS threshold attestation. + +```go +type Certificate struct { + Type CertType // Credit | Swap | Escrow | Dispute + Account string // Account whose state is being mutated + Attestation // Embedded BLS threshold proof + Credit *CreditOp // Transfer credit + Swap *SwapOp // Swap execution + Escrow *EscrowOp // Withdrawal escrow + Dispute *DisputeOp // Fraud dispute by C_watch +} + +type Attestation struct { + ThresholdSig []byte // Aggregated BLS signature (G1) + Bitmask uint64 // Which validators signed + Validators [][32]byte // BLS public keys (G2) of signers +} +``` + +The consensus layer operates on Certificates generically — sign, verify, aggregate — without knowledge of the operation type. New operation types can be added by defining a new `CertType` and payload struct. + +## Client Submission + +A user MAY connect to **any node** in the network to submit commands. The entry node is not required to be a member of the user's cluster. + +1. **Authentication** — The entry node issues a random 32-byte nonce challenge. The user signs with their ECDSA key. +2. **Transaction signing** — Every state-changing command includes `ECDSA_Sign(PrivateKey, keccak256(TxID, From, To, Asset, Amount, Nonce))`. +3. **Routing** — The entry node determines the responsible cluster via `FindCluster(keccak256(User.Address), k)` and forwards via P2P. +4. **Response** — The resulting certificate is routed back through the entry node. + +## Phase I: Deposit (L1 → YNP) + +1. User sends asset *X* to the Yellow Custody contract on L1. +2. Custody emits `Deposit(User, Asset, Amount)`. +3. The user's cluster `C_User` monitors L1 events. +4. The cluster waits for chain-specific L1 block confirmations: + - Ethereum Mainnet: **12 blocks** (~3 minutes) + - Chains with instant finality: **1 block** + - Configurable per ChainID in the network manifest via governance +5. After confirmation, `C_User` produces a BLS threshold signature (quorum `t = floor(2k/3) + 1`) to credit the user's off-chain balance: + +``` +Account.Balances[1010][X] += Amount +``` + +## Phase II: Internal Transfer (Lock-and-Certify) + +Cross-shard transfers use a **Lock-and-Certify** pattern with deferred fee settlement. The sender's cluster debits the sender and accrues the fee in the original asset, then emits a CreditOp Certificate — all in a **single BLS signing round**. + +### Step 1: Request and Valuation + +- User signs and submits `Tx(To, Asset, Amount, MaxFee, Nonce, Signature)` to any network node, which routes it to `C_Sender`. +- `C_Sender` verifies the ECDSA signature, then queries `C_Pool` for the fee asset price to determine `V_User` and required *k*. + +### Step 2: Debit and Certify (1 BLS round) + +`C_Sender` verifies balance, nonce, and that the transfer does not exceed the [Security Ceiling](./elastic-security.mdx#security-ceiling-per-certificate-value-cap): + +``` +DR 1010 Sender Balance Amount + Fee + CR 3010 Accrued Fees Fee + CR 2020 CreditOp Clearing Amount +``` + +- `Balances[1010][Asset] -= (Amount + Fee)` +- `Sender.Balances[3010][Asset] += Fee` — the fee accrues in the original asset; no swap yet. +- `C_Sender` produces a **CreditOp Certificate** attesting to the debit, fee accrual, and outbound credit. + +### Step 3: Settlement (Recipient Cluster) + +The CreditOp Certificate is routed to `C_Recipient`: + +1. **Verify** — `C_Recipient` validates the BLS signature against the Registry and checks the Security Ceiling. +2. **Credit** — `Balances[1010][Asset] += Amount`. + +``` +DR 2020 CreditOp Clearing Amount + CR 1010 Recipient Balance Amount +``` + +### Rollback on Failure + +The sender's `Balances[2020]` carries the in-flight amount. If the recipient cluster does not acknowledge the CreditOp within **5 minutes**: + +- The sender's cluster reverses the journal entry — debiting 2020 and crediting back to `Balances[1010]`. +- The accrued fee in `Balances[3010]` is also reversed. +- The nonce is incremented (preventing replay). The user receives an error and may retry. +- **Atomicity**: Either both sides settle or neither does. + +## Phase III: Withdrawal (YNP → L1) + +Withdrawals use the **Optimistic Escrow** mechanism. The signing cluster `C_sign` processes the withdrawal; the replication set `C_watch` independently verifies it and MAY override a fraudulent withdrawal via a Dispute Certificate. + +### Step 1: Escrow (Off-Chain) + +1. `C_sign` verifies balance and that the amount does not exceed the Security Ceiling. +2. `C_sign` moves funds from `Balances[1010]` to `Balances[1020]` (escrowed). +3. `C_sign` generates an **Escrow Certificate** (threshold signature with *k* signers). +4. `C_sign` broadcasts the Escrow Certificate to all `C_watch` nodes. + +### Step 2: Submission (On-Chain) + +A **Designated Submitter** is chosen deterministically: + +``` +Index = uint256(WithdrawalID) % k +``` + +where `WithdrawalID = keccak256(abi.encode(chainid, recipient, asset, amount, nonce, k))`. + +**Fallback**: Round-robin with exponential timeout — primary has 2 minutes, then each subsequent submitter gets 2 minutes, up to 12 rounds (24 minutes total). If no submission after 12 rounds, the escrow expires and funds are auto-released. + +The submitter calls `Custody.startWithdrawal(recipient, asset, amount, nonce, k, signature)`. + +### Step 3: Challenge Period + +The Custody contract starts a timer: +- **Mainnet**: 1 hour (3600 seconds) +- **Testnet**: 5 minutes (300 seconds) + +Every `C_watch` node monitors L1 for `startWithdrawal` events matching accounts in their replication scope. Each watcher compares the on-chain parameters against their local state replica: + +1. Does `Balances[1020][asset]` equal the submitted `amount`? +2. Does the `recipient` match the account's L1 address? +3. Does the `nonce` match the expected sequence? + +**Honest case**: All parameters match — no action needed. The cool-down expires normally. + +**Fraud detection**: If any parameter mismatches, the watchers produce a **Dispute Certificate**: + +1. Any `C_watch` node that detects fraud broadcasts a dispute proposal. +2. `C_watch` runs a BLS signing ceremony with *r* participants and threshold `floor(2r/3) + 1`. +3. The Dispute Certificate carries the **correct** parameters, a **nonce strictly greater** than the original, and `k = r`. +4. Any `C_watch` node submits it via `Custody.disputeWithdrawal()`. + +**On-chain verification**: +- The disputed withdrawal is still pending +- The Dispute Certificate is fresh (`signedAt + CERT_LIFETIME >= block.timestamp`) +- `counterNonce > originalNonce` +- `counterK > originalK` +- BLS threshold signature is valid + +**On successful dispute**: +- The withdrawal is cancelled; funds remain in Custody +- The contract emits `Disputed(WithdrawalID, DisputeID, counterK, originalSigners)` +- Original signers are slashed via the [Escrow Certificate gate](./elastic-security.mdx#the-escrow-certificate-gate) +- 25% of forfeited collateral goes to `C_watch` validators; 75% to the protocol treasury + +### Step 4: Finalization + +If no dispute is submitted during the cool-down, `Custody.finalize()` is called. This is a **permissionless function** — any address may call it. L1 assets are transferred to the user, and `C_sign` burns the escrowed `Balances[1020]`. diff --git a/docs/protocol/decentralized-layer/security.mdx b/docs/protocol/decentralized-layer/security.mdx new file mode 100644 index 0000000..8029932 --- /dev/null +++ b/docs/protocol/decentralized-layer/security.mdx @@ -0,0 +1,97 @@ +--- +sidebar_position: 6 +title: "Security Analysis" +description: "Attack vectors and mitigations — liveness, double spending, Sybil resistance, cluster bribery, and price manipulation defenses." +--- + +# Security Analysis + +This section describes the threat model for the Yellow Network Protocol and the multi-layer defenses against each attack vector. + +## Liveness vs. Safety + +The protocol **favors safety**. If a cluster cannot reach a quorum (e.g., due to a network partition), the account is temporarily frozen. Funds are never lost, only inaccessible until the network heals. + +## Double Spending + +Prevented by **strict nonce ordering** within a shard. A cluster MUST NOT process nonce `N+1` until nonce `N` is finalized. Each user has a single global nonce managed by their home cluster (`C_User`). All state-changing operations originate from the user's cluster, which enforces sequential ordering. + +This prevents double-spend across shards at the cost of serializing a single user's transactions. **Throughput scales with the number of users**, not the number of operations per user. + +## Sybil Attacks + +Mitigated by the **Registry VRF**. The inclusion of `PrevRandao` (L1 block randomness) and `Timestamp` in the [NodeID derivation](./overview.mdx#node-identity) prevents attackers from grinding addresses to target a specific shard. An attacker cannot predict which NodeID they will receive, so they cannot position themselves to surround a target account in XOR space. + +## Signing Cluster Bribery + +An attacker who bribes `floor(2k/3) + 1` members of `C_sign` could produce a fraudulent Escrow Certificate — signing a withdrawal for more than the account holds, or to an attacker-controlled address. The BLS signature would be genuinely valid. + +### Without the Replication Set + +This attack is **undetectable**: the certificate and submitted parameters match, the BLS signature verifies, no challenge is raised, the cool-down expires, and finalization drains the Custody contract. The attacker keeps the stolen funds and recovers their collateral after unbonding. The economic deterrent is illusory because slashing never triggers. + +### With the Replication Set + +The attack **fails**: + +1. `C_watch` nodes hold an independent copy of the account state, verified against prior Certificates. +2. When the fraudulent `startWithdrawal` lands on L1, `C_watch` detects the mismatch against their local state. +3. `C_watch` produces a [Dispute Certificate](./protocol-lifecycle.mdx#step-3-challenge-period) with `k=r` and a higher nonce, overriding the fraudulent withdrawal on-chain. +4. The original signers are slashed: the network refuses to produce Escrow Certificates for their collateral. Their stake is forfeit. + +### Cost of Corruption Comparison + +| Model | Nodes to bribe | Cost | +|-------|---------------|------| +| `C_sign` only | `floor(2k/3) + 1` | `Collateral × (2k/3 + 1)` | +| `C_sign` + `C_watch` | `floor(2r/3) + 1` | `Collateral × (2r/3 + 1)` | + +With `f_r = 4`, a `k=5` account requires bribing **14 of 20** nodes instead of 4 of 5 — a 3.5x increase. As *k* grows with value (DQE), *r* grows proportionally, maintaining the security multiplier. + +### Residual Risk + +If an attacker bribes `floor(2r/3) + 1` of `C_watch`, they can both produce a fraudulent Escrow Certificate (they contain a `C_sign` quorum) and suppress the Dispute Certificate. This is the protocol's **ultimate trust boundary**. The DQE formula ensures `Collateral × floor(2r/3) + 1 > V_A`, making this attack economically irrational. + +## Price Manipulation + +Attackers might try to manipulate the internal AMM price to lower their required *k* or extract LP capital. + +### Three-Layer Defense + +**1. EMA Oracle** — All security-critical pricing MUST use `P_EMA`, not `P_spot`. The exponential moving average (`τ = 600s`) is inherently sluggish — an attacker must sustain a manipulated price for multiple half-lives, requiring capital far exceeding any potential exploit. + +**2. Dynamic Fee Brake** — Fees scale with `|P_spot - P_scale|`. As an attacker pushes spot price away from the peg, fees rise from 10 bps to 40 bps, exponentially draining attacker capital before the EMA can be shifted. + +**3. Profit-Gated Repagging** — Even if an attacker shifts `P_EMA`, the liquidity curve (`P_scale`) only follows if the [Virtual Price gate](./liquidity-layer.mdx#profit-gated-repagging-cold-path) is satisfied. The cluster mathematically refuses to shift liquidity into a position that would decrease `VirtualPrice`, rendering spot-manipulation attacks unprofitable. + +### EMA Parameters + +| Parameter | Value | +|-----------|-------| +| Half-life (`τ`) | 600 seconds (10 minutes) | +| Minimum observations | 20 swap events before `P_EMA` is considered valid | +| Bootstrap | Before `P_EMA` is valid (new pool), spot price is used with `k` floored to `k_min × 2` | + +### Residual Risk + +A well-capitalized attacker who sustains multi-hour manipulation while absorbing escalating dynamic fees could eventually shift `P_EMA` enough to reduce *k*. The profit gate prevents LP capital extraction, but the reduced *k* could lower the cost of a subsequent bribery attack. The [DQE safety multiplier](./elastic-security.mdx#dynamic-quorum-extension-dqe) and the replication set provide defense-in-depth. + +## Temporal Consistency and Certificate Freshness + +The protocol relies on [time windows](./cluster-lifecycle.mdx#time-windows) to guarantee that on-chain signature verification always operates against the same cluster membership that produced the certificate. + +### Attack Vectors Mitigated + +| Attack | Mitigation | +|--------|------------| +| **Stale certificate replay** — resubmitting an old certificate after cluster membership changed | `signedAt + CERT_LIFETIME < block.timestamp` → contract rejects | +| **Node departure exploit** — signing a certificate then immediately unregistering to escape slashing | `CERT_LIFETIME < COOLDOWN` → certificate expires before cooldown ends; node remains slashable | +| **Warmup bypass** — including a new node in signing before it has synced state | Dual enforcement: off-chain via bitmask; on-chain via `aggregateSignerPubkeys` reverting if `block.timestamp < registeredAt + WARMUP_WINDOW` | +| **Dispute certificate hoarding** — pre-signing a dispute and waiting until membership changes | `signedAt + CERT_LIFETIME` check prevents stale submission. Fresh ceremony required. | +| **Challenge period exhaustion** — delaying dispute until challenge nearly expires | `CERT_LIFETIME` (25 min) is independent from `CHALLENGE_PERIOD` (1 hour). Even a late dispute must have a recent `signedAt` — the cluster must have been stable at that moment. | + +### Deployment Constraints + +- `CHALLENGE_PERIOD` MUST allow time for a dispute ceremony (~30 minutes minimum). +- `COOLDOWN_PERIOD` MUST be strictly greater than `CERT_LIFETIME`. The constructor should validate this. +- `EVICTION_WINDOW` MUST be greater than `CHALLENGE_PERIOD` to ensure challenged withdrawals resolve before signers can be evicted. diff --git a/docs/protocol/glossary.mdx b/docs/protocol/glossary.mdx index 6fa4532..063a3d0 100644 --- a/docs/protocol/glossary.mdx +++ b/docs/protocol/glossary.mdx @@ -11,7 +11,7 @@ import { tooltipDefinitions } from '@site/src/constants/tooltipDefinitions'; Complete alphabetical reference of all protocol terms and concepts. :::tip Quick Reference -This glossary provides concise definitions of all Nitrolite protocol terms. For detailed explanations with examples and diagrams, see the respective sections in the documentation. +This glossary provides concise definitions of all VirtualApp protocol terms. For detailed explanations with examples and diagrams, see the respective sections in the documentation. ::: --- @@ -24,7 +24,7 @@ Smart contract that validates state transitions according to application-specifi **Examples**: SimpleConsensus, RemittanceAdjudicator -**Related**: [Data Structures](../protocol/on-chain/data-structures), [Security Considerations](../protocol/on-chain/security) +**Related**: [Data Structures](./app-layer/on-chain/data-structures), [Security Considerations](./app-layer/on-chain/security) --- @@ -41,7 +41,7 @@ Specification of how funds are distributed, containing destination, token, and a } ``` -**Related**: [Data Structures](../protocol/on-chain/data-structures#allocation) +**Related**: [Data Structures](./app-layer/on-chain/data-structures#allocation) --- @@ -55,7 +55,7 @@ Off-chain channels built on top of payment channels, intended to be used by app - Fund locking from unified balance - Application-specific state management -**Related**: [App Sessions Methods](../off-chain/app-sessions), [Communication Flows](./communication-flows#app-session-lifecycle-flow) +**Related**: [App Sessions Methods](./app-layer/off-chain/app-sessions), [Communication Flows](./communication-flows#app-session-lifecycle-flow) --- @@ -70,17 +70,17 @@ Duration (in seconds) that parties have to respond to a dispute. When a app sessions -**Related**: [Architecture](../protocol/architecture), [Off-Chain RPC Protocol](../off-chain/overview) +**Related**: [Architecture](./architecture), [Off-Chain RPC Protocol](./app-layer/off-chain/overview) --- @@ -135,20 +135,20 @@ The participant at index 0 in a ch **Typically**: A user or light client opening a payment channel with a clearnode. -**Related**: [Channel Lifecycle](../protocol/on-chain/channel-lifecycle#creation-phase), [Protocol Reference](./protocol-reference#participant-indices) +**Related**: [Channel Lifecycle](./app-layer/on-chain/channel-lifecycle#creation-phase), [Protocol Reference](./protocol-reference#participant-indices) --- ### Custody Contract -The main on-chain contract implementing channel creation, joining, closure, and resizing. It is an implementation of the Nitrolite protocol. +The main on-chain contract implementing channel creation, joining, closure, and resizing. It is an implementation of the VirtualApp protocol. **Interfaces Implemented**: - `IChannel` - Core channel operations - `IDeposit` - Fund management - `IChannelReader` - State queries -**Related**: [On-Chain Overview](../protocol/on-chain/overview), [Data Structures](../protocol/on-chain/data-structures) +**Related**: [On-Chain Overview](./app-layer/on-chain/overview), [Data Structures](./app-layer/on-chain/data-structures) --- @@ -163,7 +163,7 @@ In NitroRPC/0.4, specifies the type of unified balance - **WITHDRAW**: Remove funds from session to unified balance -**Related**: [App Sessions](../off-chain/app-sessions#submit_app_state) +**Related**: [App Sessions](./app-layer/off-chain/app-sessions#submit_app_state) --- @@ -180,7 +180,7 @@ Double-entry bookkeeping record of a debit or credit. Every financial operation - debit (outgoing) - created_at -**Related**: [Transfers](../off-chain/transfers#off-chain-processing), [Query Methods](../off-chain/queries#get_ledger_entries) +**Related**: [Transfers](./app-layer/off-chain/transfers#off-chain-processing), [Query Methods](./app-layer/off-chain/queries#get_ledger_entries) --- @@ -195,7 +195,7 @@ User-facing transaction record showing transfers, deposits, withdrawals, and app session - `app_withdrawal` - Funds released from app session -**Related**: [Query Methods](../off-chain/queries#get_ledger_transactions) +**Related**: [Query Methods](./app-layer/off-chain/queries#get_ledger_transactions) --- @@ -209,7 +209,7 @@ Constant in `state.data` signaling special states. Magic numbers enable smart co - **CHANOPEN** = 7877 (0x1EC5) - Initial funding state - **CHANCLOSE** = 7879 (0x1EC7) - Final closing state -**Related**: [Protocol Reference](./protocol-reference#magic-numbers), [Data Structures](../protocol/on-chain/data-structures) +**Related**: [Protocol Reference](./protocol-reference#magic-numbers), [Data Structures](./app-layer/on-chain/data-structures) --- @@ -221,7 +221,7 @@ Unique number ensuring channel i **Typical Value**: Timestamp in milliseconds -**Related**: [Data Structures](../protocol/on-chain/data-structures#channel), [Channel Creation](../off-chain/channel-methods#create_channel) +**Related**: [Data Structures](./app-layer/on-chain/data-structures#channel), [Channel Creation](./app-layer/off-chain/channel-methods#create_channel) --- @@ -233,17 +233,17 @@ The off-chain communication protocol for state channel operations. A lightweight - **NitroRPC/0.2**: Legacy (basic state updates) - **NitroRPC/0.4**: Current (intent system) -**Related**: [Off-Chain RPC Protocol](../off-chain/overview), [Message Format](../off-chain/message-format) +**Related**: [Off-Chain RPC Protocol](./app-layer/off-chain/overview), [Message Format](./app-layer/off-chain/message-format) --- -### Nitrolite +### VirtualApp (App Layer / YApps) -The on-chain smart contract protocol for state channels. Defines the structure of channels, states, and the rules for creation, updates, and closure. +The App Layer protocol for state channels and application hosting. Includes on-chain contracts (Custody, Adjudicator) and the off-chain Nitro RPC protocol. Also known as YApps. **Version**: 0.5.0 (Mainnet deployments live; not production yet) -**Related**: [On-Chain Protocol](../protocol/on-chain/overview), [Protocol Reference](./protocol-reference#protocol-versions) +**Related**: [On-Chain Protocol](./app-layer/on-chain/overview), [Protocol Reference](./protocol-reference#protocol-versions) --- @@ -257,7 +257,7 @@ An entity (identified by a w - Index 0: Creator (user) - Index 1: Clearnode -**Related**: [Data Structures](../protocol/on-chain/data-structures#channel), [Protocol Reference](./protocol-reference#participant-indices) +**Related**: [Data Structures](./app-layer/on-chain/data-structures#channel), [Protocol Reference](./protocol-reference#participant-indices) --- @@ -280,7 +280,7 @@ quorum: 80 // - Alice alone (40 < 80) ✗ ``` -**Related**: [App Sessions](../off-chain/app-sessions#create_app_session), [Governance Examples](../off-chain/app-sessions#governance-examples) +**Related**: [App Sessions](./app-layer/off-chain/app-sessions#create_app_session), [Governance Examples](./app-layer/off-chain/app-sessions#governance-examples) --- @@ -292,7 +292,7 @@ A unique identifier for an RPC request, used for correlating requests and respon **Type**: uint64 -**Related**: [Message Format](../off-chain/message-format#general-structure) +**Related**: [Message Format](./app-layer/off-chain/message-format#general-structure) --- @@ -308,7 +308,7 @@ A temporary cryptographic key delegated by a user's main wallet that provides a - Expiration time - Gasless signing (no wallet prompts) -**Related**: [Authentication](../off-chain/authentication), [Communication Flows](./communication-flows#authentication-flow) +**Related**: [Authentication](./app-layer/off-chain/authentication), [Communication Flows](./communication-flows#authentication-flow) --- @@ -323,7 +323,7 @@ A snapshot of the channelquorum for state updates to be valid. -**Related**: [App Sessions](../off-chain/app-sessions#create_app_session) +**Related**: [App Sessions](./app-layer/off-chain/app-sessions#create_app_session) --- @@ -404,10 +404,10 @@ A user's blockchain address (0x-prefixed hex string, 20 bytes) that identifies t For detailed explanations of these terms with examples, diagrams, and use cases, refer to: -- **Core Concepts**: [Terminology](../protocol/terminology) -- **On-Chain Details**: [On-Chain Protocol](../protocol/on-chain/overview) -- **Off-Chain Details**: [Off-Chain RPC Protocol](../off-chain/overview) -- **Implementation**: [Quick Start Guide](./quick-start), [Implementation Checklist](./implementation-checklist) +- **Core Concepts**: [Terminology](./terminology) +- **On-Chain Details**: [On-Chain Protocol](./app-layer/on-chain/overview) +- **Off-Chain Details**: [Off-Chain RPC Protocol](./app-layer/off-chain/overview) +- **Implementation**: [Quick Start Guide](/docs/build/quick-start), [Implementation Checklist](./implementation-checklist) :::tip Using This Glossary Press `Ctrl+F` (or `Cmd+F` on Mac) to search for specific terms. Most terms also appear as tooltips throughout the documentation for quick reference. diff --git a/docs/protocol/implementation-checklist.mdx b/docs/protocol/implementation-checklist.mdx index f51b0dc..c1eda5e 100644 --- a/docs/protocol/implementation-checklist.mdx +++ b/docs/protocol/implementation-checklist.mdx @@ -8,7 +8,7 @@ import { tooltipDefinitions } from '@site/src/constants/tooltipDefinitions'; # Implementation Checklist -Comprehensive checklist for building a compliant Nitrolite client with security best practices. +Comprehensive checklist for building a compliant VirtualApp client with security best practices. :::tip Progressive Implementation You don't need to implement everything at once. Start with Core Protocol and On-Chain Integration, then add Off-Chain RPC and advanced features progressively. @@ -18,19 +18,19 @@ You don't need to implement everything at once. Start with Core Protocol and On- ## Core Protocol Support -Foundation requirements for any Nitrolite implementation. +Foundation requirements for any VirtualApp implementation. ### Identifier Computation - [ ] **Compute channelId from Channel struct** - Hash participants, adjudicator, challenge, nonce using keccak256 - Verify deterministic computation (same inputs = same output) - - Reference: [Data Structures](../protocol/on-chain/data-structures#channel-identifier) + - Reference: [Data Structures](./app-layer/on-chain/data-structures#channel-identifier) - [ ] **Compute payload hash (packedState) from channel state** - Compute `packedState = keccak256(abi.encode(channelId, state.intent, state.version, state.data, state.allocations))` - Ensure proper ABI encoding - - Reference: [Data Structures](../protocol/on-chain/data-structures#packed-state) + - Reference: [Data Structures](./app-layer/on-chain/data-structures#packed-state) ### Signature Handling @@ -78,7 +78,7 @@ Smart contract interactions for ch - Preferred: include both participant signatures to start in `ACTIVE` - Legacy: single sig → `INITIAL`; wait for `join()` to reach `ACTIVE` - Handle ERC-20 approvals only if depositing at creation (legacy flow) - - Reference: [Channel Lifecycle](../protocol/on-chain/channel-lifecycle#creation-phase) + - Reference: [Channel Lifecycle](./app-layer/on-chain/channel-lifecycle#creation-phase) - [ ] **Monitor activation / join** - Subscribe to `Opened` and `Joined` events @@ -88,13 +88,13 @@ Smart contract interactions for ch - Build state with `intent = FINALIZE` (3), `version = current+1`, `data = "0x"` - Require both participant signatures; submit single tx - Confirm funds destination and allocations match expectations - - Reference: [Channel Lifecycle](../protocol/on-chain/channel-lifecycle#cooperative-closure) + - Reference: [Channel Lifecycle](./app-layer/on-chain/channel-lifecycle#cooperative-closure) - [ ] **Dispute / challenge** - Persist latest fully signed state for `challenge()` - During `DISPUTE`, accept newer state via `checkpoint()` (on-chain) if available - After challenge timeout, finalize with `close()` using challenged state - - Reference: [Channel Lifecycle](../protocol/on-chain/channel-lifecycle#challenge-phase) + - Reference: [Channel Lifecycle](./app-layer/on-chain/channel-lifecycle#challenge-phase) ### Event Listening @@ -130,14 +130,14 @@ RPC communication with clearnode - Connect to clearnode RPC endpoint - Handle connection timeouts - Implement exponential backoff for reconnection - - Reference: [Off-Chain Overview](../off-chain/overview) + - Reference: [Off-Chain Overview](./app-layer/off-chain/overview) - [ ] **Implement message format** - Compact JSON array format: `[requestId, method, params, timestamp]` - Request wrapper: `{req: [...], sig: [...]}` - Response wrapper: `{res: [...], sig: [...]}` - Error format: `{res: [requestId, "error", {error: "message"}, timestamp], sig: [...]}` - - Reference: [Message Format](../off-chain/message-format) + - Reference: [Message Format](./app-layer/off-chain/message-format) - [ ] **Handle network outages gracefully** - Detect connection loss @@ -153,7 +153,7 @@ RPC communication with clearnode - Store the exact parameters; response method is `auth_challenge` with `challenge_message` - `auth_verify`: sign EIP-712 Policy typed data with **main wallet** (not session key) including challenge, wallet, session_key, expires_at, scope, allowances; or pass `jwt` to reuse without signature - Response returns `{address, session_key, jwt_token, success}`; use session key for all subsequent private calls - - Reference: [Authentication](../off-chain/authentication) + - Reference: [Authentication](./app-layer/off-chain/authentication) - [ ] **Session key management** - Specify allowances per asset (unrestricted if omitted); enforce spending caps on every debit @@ -172,14 +172,14 @@ RPC communication with clearnode - **Transfers**: transfer - **App Sessions**: create_app_session, submit_app_state, close_app_session - **Queries**: get_config, get_assets, get_app_definition, get_channels, get_app_sessions, get_ledger_balances, get_ledger_entries, get_ledger_transactions, get_rpc_history, get_user_tag, get_session_keys, ping - - Reference: [Queries](../off-chain/queries) + - Reference: [Queries](./app-layer/off-chain/queries) - [ ] **Handle server notifications** - `bu` (Balance Update) - Balance changed - `cu` (Channel Update) - Channel status changed - `tr` (Transfer) - Incoming/outgoing transfer - `asu` (App Session Update) - App session state changed - - Reference: [Notifications](../off-chain/queries#notifications) + - Reference: [Notifications](./app-layer/off-chain/queries#notifications) :::tip Method Prioritization Start with: authentication → create_channel → transfer → get_ledger_balances. Add other methods as needed for your use case. @@ -208,13 +208,13 @@ Off-chain state tracking and synchronization. - Aggregate funds across all chains - Track funds in unified account vs channel escrow vs app session accounts - Update on channel open/close and transfers - - Reference: [Transfers](../off-chain/transfers) + - Reference: [Transfers](./app-layer/off-chain/transfers) - [ ] **Handle app session state updates** - Verify quorum met (sum of weights ≥ quorum) - Track locked funds per session - Release funds on session close - - Reference: [App Sessions](../off-chain/app-sessions) + - Reference: [App Sessions](./app-layer/off-chain/app-sessions) ### State Validation @@ -561,6 +561,6 @@ Use this checklist as a guide throughout your implementation. Check off items as - **Communication Flows**: [Communication Flows](./communication-flows) - **Reference**: [Protocol Reference](./protocol-reference) -- **Channel Lifecycle**: [Channel Lifecycle](../on-chain/channel-lifecycle) -- **RPC Methods**: [Queries](../off-chain/queries) +- **Channel Lifecycle**: [Channel Lifecycle](./app-layer/on-chain/channel-lifecycle) +- **RPC Methods**: [Queries](./app-layer/off-chain/queries) - **Example Code**: [Integration Tests](https://github.com/layer-3/nitrolite/tree/main/integration) diff --git a/docs/protocol/introduction.mdx b/docs/protocol/introduction.mdx index 474d987..55ae822 100644 --- a/docs/protocol/introduction.mdx +++ b/docs/protocol/introduction.mdx @@ -8,45 +8,69 @@ import { tooltipDefinitions } from '@site/src/constants/tooltipDefinitions'; # Introduction -## What is Nitrolite? +## What is Yellow Protocol? -Nitrolite is a state channel protocol that enables off-chain interactions between participants with minimal on-chain operations. The protocol forms a unified virtual ledger (called "clearnet") for applications to escrow funds while being fully abstracted from the underlying blockchain. Nitrolite is developed and maintained by Layer3 Fintech Ltd. and operated by independent node operators running the issuer's open-source clearnode software. +Yellow Protocol is a layered system for decentralized clearing, settlement, and application hosting across multiple blockchains. It is developed and maintained by Layer3 Fintech Ltd. and operated by independent node operators running open-source clearnode software. -The initial version of Nitrolite is EVM-compatible and designed for deployment on Layer 1 and Layer 2 Ethereum networks. +The protocol is composed of two distinct layers: -## Design Goals - -Nitrolite is designed with the following objectives: - -- **Scalability**: Move high-frequency operations off-chain -- **Cost Efficiency**: Minimize gas fees by reducing on-chain transactions -- **Security**: Maintain blockchain-level security guarantees -- **Interoperability**: Support multiple blockchains and assets -- **Developer Experience**: Provide clear, implementable specifications +1. **Decentralized Layer** — A peer-to-peer overlay network (the Yellow Network Protocol, or YNP) that uses a Kademlia DHT, BLS threshold signatures, and elastic security to manage accounts, route transactions, and settle assets across chains. -## Protocol Layers +2. **App Layer (VirtualApp)** — A state channel protocol (also known as YApps) that enables off-chain interactions between participants with minimal on-chain operations. It forms a unified virtual ledger for applications to escrow funds while being fully abstracted from the underlying blockchain. -Nitrolite consists of three interconnected layers: - -1. **On-Chain Layer**: Smart contracts that handle fund custody, dispute resolution, and final settlement -2. **Off-Chain Layer**: RPC protocol for fast, gasless state updates between participants -3. **Application Layer**: Arbitrary application logic built on top of the protocol +:::info On-Chain Contracts +Both layers currently deploy their own on-chain smart contracts. These are expected to be merged into a unified contract suite once testnet concludes. +::: ```mermaid graph TB - A[Application Layer] --> B[Off-Chain RPC Layer] - B --> C[On-Chain Smart Contract Layer] - C --> D[Blockchain] - - style A fill:#e1f5ff - style B fill:#fff4e1 - style C fill:#ffe1f5 - style D fill:#f0f0f0 + subgraph DL["Decentralized Layer"] + direction TB + DHT["Kademlia DHT & Routing"] + CLUSTERS["BLS Threshold Clusters"] + ELASTIC["Elastic Security & Collateral"] + LIQUIDITY["Liquidity Layer & AMM"] + DL_CHAIN["Registry, Custody, Governor"] + end + + subgraph AL["App Layer (VirtualApp)"] + direction TB + OFFCHAIN["Off-Chain Nitro RPC"] + AL_CHAIN["Custody & Adjudicator Contracts"] + APPS["YApps (Chess, DEX, Payments, ...)"] + end + + subgraph L1["Blockchains"] + CHAINS["Ethereum, Arbitrum, Base, Polygon, ..."] + end + + DL --> AL + AL --> L1 + DL_CHAIN -.-> L1 + AL_CHAIN -.-> L1 + + style DL fill:#e1f5ff,stroke:#9ad7ff,color:#111 + style AL fill:#fff4e1,stroke:#ffd497,color:#111 + style L1 fill:#f0f0f0,stroke:#c9c9c9,color:#111 ``` +## Design Goals + +- **Scalability**: Move high-frequency operations off-chain; throughput scales with the number of users +- **Cost Efficiency**: Minimize gas fees by reducing on-chain transactions to deposits, withdrawals, and disputes +- **Security**: Value-proportional security — the cost to corrupt a cluster always exceeds the value it protects +- **Interoperability**: Support multiple blockchains and assets through a unified clearing layer +- **Developer Experience**: Provide clear, implementable specifications for both layers + ## Specification Scope -This document defines the Nitrolite protocol in a **programming language-agnostic manner**. Implementers can use these specifications to build compliant implementations in any language (Go, Python, Rust, JavaScript, etc.). +This documentation defines the Yellow Protocol in a **programming language-agnostic manner**. Implementers can use these specifications to build compliant implementations in any language (Go, Python, Rust, JavaScript, etc.). + +| Section | Layer | Covers | +|---------|-------|--------| +| [Decentralized Layer](./decentralized-layer/overview) | Network | DHT topology, cluster lifecycle, elastic security, protocol lifecycle, liquidity, security analysis | +| [App Layer — On-Chain](./app-layer/on-chain/overview) | VirtualApp | Smart contracts for fund custody, dispute resolution, and settlement | +| [App Layer — Off-Chain](./app-layer/off-chain/overview) | VirtualApp | Nitro RPC protocol for state channel operations, transfers, and app sessions | :::caution Language Independence Implementation-specific details are referenced but not mandated by this specification. The protocol description is abstract and can be implemented in any programming language. @@ -55,4 +79,3 @@ Implementation-specific details are referenced but not mandated by this specific ## RFC 2119 Keywords The keywords "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC 2119. - diff --git a/docs/protocol/protocol-reference.mdx b/docs/protocol/protocol-reference.mdx index c7cb32c..7f02434 100644 --- a/docs/protocol/protocol-reference.mdx +++ b/docs/protocol/protocol-reference.mdx @@ -12,7 +12,7 @@ Quick reference guide for protocol versions, constants, standards, and specifica :::info Quick Navigation Jump to a section: -- [Protocol Versions](#protocol-versions) - Nitrolite & Nitro RPC versions +- [Protocol Versions](#protocol-versions) - VirtualApp & Nitro RPC versions - [State Intent System](#state-intent-system) - Channel state classification - [Participant Indices](#participant-indices) - Creator & Clearnode positions - [Channel Status](#channel-status-state-machine) - Status transitions @@ -25,7 +25,7 @@ Jump to a section: ## Protocol Versions -### Nitrolite Protocol +### VirtualApp Protocol | Property | Value | |----------|-------| @@ -336,7 +336,7 @@ Now that you have the complete protocol reference: 1. **Terminology**: Review [Terminology](./terminology) for all term definitions 2. **Communication Flows**: See [Communication Flows](./communication-flows) for sequence diagrams 3. **Implementation Guide**: Follow [Implementation Checklist](./implementation-checklist) to build compliant clients -4. **Channel Lifecycle**: See [Channel Lifecycle](../on-chain/channel-lifecycle) for detailed state transitions +4. **Channel Lifecycle**: See [Channel Lifecycle](./app-layer/on-chain/channel-lifecycle) for detailed state transitions :::tip Reference Updates This reference reflects protocol version 0.5.0. For the latest updates, check the [Nitrolite repository](https://github.com/layer-3/nitrolite) or use `get_config` to query clearnode capabilities dynamically. diff --git a/docs/protocol/terminology.mdx b/docs/protocol/terminology.mdx index ef87306..c493f02 100644 --- a/docs/protocol/terminology.mdx +++ b/docs/protocol/terminology.mdx @@ -48,15 +48,31 @@ import { tooltipDefinitions } from '@site/src/constants/tooltipDefinitions'; ## On-Chain Contracts -**Custody Contract**: The main on-chain contract implementing the Nitrolite protocol. It provides the functionality to lock and unlock funds; create, close and challenge a channel; track channel state, and coordinate with adjudicators to validate state transitions on state updates. +**Custody Contract**: The main on-chain contract implementing the VirtualApp protocol. It provides the functionality to lock and unlock funds; create, close and challenge a channel; track channel state, and coordinate with adjudicators to validate state transitions on state updates. **Adjudicator**: A smart contract that defines the rules for validating state transitions during all channel lifecycle operations. The adjudicator's `adjudicate(...)` function is called by the Custody contract to verify whether a new state is valid based on previous states and application-specific logic. Examples include SimpleConsensus (requires both signatures) and Remittance (only sender must sign). -## Protocol Components +## Protocol Layers -**Nitrolite**: The on-chain smart contract protocol. +**Decentralized Layer (YNP)**: The peer-to-peer overlay network — Kademlia DHT, BLS threshold clusters, elastic security, and the liquidity layer. Manages account state, cross-shard transfers, and settlement. -**Nitro RPC**: The off-chain communication protocol. +**App Layer (VirtualApp)**: The state channel protocol (also known as YApps) — on-chain custody and adjudicator contracts, plus the off-chain Nitro RPC protocol for fast state updates. + +**Nitro RPC**: The off-chain communication protocol used by the App Layer for channel operations, transfers, and app sessions. + +## Decentralized Layer Terms + +**NodeID**: A 256-bit identity derived from on-chain randomness at registration. Each NodeID requires collateral. + +**Signing Cluster (C_sign)**: The set of *k* nodes closest to an account's key in the DHT, responsible for BLS threshold signing. + +**Replication Set (C_watch)**: A larger ring of *r* nodes that independently verify signing cluster state. Always a superset of the signing cluster. + +**Certificate**: The protocol's universal primitive for state change — a cluster-attested operation carrying a BLS threshold signature. + +**Escrow Certificate**: A certificate authorizing a withdrawal from the network to L1. + +**Dispute Certificate**: A certificate produced by the replication set to override a fraudulent withdrawal. :::tip Quick Reference These terms are used throughout the protocol specification. Bookmark this page for easy reference while reading other sections. diff --git a/docusaurus.config.ts b/docusaurus.config.ts index 4c029e4..510d3aa 100644 --- a/docusaurus.config.ts +++ b/docusaurus.config.ts @@ -131,6 +131,12 @@ const config: Config = { label: 'Protocol', position: 'left', }, + { + type: 'doc', + docId: 'contracts/index', + label: 'Contracts', + position: 'left', + }, { type: 'doc', docId: 'manuals/index', @@ -186,6 +192,10 @@ const config: Config = { label: 'Build', to: '/docs/build/quick-start', }, + { + label: 'Contracts', + to: '/docs/contracts', + }, { label: 'Manuals', to: '/docs/manuals', diff --git a/package-lock.json b/package-lock.json index f163e05..8a5f4c1 100644 --- a/package-lock.json +++ b/package-lock.json @@ -10,8 +10,8 @@ "dependencies": { "@docusaurus/core": "3.9.2", "@docusaurus/preset-classic": "3.9.2", - "@docusaurus/theme-mermaid": "^3.9.2", - "@docusaurus/theme-search-algolia": "^3.9.2", + "@docusaurus/theme-mermaid": "3.9.2", + "@docusaurus/theme-search-algolia": "3.9.2", "@mdx-js/react": "^3.1.1", "@tippyjs/react": "^4.2.6", "clsx": "^2.0.0", @@ -35,86 +35,16 @@ "node": ">=18.0" } }, - "node_modules/@ai-sdk/gateway": { - "version": "2.0.12", - "resolved": "https://registry.npmjs.org/@ai-sdk/gateway/-/gateway-2.0.12.tgz", - "integrity": "sha512-W+cB1sOWvPcz9qiIsNtD+HxUrBUva2vWv2K1EFukuImX+HA0uZx3EyyOjhYQ9gtf/teqEG80M6OvJ7xx/VLV2A==", - "license": "Apache-2.0", - "dependencies": { - "@ai-sdk/provider": "2.0.0", - "@ai-sdk/provider-utils": "3.0.17", - "@vercel/oidc": "3.0.5" - }, - "engines": { - "node": ">=18" - }, - "peerDependencies": { - "zod": "^3.25.76 || ^4.1.8" - } - }, - "node_modules/@ai-sdk/provider": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/@ai-sdk/provider/-/provider-2.0.0.tgz", - "integrity": "sha512-6o7Y2SeO9vFKB8lArHXehNuusnpddKPk7xqL7T2/b+OvXMRIXUO1rR4wcv1hAFUAT9avGZshty3Wlua/XA7TvA==", - "license": "Apache-2.0", - "dependencies": { - "json-schema": "^0.4.0" - }, - "engines": { - "node": ">=18" - } - }, - "node_modules/@ai-sdk/provider-utils": { - "version": "3.0.17", - "resolved": "https://registry.npmjs.org/@ai-sdk/provider-utils/-/provider-utils-3.0.17.tgz", - "integrity": "sha512-TR3Gs4I3Tym4Ll+EPdzRdvo/rc8Js6c4nVhFLuvGLX/Y4V9ZcQMa/HTiYsHEgmYrf1zVi6Q145UEZUfleOwOjw==", - "license": "Apache-2.0", - "dependencies": { - "@ai-sdk/provider": "2.0.0", - "@standard-schema/spec": "^1.0.0", - "eventsource-parser": "^3.0.6" - }, - "engines": { - "node": ">=18" - }, - "peerDependencies": { - "zod": "^3.25.76 || ^4.1.8" - } - }, - "node_modules/@ai-sdk/react": { - "version": "2.0.97", - "resolved": "https://registry.npmjs.org/@ai-sdk/react/-/react-2.0.97.tgz", - "integrity": "sha512-mFfD2OQ+YVwXoCwJUIRdVSQ4XRPxKl/cJwvjKHDGoUlhIoSd58vEjCbj5rlDXGAHcPit6OR0bJT7oINc/mT90w==", - "license": "Apache-2.0", - "dependencies": { - "@ai-sdk/provider-utils": "3.0.17", - "ai": "5.0.97", - "swr": "^2.2.5", - "throttleit": "2.1.0" - }, - "engines": { - "node": ">=18" - }, - "peerDependencies": { - "react": "^18 || ^19 || ^19.0.0-rc", - "zod": "^3.25.76 || ^4.1.8" - }, - "peerDependenciesMeta": { - "zod": { - "optional": true - } - } - }, "node_modules/@algolia/abtesting": { - "version": "1.10.0", - "resolved": "https://registry.npmjs.org/@algolia/abtesting/-/abtesting-1.10.0.tgz", - "integrity": "sha512-mQT3jwuTgX8QMoqbIR7mPlWkqQqBPQaPabQzm37xg2txMlaMogK/4hCiiESGdg39MlHZOVHeV+0VJuE7f5UK8A==", + "version": "1.15.1", + "resolved": "https://registry.npmjs.org/@algolia/abtesting/-/abtesting-1.15.1.tgz", + "integrity": "sha512-2yuIC48rUuHGhU1U5qJ9kJHaxYpJ0jpDHJVI5ekOxSMYXlH4+HP+pA31G820lsAznfmu2nzDV7n5RO44zIY1zw==", "license": "MIT", "dependencies": { - "@algolia/client-common": "5.44.0", - "@algolia/requester-browser-xhr": "5.44.0", - "@algolia/requester-fetch": "5.44.0", - "@algolia/requester-node-http": "5.44.0" + "@algolia/client-common": "5.49.1", + "@algolia/requester-browser-xhr": "5.49.1", + "@algolia/requester-fetch": "5.49.1", + "@algolia/requester-node-http": "5.49.1" }, "engines": { "node": ">= 14.0.0" @@ -153,99 +83,100 @@ } }, "node_modules/@algolia/client-abtesting": { - "version": "5.44.0", - "resolved": "https://registry.npmjs.org/@algolia/client-abtesting/-/client-abtesting-5.44.0.tgz", - "integrity": "sha512-KY5CcrWhRTUo/lV7KcyjrZkPOOF9bjgWpMj9z98VA+sXzVpZtkuskBLCKsWYFp2sbwchZFTd3wJM48H0IGgF7g==", + "version": "5.49.1", + "resolved": "https://registry.npmjs.org/@algolia/client-abtesting/-/client-abtesting-5.49.1.tgz", + "integrity": "sha512-h6M7HzPin+45/l09q0r2dYmocSSt2MMGOOk5c4O5K/bBBlEwf1BKfN6z+iX4b8WXcQQhf7rgQwC52kBZJt/ZZw==", "license": "MIT", "dependencies": { - "@algolia/client-common": "5.44.0", - "@algolia/requester-browser-xhr": "5.44.0", - "@algolia/requester-fetch": "5.44.0", - "@algolia/requester-node-http": "5.44.0" + "@algolia/client-common": "5.49.1", + "@algolia/requester-browser-xhr": "5.49.1", + "@algolia/requester-fetch": "5.49.1", + "@algolia/requester-node-http": "5.49.1" }, "engines": { "node": ">= 14.0.0" } }, "node_modules/@algolia/client-analytics": { - "version": "5.44.0", - "resolved": "https://registry.npmjs.org/@algolia/client-analytics/-/client-analytics-5.44.0.tgz", - "integrity": "sha512-LKOCE8S4ewI9bN3ot9RZoYASPi8b78E918/DVPW3HHjCMUe6i+NjbNG6KotU4RpP6AhRWZjjswbOkWelUO+OoA==", + "version": "5.49.1", + "resolved": "https://registry.npmjs.org/@algolia/client-analytics/-/client-analytics-5.49.1.tgz", + "integrity": "sha512-048T9/Z8OeLmTk8h76QUqaNFp7Rq2VgS2Zm6Y2tNMYGQ1uNuzePY/udB5l5krlXll7ZGflyCjFvRiOtlPZpE9g==", "license": "MIT", "dependencies": { - "@algolia/client-common": "5.44.0", - "@algolia/requester-browser-xhr": "5.44.0", - "@algolia/requester-fetch": "5.44.0", - "@algolia/requester-node-http": "5.44.0" + "@algolia/client-common": "5.49.1", + "@algolia/requester-browser-xhr": "5.49.1", + "@algolia/requester-fetch": "5.49.1", + "@algolia/requester-node-http": "5.49.1" }, "engines": { "node": ">= 14.0.0" } }, "node_modules/@algolia/client-common": { - "version": "5.44.0", - "resolved": "https://registry.npmjs.org/@algolia/client-common/-/client-common-5.44.0.tgz", - "integrity": "sha512-1yyJm4OYC2cztbS28XYVWwLXdwpLsMG4LoZLOltVglQ2+hc/i9q9fUDZyjRa2Bqt4DmkIfezagfMrokhyH4uxQ==", + "version": "5.49.1", + "resolved": "https://registry.npmjs.org/@algolia/client-common/-/client-common-5.49.1.tgz", + "integrity": "sha512-vp5/a9ikqvf3mn9QvHN8PRekn8hW34aV9eX+O0J5mKPZXeA6Pd5OQEh2ZWf7gJY6yyfTlLp5LMFzQUAU+Fpqpg==", "license": "MIT", "engines": { "node": ">= 14.0.0" } }, "node_modules/@algolia/client-insights": { - "version": "5.44.0", - "resolved": "https://registry.npmjs.org/@algolia/client-insights/-/client-insights-5.44.0.tgz", - "integrity": "sha512-wVQWK6jYYsbEOjIMI+e5voLGPUIbXrvDj392IckXaCPvQ6vCMTXakQqOYCd+znQdL76S+3wHDo77HZWiAYKrtA==", + "version": "5.49.1", + "resolved": "https://registry.npmjs.org/@algolia/client-insights/-/client-insights-5.49.1.tgz", + "integrity": "sha512-B6N7PgkvYrul3bntTz/l6uXnhQ2bvP+M7NqTcayh681tSqPaA5cJCUBp/vrP7vpPRpej4Eeyx2qz5p0tE/2N2g==", "license": "MIT", "dependencies": { - "@algolia/client-common": "5.44.0", - "@algolia/requester-browser-xhr": "5.44.0", - "@algolia/requester-fetch": "5.44.0", - "@algolia/requester-node-http": "5.44.0" + "@algolia/client-common": "5.49.1", + "@algolia/requester-browser-xhr": "5.49.1", + "@algolia/requester-fetch": "5.49.1", + "@algolia/requester-node-http": "5.49.1" }, "engines": { "node": ">= 14.0.0" } }, "node_modules/@algolia/client-personalization": { - "version": "5.44.0", - "resolved": "https://registry.npmjs.org/@algolia/client-personalization/-/client-personalization-5.44.0.tgz", - "integrity": "sha512-lkgRjOjOkqmIkebHjHpU9rLJcJNUDMm+eVSW/KJQYLjGqykEZxal+nYJJTBbLceEU2roByP/+27ZmgIwCdf0iA==", + "version": "5.49.1", + "resolved": "https://registry.npmjs.org/@algolia/client-personalization/-/client-personalization-5.49.1.tgz", + "integrity": "sha512-v+4DN+lkYfBd01Hbnb9ZrCHe7l+mvihyx218INRX/kaCXROIWUDIT1cs3urQxfE7kXBFnLsqYeOflQALv/gA5w==", "license": "MIT", "dependencies": { - "@algolia/client-common": "5.44.0", - "@algolia/requester-browser-xhr": "5.44.0", - "@algolia/requester-fetch": "5.44.0", - "@algolia/requester-node-http": "5.44.0" + "@algolia/client-common": "5.49.1", + "@algolia/requester-browser-xhr": "5.49.1", + "@algolia/requester-fetch": "5.49.1", + "@algolia/requester-node-http": "5.49.1" }, "engines": { "node": ">= 14.0.0" } }, "node_modules/@algolia/client-query-suggestions": { - "version": "5.44.0", - "resolved": "https://registry.npmjs.org/@algolia/client-query-suggestions/-/client-query-suggestions-5.44.0.tgz", - "integrity": "sha512-sYfhgwKu6NDVmZHL1WEKVLsOx/jUXCY4BHKLUOcYa8k4COCs6USGgz6IjFkUf+niwq8NCECMmTC4o/fVQOalsA==", + "version": "5.49.1", + "resolved": "https://registry.npmjs.org/@algolia/client-query-suggestions/-/client-query-suggestions-5.49.1.tgz", + "integrity": "sha512-Un11cab6ZCv0W+Jiak8UktGIqoa4+gSNgEZNfG8m8eTsXGqwIEr370H3Rqwj87zeNSlFpH2BslMXJ/cLNS1qtg==", "license": "MIT", "dependencies": { - "@algolia/client-common": "5.44.0", - "@algolia/requester-browser-xhr": "5.44.0", - "@algolia/requester-fetch": "5.44.0", - "@algolia/requester-node-http": "5.44.0" + "@algolia/client-common": "5.49.1", + "@algolia/requester-browser-xhr": "5.49.1", + "@algolia/requester-fetch": "5.49.1", + "@algolia/requester-node-http": "5.49.1" }, "engines": { "node": ">= 14.0.0" } }, "node_modules/@algolia/client-search": { - "version": "5.44.0", - "resolved": "https://registry.npmjs.org/@algolia/client-search/-/client-search-5.44.0.tgz", - "integrity": "sha512-/FRKUM1G4xn3vV8+9xH1WJ9XknU8rkBGlefruq9jDhYUAvYozKimhrmC2pRqw/RyHhPivmgZCRuC8jHP8piz4Q==", + "version": "5.49.1", + "resolved": "https://registry.npmjs.org/@algolia/client-search/-/client-search-5.49.1.tgz", + "integrity": "sha512-Nt9hri7nbOo0RipAsGjIssHkpLMHHN/P7QqENywAq5TLsoYDzUyJGny8FEiD/9KJUxtGH8blGpMedilI6kK3rA==", "license": "MIT", + "peer": true, "dependencies": { - "@algolia/client-common": "5.44.0", - "@algolia/requester-browser-xhr": "5.44.0", - "@algolia/requester-fetch": "5.44.0", - "@algolia/requester-node-http": "5.44.0" + "@algolia/client-common": "5.49.1", + "@algolia/requester-browser-xhr": "5.49.1", + "@algolia/requester-fetch": "5.49.1", + "@algolia/requester-node-http": "5.49.1" }, "engines": { "node": ">= 14.0.0" @@ -258,81 +189,81 @@ "license": "MIT" }, "node_modules/@algolia/ingestion": { - "version": "1.44.0", - "resolved": "https://registry.npmjs.org/@algolia/ingestion/-/ingestion-1.44.0.tgz", - "integrity": "sha512-5+S5ynwMmpTpCLXGjTDpeIa81J+R4BLH0lAojOhmeGSeGEHQTqacl/4sbPyDTcidvnWhaqtyf8m42ue6lvISAw==", + "version": "1.49.1", + "resolved": "https://registry.npmjs.org/@algolia/ingestion/-/ingestion-1.49.1.tgz", + "integrity": "sha512-b5hUXwDqje0Y4CpU6VL481DXgPgxpTD5sYMnfQTHKgUispGnaCLCm2/T9WbJo1YNUbX3iHtYDArp804eD6CmRQ==", "license": "MIT", "dependencies": { - "@algolia/client-common": "5.44.0", - "@algolia/requester-browser-xhr": "5.44.0", - "@algolia/requester-fetch": "5.44.0", - "@algolia/requester-node-http": "5.44.0" + "@algolia/client-common": "5.49.1", + "@algolia/requester-browser-xhr": "5.49.1", + "@algolia/requester-fetch": "5.49.1", + "@algolia/requester-node-http": "5.49.1" }, "engines": { "node": ">= 14.0.0" } }, "node_modules/@algolia/monitoring": { - "version": "1.44.0", - "resolved": "https://registry.npmjs.org/@algolia/monitoring/-/monitoring-1.44.0.tgz", - "integrity": "sha512-xhaTN8pXJjR6zkrecg4Cc9YZaQK2LKm2R+LkbAq+AYGBCWJxtSGlNwftozZzkUyq4AXWoyoc0x2SyBtq5LRtqQ==", + "version": "1.49.1", + "resolved": "https://registry.npmjs.org/@algolia/monitoring/-/monitoring-1.49.1.tgz", + "integrity": "sha512-bvrXwZ0WsL3rN6Q4m4QqxsXFCo6WAew7sAdrpMQMK4Efn4/W920r9ptOuckejOSSvyLr9pAWgC5rsHhR2FYuYw==", "license": "MIT", "dependencies": { - "@algolia/client-common": "5.44.0", - "@algolia/requester-browser-xhr": "5.44.0", - "@algolia/requester-fetch": "5.44.0", - "@algolia/requester-node-http": "5.44.0" + "@algolia/client-common": "5.49.1", + "@algolia/requester-browser-xhr": "5.49.1", + "@algolia/requester-fetch": "5.49.1", + "@algolia/requester-node-http": "5.49.1" }, "engines": { "node": ">= 14.0.0" } }, "node_modules/@algolia/recommend": { - "version": "5.44.0", - "resolved": "https://registry.npmjs.org/@algolia/recommend/-/recommend-5.44.0.tgz", - "integrity": "sha512-GNcite/uOIS7wgRU1MT7SdNIupGSW+vbK9igIzMePvD2Dl8dy0O3urKPKIbTuZQqiVH1Cb84y5cgLvwNrdCj/Q==", + "version": "5.49.1", + "resolved": "https://registry.npmjs.org/@algolia/recommend/-/recommend-5.49.1.tgz", + "integrity": "sha512-h2yz3AGeGkQwNgbLmoe3bxYs8fac4An1CprKTypYyTU/k3Q+9FbIvJ8aS1DoBKaTjSRZVoyQS7SZQio6GaHbZw==", "license": "MIT", "dependencies": { - "@algolia/client-common": "5.44.0", - "@algolia/requester-browser-xhr": "5.44.0", - "@algolia/requester-fetch": "5.44.0", - "@algolia/requester-node-http": "5.44.0" + "@algolia/client-common": "5.49.1", + "@algolia/requester-browser-xhr": "5.49.1", + "@algolia/requester-fetch": "5.49.1", + "@algolia/requester-node-http": "5.49.1" }, "engines": { "node": ">= 14.0.0" } }, "node_modules/@algolia/requester-browser-xhr": { - "version": "5.44.0", - "resolved": "https://registry.npmjs.org/@algolia/requester-browser-xhr/-/requester-browser-xhr-5.44.0.tgz", - "integrity": "sha512-YZHBk72Cd7pcuNHzbhNzF/FbbYszlc7JhZlDyQAchnX5S7tcemSS96F39Sy8t4O4WQLpFvUf1MTNedlitWdOsQ==", + "version": "5.49.1", + "resolved": "https://registry.npmjs.org/@algolia/requester-browser-xhr/-/requester-browser-xhr-5.49.1.tgz", + "integrity": "sha512-2UPyRuUR/qpqSqH8mxFV5uBZWEpxhGPHLlx9Xf6OVxr79XO2ctzZQAhsmTZ6X22x+N8MBWpB9UEky7YU2HGFgA==", "license": "MIT", "dependencies": { - "@algolia/client-common": "5.44.0" + "@algolia/client-common": "5.49.1" }, "engines": { "node": ">= 14.0.0" } }, "node_modules/@algolia/requester-fetch": { - "version": "5.44.0", - "resolved": "https://registry.npmjs.org/@algolia/requester-fetch/-/requester-fetch-5.44.0.tgz", - "integrity": "sha512-B9WHl+wQ7uf46t9cq+vVM/ypVbOeuldVDq9OtKsX2ApL2g/htx6ImB9ugDOOJmB5+fE31/XPTuCcYz/j03+idA==", + "version": "5.49.1", + "resolved": "https://registry.npmjs.org/@algolia/requester-fetch/-/requester-fetch-5.49.1.tgz", + "integrity": "sha512-N+xlE4lN+wpuT+4vhNEwPVlrfN+DWAZmSX9SYhbz986Oq8AMsqdntOqUyiOXVxYsQtfLwmiej24vbvJGYv1Qtw==", "license": "MIT", "dependencies": { - "@algolia/client-common": "5.44.0" + "@algolia/client-common": "5.49.1" }, "engines": { "node": ">= 14.0.0" } }, "node_modules/@algolia/requester-node-http": { - "version": "5.44.0", - "resolved": "https://registry.npmjs.org/@algolia/requester-node-http/-/requester-node-http-5.44.0.tgz", - "integrity": "sha512-MULm0qeAIk4cdzZ/ehJnl1o7uB5NMokg83/3MKhPq0Pk7+I0uELGNbzIfAkvkKKEYcHALemKdArtySF9eKzh/A==", + "version": "5.49.1", + "resolved": "https://registry.npmjs.org/@algolia/requester-node-http/-/requester-node-http-5.49.1.tgz", + "integrity": "sha512-zA5bkUOB5PPtTr182DJmajCiizHp0rCJQ0Chf96zNFvkdESKYlDeYA3tQ7r2oyHbu/8DiohAQ5PZ85edctzbXA==", "license": "MIT", "dependencies": { - "@algolia/client-common": "5.44.0" + "@algolia/client-common": "5.49.1" }, "engines": { "node": ">= 14.0.0" @@ -364,22 +295,13 @@ "url": "https://github.com/sponsors/antfu" } }, - "node_modules/@antfu/utils": { - "version": "8.1.1", - "resolved": "https://registry.npmjs.org/@antfu/utils/-/utils-8.1.1.tgz", - "integrity": "sha512-Mex9nXf9vR6AhcXmMrlz/HVgYYZpVGJ6YlPgwl7UnaFpnshXs6EK/oa5Gpf3CzENMjkvEx2tQtntGnb7UtSTOQ==", - "license": "MIT", - "funding": { - "url": "https://github.com/sponsors/antfu" - } - }, "node_modules/@babel/code-frame": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.27.1.tgz", - "integrity": "sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==", + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.0.tgz", + "integrity": "sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==", "license": "MIT", "dependencies": { - "@babel/helper-validator-identifier": "^7.27.1", + "@babel/helper-validator-identifier": "^7.28.5", "js-tokens": "^4.0.0", "picocolors": "^1.1.1" }, @@ -388,29 +310,30 @@ } }, "node_modules/@babel/compat-data": { - "version": "7.28.5", - "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.28.5.tgz", - "integrity": "sha512-6uFXyCayocRbqhZOB+6XcuZbkMNimwfVGFji8CTZnCzOHVGvDqzvitu1re2AU5LROliz7eQPhB8CpAMvnx9EjA==", + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.0.tgz", + "integrity": "sha512-T1NCJqT/j9+cn8fvkt7jtwbLBfLC/1y1c7NtCeXFRgzGTsafi68MRv8yzkYSapBnFA6L3U2VSc02ciDzoAJhJg==", "license": "MIT", "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/core": { - "version": "7.28.5", - "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.28.5.tgz", - "integrity": "sha512-e7jT4DxYvIDLk1ZHmU/m/mB19rex9sv0c2ftBtjSBv+kVM/902eh0fINUzD7UwLLNR+jU585GxUJ8/EBfAM5fw==", - "license": "MIT", - "dependencies": { - "@babel/code-frame": "^7.27.1", - "@babel/generator": "^7.28.5", - "@babel/helper-compilation-targets": "^7.27.2", - "@babel/helper-module-transforms": "^7.28.3", - "@babel/helpers": "^7.28.4", - "@babel/parser": "^7.28.5", - "@babel/template": "^7.27.2", - "@babel/traverse": "^7.28.5", - "@babel/types": "^7.28.5", + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.0.tgz", + "integrity": "sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==", + "license": "MIT", + "peer": true, + "dependencies": { + "@babel/code-frame": "^7.29.0", + "@babel/generator": "^7.29.0", + "@babel/helper-compilation-targets": "^7.28.6", + "@babel/helper-module-transforms": "^7.28.6", + "@babel/helpers": "^7.28.6", + "@babel/parser": "^7.29.0", + "@babel/template": "^7.28.6", + "@babel/traverse": "^7.29.0", + "@babel/types": "^7.29.0", "@jridgewell/remapping": "^2.3.5", "convert-source-map": "^2.0.0", "debug": "^4.1.0", @@ -436,13 +359,13 @@ } }, "node_modules/@babel/generator": { - "version": "7.28.5", - "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.28.5.tgz", - "integrity": "sha512-3EwLFhZ38J4VyIP6WNtt2kUdW9dokXA9Cr4IVIFHuCpZ3H8/YFOl5JjZHisrn1fATPBmKKqXzDFvh9fUwHz6CQ==", + "version": "7.29.1", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.1.tgz", + "integrity": "sha512-qsaF+9Qcm2Qv8SRIMMscAvG4O3lJ0F1GuMo5HR/Bp02LopNgnZBC/EkbevHFeGs4ls/oPz9v+Bsmzbkbe+0dUw==", "license": "MIT", "dependencies": { - "@babel/parser": "^7.28.5", - "@babel/types": "^7.28.5", + "@babel/parser": "^7.29.0", + "@babel/types": "^7.29.0", "@jridgewell/gen-mapping": "^0.3.12", "@jridgewell/trace-mapping": "^0.3.28", "jsesc": "^3.0.2" @@ -464,12 +387,12 @@ } }, "node_modules/@babel/helper-compilation-targets": { - "version": "7.27.2", - "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.27.2.tgz", - "integrity": "sha512-2+1thGUUWWjLTYTHZWK1n8Yga0ijBz1XAhUXcKy81rd5g6yh7hGqMp45v7cadSbEHc9G3OTv45SyneRN3ps4DQ==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.28.6.tgz", + "integrity": "sha512-JYtls3hqi15fcx5GaSNL7SCTJ2MNmjrkHXg4FSpOA/grxK8KwyZ5bubHsCq8FXCkua6xhuaaBit+3b7+VZRfcA==", "license": "MIT", "dependencies": { - "@babel/compat-data": "^7.27.2", + "@babel/compat-data": "^7.28.6", "@babel/helper-validator-option": "^7.27.1", "browserslist": "^4.24.0", "lru-cache": "^5.1.1", @@ -489,17 +412,17 @@ } }, "node_modules/@babel/helper-create-class-features-plugin": { - "version": "7.28.5", - "resolved": "https://registry.npmjs.org/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.28.5.tgz", - "integrity": "sha512-q3WC4JfdODypvxArsJQROfupPBq9+lMwjKq7C33GhbFYJsufD0yd/ziwD+hJucLeWsnFPWZjsU2DNFqBPE7jwQ==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.28.6.tgz", + "integrity": "sha512-dTOdvsjnG3xNT9Y0AUg1wAl38y+4Rl4sf9caSQZOXdNqVn+H+HbbJ4IyyHaIqNR6SW9oJpA/RuRjsjCw2IdIow==", "license": "MIT", "dependencies": { "@babel/helper-annotate-as-pure": "^7.27.3", "@babel/helper-member-expression-to-functions": "^7.28.5", "@babel/helper-optimise-call-expression": "^7.27.1", - "@babel/helper-replace-supers": "^7.27.1", + "@babel/helper-replace-supers": "^7.28.6", "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1", - "@babel/traverse": "^7.28.5", + "@babel/traverse": "^7.28.6", "semver": "^6.3.1" }, "engines": { @@ -545,16 +468,16 @@ } }, "node_modules/@babel/helper-define-polyfill-provider": { - "version": "0.6.5", - "resolved": "https://registry.npmjs.org/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.6.5.tgz", - "integrity": "sha512-uJnGFcPsWQK8fvjgGP5LZUZZsYGIoPeRjSF5PGwrelYgq7Q15/Ft9NGFp1zglwgIv//W0uG4BevRuSJRyylZPg==", + "version": "0.6.6", + "resolved": "https://registry.npmjs.org/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.6.6.tgz", + "integrity": "sha512-mOAsxeeKkUKayvZR3HeTYD/fICpCPLJrU5ZjelT/PA6WHtNDBOE436YiaEUvHN454bRM3CebhDsIpieCc4texA==", "license": "MIT", "dependencies": { - "@babel/helper-compilation-targets": "^7.27.2", - "@babel/helper-plugin-utils": "^7.27.1", - "debug": "^4.4.1", + "@babel/helper-compilation-targets": "^7.28.6", + "@babel/helper-plugin-utils": "^7.28.6", + "debug": "^4.4.3", "lodash.debounce": "^4.0.8", - "resolve": "^1.22.10" + "resolve": "^1.22.11" }, "peerDependencies": { "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0" @@ -583,27 +506,27 @@ } }, "node_modules/@babel/helper-module-imports": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.27.1.tgz", - "integrity": "sha512-0gSFWUPNXNopqtIPQvlD5WgXYI5GY2kP2cCvoT8kczjbfcfuIljTbcWrulD1CIPIX2gt1wghbDy08yE1p+/r3w==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.28.6.tgz", + "integrity": "sha512-l5XkZK7r7wa9LucGw9LwZyyCUscb4x37JWTPz7swwFE/0FMQAGpiWUZn8u9DzkSBWEcK25jmvubfpw2dnAMdbw==", "license": "MIT", "dependencies": { - "@babel/traverse": "^7.27.1", - "@babel/types": "^7.27.1" + "@babel/traverse": "^7.28.6", + "@babel/types": "^7.28.6" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-module-transforms": { - "version": "7.28.3", - "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.28.3.tgz", - "integrity": "sha512-gytXUbs8k2sXS9PnQptz5o0QnpLL51SwASIORY6XaBKF88nsOT0Zw9szLqlSGQDP/4TljBAD5y98p2U1fqkdsw==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.28.6.tgz", + "integrity": "sha512-67oXFAYr2cDLDVGLXTEABjdBJZ6drElUSI7WKp70NrpyISso3plG9SAGEF6y7zbha/wOzUByWWTJvEDVNIUGcA==", "license": "MIT", "dependencies": { - "@babel/helper-module-imports": "^7.27.1", - "@babel/helper-validator-identifier": "^7.27.1", - "@babel/traverse": "^7.28.3" + "@babel/helper-module-imports": "^7.28.6", + "@babel/helper-validator-identifier": "^7.28.5", + "@babel/traverse": "^7.28.6" }, "engines": { "node": ">=6.9.0" @@ -625,9 +548,9 @@ } }, "node_modules/@babel/helper-plugin-utils": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.27.1.tgz", - "integrity": "sha512-1gn1Up5YXka3YYAHGKpbideQ5Yjf1tDa9qYcgysz+cNCXukyLl6DjPXhD3VRwSb8c0J9tA4b2+rHEZtc6R0tlw==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.28.6.tgz", + "integrity": "sha512-S9gzZ/bz83GRysI7gAD4wPT/AI3uCnY+9xn+Mx/KPs2JwHJIz1W8PZkg2cqyt3RNOBM8ejcXhV6y8Og7ly/Dug==", "license": "MIT", "engines": { "node": ">=6.9.0" @@ -651,14 +574,14 @@ } }, "node_modules/@babel/helper-replace-supers": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/helper-replace-supers/-/helper-replace-supers-7.27.1.tgz", - "integrity": "sha512-7EHz6qDZc8RYS5ElPoShMheWvEgERonFCs7IAonWLLUTXW59DP14bCZt89/GKyreYn8g3S83m21FelHKbeDCKA==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/helper-replace-supers/-/helper-replace-supers-7.28.6.tgz", + "integrity": "sha512-mq8e+laIk94/yFec3DxSjCRD2Z0TAjhVbEJY3UQrlwVo15Lmt7C2wAUbK4bjnTs4APkwsYLTahXRraQXhb1WCg==", "license": "MIT", "dependencies": { - "@babel/helper-member-expression-to-functions": "^7.27.1", + "@babel/helper-member-expression-to-functions": "^7.28.5", "@babel/helper-optimise-call-expression": "^7.27.1", - "@babel/traverse": "^7.27.1" + "@babel/traverse": "^7.28.6" }, "engines": { "node": ">=6.9.0" @@ -708,39 +631,39 @@ } }, "node_modules/@babel/helper-wrap-function": { - "version": "7.28.3", - "resolved": "https://registry.npmjs.org/@babel/helper-wrap-function/-/helper-wrap-function-7.28.3.tgz", - "integrity": "sha512-zdf983tNfLZFletc0RRXYrHrucBEg95NIFMkn6K9dbeMYnsgHaSBGcQqdsCSStG2PYwRre0Qc2NNSCXbG+xc6g==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/helper-wrap-function/-/helper-wrap-function-7.28.6.tgz", + "integrity": "sha512-z+PwLziMNBeSQJonizz2AGnndLsP2DeGHIxDAn+wdHOGuo4Fo1x1HBPPXeE9TAOPHNNWQKCSlA2VZyYyyibDnQ==", "license": "MIT", "dependencies": { - "@babel/template": "^7.27.2", - "@babel/traverse": "^7.28.3", - "@babel/types": "^7.28.2" + "@babel/template": "^7.28.6", + "@babel/traverse": "^7.28.6", + "@babel/types": "^7.28.6" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helpers": { - "version": "7.28.4", - "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.28.4.tgz", - "integrity": "sha512-HFN59MmQXGHVyYadKLVumYsA9dBFun/ldYxipEjzA4196jpLZd8UjEEBLkbEkvfYreDqJhZxYAWFPtrfhNpj4w==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.28.6.tgz", + "integrity": "sha512-xOBvwq86HHdB7WUDTfKfT/Vuxh7gElQ+Sfti2Cy6yIWNW05P8iUslOVcZ4/sKbE+/jQaukQAdz/gf3724kYdqw==", "license": "MIT", "dependencies": { - "@babel/template": "^7.27.2", - "@babel/types": "^7.28.4" + "@babel/template": "^7.28.6", + "@babel/types": "^7.28.6" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/parser": { - "version": "7.28.5", - "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.28.5.tgz", - "integrity": "sha512-KKBU1VGYR7ORr3At5HAtUQ+TV3SzRCXmA/8OdDZiLDBIZxVyzXuztPjfLd3BV1PRAQGCMWWSHYhL0F8d5uHBDQ==", + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.0.tgz", + "integrity": "sha512-IyDgFV5GeDUVX4YdF/3CPULtVGSXXMLh1xVIgdCgxApktqnQV0r7/8Nqthg+8YLGaAtdyIlo2qIdZrbCv4+7ww==", "license": "MIT", "dependencies": { - "@babel/types": "^7.28.5" + "@babel/types": "^7.29.0" }, "bin": { "parser": "bin/babel-parser.js" @@ -813,13 +736,13 @@ } }, "node_modules/@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly": { - "version": "7.28.3", - "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly/-/plugin-bugfix-v8-static-class-fields-redefine-readonly-7.28.3.tgz", - "integrity": "sha512-b6YTX108evsvE4YgWyQ921ZAFFQm3Bn+CA3+ZXlNVnPhx+UfsVURoPjfGAPCjBgrqo30yX/C2nZGX96DxvR9Iw==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly/-/plugin-bugfix-v8-static-class-fields-redefine-readonly-7.28.6.tgz", + "integrity": "sha512-a0aBScVTlNaiUe35UtfxAN7A/tehvvG4/ByO6+46VPKTRSlfnAFsgKy0FUh+qAkQrDTmhDkT+IBOKlOoMUxQ0g==", "license": "MIT", "dependencies": { - "@babel/helper-plugin-utils": "^7.27.1", - "@babel/traverse": "^7.28.3" + "@babel/helper-plugin-utils": "^7.28.6", + "@babel/traverse": "^7.28.6" }, "engines": { "node": ">=6.9.0" @@ -853,12 +776,12 @@ } }, "node_modules/@babel/plugin-syntax-import-assertions": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-assertions/-/plugin-syntax-import-assertions-7.27.1.tgz", - "integrity": "sha512-UT/Jrhw57xg4ILHLFnzFpPDlMbcdEicaAtjPQpbj9wa8T4r5KVWCimHcL/460g8Ht0DMxDyjsLgiWSkVjnwPFg==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-assertions/-/plugin-syntax-import-assertions-7.28.6.tgz", + "integrity": "sha512-pSJUpFHdx9z5nqTSirOCMtYVP2wFgoWhP0p3g8ONK/4IHhLIBd0B9NYqAvIUAhq+OkhO4VM1tENCt0cjlsNShw==", "license": "MIT", "dependencies": { - "@babel/helper-plugin-utils": "^7.27.1" + "@babel/helper-plugin-utils": "^7.28.6" }, "engines": { "node": ">=6.9.0" @@ -868,12 +791,12 @@ } }, "node_modules/@babel/plugin-syntax-import-attributes": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-attributes/-/plugin-syntax-import-attributes-7.27.1.tgz", - "integrity": "sha512-oFT0FrKHgF53f4vOsZGi2Hh3I35PfSmVs4IBFLFj4dnafP+hIWDLg3VyKmUHfLoLHlyxY4C7DGtmHuJgn+IGww==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-attributes/-/plugin-syntax-import-attributes-7.28.6.tgz", + "integrity": "sha512-jiLC0ma9XkQT3TKJ9uYvlakm66Pamywo+qwL+oL8HJOvc6TWdZXVfhqJr8CCzbSGUAbDOzlGHJC1U+vRfLQDvw==", "license": "MIT", "dependencies": { - "@babel/helper-plugin-utils": "^7.27.1" + "@babel/helper-plugin-utils": "^7.28.6" }, "engines": { "node": ">=6.9.0" @@ -883,12 +806,12 @@ } }, "node_modules/@babel/plugin-syntax-jsx": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.27.1.tgz", - "integrity": "sha512-y8YTNIeKoyhGd9O0Jiyzyyqk8gdjnumGTQPsz0xOZOQ2RmkVJeZ1vmmfIvFEKqucBG6axJGBZDE/7iI5suUI/w==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.28.6.tgz", + "integrity": "sha512-wgEmr06G6sIpqr8YDwA2dSRTE3bJ+V0IfpzfSY3Lfgd7YWOaAdlykvJi13ZKBt8cZHfgH1IXN+CL656W3uUa4w==", "license": "MIT", "dependencies": { - "@babel/helper-plugin-utils": "^7.27.1" + "@babel/helper-plugin-utils": "^7.28.6" }, "engines": { "node": ">=6.9.0" @@ -898,12 +821,12 @@ } }, "node_modules/@babel/plugin-syntax-typescript": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.27.1.tgz", - "integrity": "sha512-xfYCBMxveHrRMnAWl1ZlPXOZjzkN82THFvLhQhFXFt81Z5HnN+EtUkZhv/zcKpmT3fzmWZB0ywiBrbC3vogbwQ==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.28.6.tgz", + "integrity": "sha512-+nDNmQye7nlnuuHDboPbGm00Vqg3oO8niRRL27/4LYHUsHYh0zJ1xWOz0uRwNFmM1Avzk8wZbc6rdiYhomzv/A==", "license": "MIT", "dependencies": { - "@babel/helper-plugin-utils": "^7.27.1" + "@babel/helper-plugin-utils": "^7.28.6" }, "engines": { "node": ">=6.9.0" @@ -944,14 +867,14 @@ } }, "node_modules/@babel/plugin-transform-async-generator-functions": { - "version": "7.28.0", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-async-generator-functions/-/plugin-transform-async-generator-functions-7.28.0.tgz", - "integrity": "sha512-BEOdvX4+M765icNPZeidyADIvQ1m1gmunXufXxvRESy/jNNyfovIqUyE7MVgGBjWktCoJlzvFA1To2O4ymIO3Q==", + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-async-generator-functions/-/plugin-transform-async-generator-functions-7.29.0.tgz", + "integrity": "sha512-va0VdWro4zlBr2JsXC+ofCPB2iG12wPtVGTWFx2WLDOM3nYQZZIGP82qku2eW/JR83sD+k2k+CsNtyEbUqhU6w==", "license": "MIT", "dependencies": { - "@babel/helper-plugin-utils": "^7.27.1", + "@babel/helper-plugin-utils": "^7.28.6", "@babel/helper-remap-async-to-generator": "^7.27.1", - "@babel/traverse": "^7.28.0" + "@babel/traverse": "^7.29.0" }, "engines": { "node": ">=6.9.0" @@ -961,13 +884,13 @@ } }, "node_modules/@babel/plugin-transform-async-to-generator": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.27.1.tgz", - "integrity": "sha512-NREkZsZVJS4xmTr8qzE5y8AfIPqsdQfRuUiLRTEzb7Qii8iFWCyDKaUV2c0rCuh4ljDZ98ALHP/PetiBV2nddA==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.28.6.tgz", + "integrity": "sha512-ilTRcmbuXjsMmcZ3HASTe4caH5Tpo93PkTxF9oG2VZsSWsahydmcEHhix9Ik122RcTnZnUzPbmux4wh1swfv7g==", "license": "MIT", "dependencies": { - "@babel/helper-module-imports": "^7.27.1", - "@babel/helper-plugin-utils": "^7.27.1", + "@babel/helper-module-imports": "^7.28.6", + "@babel/helper-plugin-utils": "^7.28.6", "@babel/helper-remap-async-to-generator": "^7.27.1" }, "engines": { @@ -993,12 +916,12 @@ } }, "node_modules/@babel/plugin-transform-block-scoping": { - "version": "7.28.5", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.28.5.tgz", - "integrity": "sha512-45DmULpySVvmq9Pj3X9B+62Xe+DJGov27QravQJU1LLcapR6/10i+gYVAucGGJpHBp5mYxIMK4nDAT/QDLr47g==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.28.6.tgz", + "integrity": "sha512-tt/7wOtBmwHPNMPu7ax4pdPz6shjFrmHDghvNC+FG9Qvj7D6mJcoRQIF5dy4njmxR941l6rgtvfSB2zX3VlUIw==", "license": "MIT", "dependencies": { - "@babel/helper-plugin-utils": "^7.27.1" + "@babel/helper-plugin-utils": "^7.28.6" }, "engines": { "node": ">=6.9.0" @@ -1008,13 +931,13 @@ } }, "node_modules/@babel/plugin-transform-class-properties": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-class-properties/-/plugin-transform-class-properties-7.27.1.tgz", - "integrity": "sha512-D0VcalChDMtuRvJIu3U/fwWjf8ZMykz5iZsg77Nuj821vCKI3zCyRLwRdWbsuJ/uRwZhZ002QtCqIkwC/ZkvbA==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-class-properties/-/plugin-transform-class-properties-7.28.6.tgz", + "integrity": "sha512-dY2wS3I2G7D697VHndN91TJr8/AAfXQNt5ynCTI/MpxMsSzHp+52uNivYT5wCPax3whc47DR8Ba7cmlQMg24bw==", "license": "MIT", "dependencies": { - "@babel/helper-create-class-features-plugin": "^7.27.1", - "@babel/helper-plugin-utils": "^7.27.1" + "@babel/helper-create-class-features-plugin": "^7.28.6", + "@babel/helper-plugin-utils": "^7.28.6" }, "engines": { "node": ">=6.9.0" @@ -1024,13 +947,13 @@ } }, "node_modules/@babel/plugin-transform-class-static-block": { - "version": "7.28.3", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-class-static-block/-/plugin-transform-class-static-block-7.28.3.tgz", - "integrity": "sha512-LtPXlBbRoc4Njl/oh1CeD/3jC+atytbnf/UqLoqTDcEYGUPj022+rvfkbDYieUrSj3CaV4yHDByPE+T2HwfsJg==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-class-static-block/-/plugin-transform-class-static-block-7.28.6.tgz", + "integrity": "sha512-rfQ++ghVwTWTqQ7w8qyDxL1XGihjBss4CmTgGRCTAC9RIbhVpyp4fOeZtta0Lbf+dTNIVJer6ych2ibHwkZqsQ==", "license": "MIT", "dependencies": { - "@babel/helper-create-class-features-plugin": "^7.28.3", - "@babel/helper-plugin-utils": "^7.27.1" + "@babel/helper-create-class-features-plugin": "^7.28.6", + "@babel/helper-plugin-utils": "^7.28.6" }, "engines": { "node": ">=6.9.0" @@ -1040,17 +963,17 @@ } }, "node_modules/@babel/plugin-transform-classes": { - "version": "7.28.4", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-classes/-/plugin-transform-classes-7.28.4.tgz", - "integrity": "sha512-cFOlhIYPBv/iBoc+KS3M6et2XPtbT2HiCRfBXWtfpc9OAyostldxIf9YAYB6ypURBBbx+Qv6nyrLzASfJe+hBA==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-classes/-/plugin-transform-classes-7.28.6.tgz", + "integrity": "sha512-EF5KONAqC5zAqT783iMGuM2ZtmEBy+mJMOKl2BCvPZ2lVrwvXnB6o+OBWCS+CoeCCpVRF2sA2RBKUxvT8tQT5Q==", "license": "MIT", "dependencies": { "@babel/helper-annotate-as-pure": "^7.27.3", - "@babel/helper-compilation-targets": "^7.27.2", + "@babel/helper-compilation-targets": "^7.28.6", "@babel/helper-globals": "^7.28.0", - "@babel/helper-plugin-utils": "^7.27.1", - "@babel/helper-replace-supers": "^7.27.1", - "@babel/traverse": "^7.28.4" + "@babel/helper-plugin-utils": "^7.28.6", + "@babel/helper-replace-supers": "^7.28.6", + "@babel/traverse": "^7.28.6" }, "engines": { "node": ">=6.9.0" @@ -1060,13 +983,13 @@ } }, "node_modules/@babel/plugin-transform-computed-properties": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.27.1.tgz", - "integrity": "sha512-lj9PGWvMTVksbWiDT2tW68zGS/cyo4AkZ/QTp0sQT0mjPopCmrSkzxeXkznjqBxzDI6TclZhOJbBmbBLjuOZUw==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.28.6.tgz", + "integrity": "sha512-bcc3k0ijhHbc2lEfpFHgx7eYw9KNXqOerKWfzbxEHUGKnS3sz9C4CNL9OiFN1297bDNfUiSO7DaLzbvHQQQ1BQ==", "license": "MIT", "dependencies": { - "@babel/helper-plugin-utils": "^7.27.1", - "@babel/template": "^7.27.1" + "@babel/helper-plugin-utils": "^7.28.6", + "@babel/template": "^7.28.6" }, "engines": { "node": ">=6.9.0" @@ -1092,13 +1015,13 @@ } }, "node_modules/@babel/plugin-transform-dotall-regex": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.27.1.tgz", - "integrity": "sha512-gEbkDVGRvjj7+T1ivxrfgygpT7GUd4vmODtYpbs0gZATdkX8/iSnOtZSxiZnsgm1YjTgjI6VKBGSJJevkrclzw==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.28.6.tgz", + "integrity": "sha512-SljjowuNKB7q5Oayv4FoPzeB74g3QgLt8IVJw9ADvWy3QnUb/01aw8I4AVv8wYnPvQz2GDDZ/g3GhcNyDBI4Bg==", "license": "MIT", "dependencies": { - "@babel/helper-create-regexp-features-plugin": "^7.27.1", - "@babel/helper-plugin-utils": "^7.27.1" + "@babel/helper-create-regexp-features-plugin": "^7.28.5", + "@babel/helper-plugin-utils": "^7.28.6" }, "engines": { "node": ">=6.9.0" @@ -1123,13 +1046,13 @@ } }, "node_modules/@babel/plugin-transform-duplicate-named-capturing-groups-regex": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-duplicate-named-capturing-groups-regex/-/plugin-transform-duplicate-named-capturing-groups-regex-7.27.1.tgz", - "integrity": "sha512-hkGcueTEzuhB30B3eJCbCYeCaaEQOmQR0AdvzpD4LoN0GXMWzzGSuRrxR2xTnCrvNbVwK9N6/jQ92GSLfiZWoQ==", + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-duplicate-named-capturing-groups-regex/-/plugin-transform-duplicate-named-capturing-groups-regex-7.29.0.tgz", + "integrity": "sha512-zBPcW2lFGxdiD8PUnPwJjag2J9otbcLQzvbiOzDxpYXyCuYX9agOwMPGn1prVH0a4qzhCKu24rlH4c1f7yA8rw==", "license": "MIT", "dependencies": { - "@babel/helper-create-regexp-features-plugin": "^7.27.1", - "@babel/helper-plugin-utils": "^7.27.1" + "@babel/helper-create-regexp-features-plugin": "^7.28.5", + "@babel/helper-plugin-utils": "^7.28.6" }, "engines": { "node": ">=6.9.0" @@ -1154,13 +1077,13 @@ } }, "node_modules/@babel/plugin-transform-explicit-resource-management": { - "version": "7.28.0", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-explicit-resource-management/-/plugin-transform-explicit-resource-management-7.28.0.tgz", - "integrity": "sha512-K8nhUcn3f6iB+P3gwCv/no7OdzOZQcKchW6N389V6PD8NUWKZHzndOd9sPDVbMoBsbmjMqlB4L9fm+fEFNVlwQ==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-explicit-resource-management/-/plugin-transform-explicit-resource-management-7.28.6.tgz", + "integrity": "sha512-Iao5Konzx2b6g7EPqTy40UZbcdXE126tTxVFr/nAIj+WItNxjKSYTEw3RC+A2/ZetmdJsgueL1KhaMCQHkLPIg==", "license": "MIT", "dependencies": { - "@babel/helper-plugin-utils": "^7.27.1", - "@babel/plugin-transform-destructuring": "^7.28.0" + "@babel/helper-plugin-utils": "^7.28.6", + "@babel/plugin-transform-destructuring": "^7.28.5" }, "engines": { "node": ">=6.9.0" @@ -1170,12 +1093,12 @@ } }, "node_modules/@babel/plugin-transform-exponentiation-operator": { - "version": "7.28.5", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.28.5.tgz", - "integrity": "sha512-D4WIMaFtwa2NizOp+dnoFjRez/ClKiC2BqqImwKd1X28nqBtZEyCYJ2ozQrrzlxAFrcrjxo39S6khe9RNDlGzw==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.28.6.tgz", + "integrity": "sha512-WitabqiGjV/vJ0aPOLSFfNY1u9U3R7W36B03r5I2KoNix+a3sOhJ3pKFB3R5It9/UiK78NiO0KE9P21cMhlPkw==", "license": "MIT", "dependencies": { - "@babel/helper-plugin-utils": "^7.27.1" + "@babel/helper-plugin-utils": "^7.28.6" }, "engines": { "node": ">=6.9.0" @@ -1233,12 +1156,12 @@ } }, "node_modules/@babel/plugin-transform-json-strings": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-json-strings/-/plugin-transform-json-strings-7.27.1.tgz", - "integrity": "sha512-6WVLVJiTjqcQauBhn1LkICsR2H+zm62I3h9faTDKt1qP4jn2o72tSvqMwtGFKGTpojce0gJs+76eZ2uCHRZh0Q==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-json-strings/-/plugin-transform-json-strings-7.28.6.tgz", + "integrity": "sha512-Nr+hEN+0geQkzhbdgQVPoqr47lZbm+5fCUmO70722xJZd0Mvb59+33QLImGj6F+DkK3xgDi1YVysP8whD6FQAw==", "license": "MIT", "dependencies": { - "@babel/helper-plugin-utils": "^7.27.1" + "@babel/helper-plugin-utils": "^7.28.6" }, "engines": { "node": ">=6.9.0" @@ -1263,12 +1186,12 @@ } }, "node_modules/@babel/plugin-transform-logical-assignment-operators": { - "version": "7.28.5", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-logical-assignment-operators/-/plugin-transform-logical-assignment-operators-7.28.5.tgz", - "integrity": "sha512-axUuqnUTBuXyHGcJEVVh9pORaN6wC5bYfE7FGzPiaWa3syib9m7g+/IT/4VgCOe2Upef43PHzeAvcrVek6QuuA==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-logical-assignment-operators/-/plugin-transform-logical-assignment-operators-7.28.6.tgz", + "integrity": "sha512-+anKKair6gpi8VsM/95kmomGNMD0eLz1NQ8+Pfw5sAwWH9fGYXT50E55ZpV0pHUHWf6IUTWPM+f/7AAff+wr9A==", "license": "MIT", "dependencies": { - "@babel/helper-plugin-utils": "^7.27.1" + "@babel/helper-plugin-utils": "^7.28.6" }, "engines": { "node": ">=6.9.0" @@ -1309,13 +1232,13 @@ } }, "node_modules/@babel/plugin-transform-modules-commonjs": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.27.1.tgz", - "integrity": "sha512-OJguuwlTYlN0gBZFRPqwOGNWssZjfIUdS7HMYtN8c1KmwpwHFBwTeFZrg9XZa+DFTitWOW5iTAG7tyCUPsCCyw==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.28.6.tgz", + "integrity": "sha512-jppVbf8IV9iWWwWTQIxJMAJCWBuuKx71475wHwYytrRGQ2CWiDvYlADQno3tcYpS/T2UUWFQp3nVtYfK/YBQrA==", "license": "MIT", "dependencies": { - "@babel/helper-module-transforms": "^7.27.1", - "@babel/helper-plugin-utils": "^7.27.1" + "@babel/helper-module-transforms": "^7.28.6", + "@babel/helper-plugin-utils": "^7.28.6" }, "engines": { "node": ">=6.9.0" @@ -1325,15 +1248,15 @@ } }, "node_modules/@babel/plugin-transform-modules-systemjs": { - "version": "7.28.5", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.28.5.tgz", - "integrity": "sha512-vn5Jma98LCOeBy/KpeQhXcV2WZgaRUtjwQmjoBuLNlOmkg0fB5pdvYVeWRYI69wWKwK2cD1QbMiUQnoujWvrew==", + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.29.0.tgz", + "integrity": "sha512-PrujnVFbOdUpw4UHiVwKvKRLMMic8+eC0CuNlxjsyZUiBjhFdPsewdXCkveh2KqBA9/waD0W1b4hXSOBQJezpQ==", "license": "MIT", "dependencies": { - "@babel/helper-module-transforms": "^7.28.3", - "@babel/helper-plugin-utils": "^7.27.1", + "@babel/helper-module-transforms": "^7.28.6", + "@babel/helper-plugin-utils": "^7.28.6", "@babel/helper-validator-identifier": "^7.28.5", - "@babel/traverse": "^7.28.5" + "@babel/traverse": "^7.29.0" }, "engines": { "node": ">=6.9.0" @@ -1359,13 +1282,13 @@ } }, "node_modules/@babel/plugin-transform-named-capturing-groups-regex": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-named-capturing-groups-regex/-/plugin-transform-named-capturing-groups-regex-7.27.1.tgz", - "integrity": "sha512-SstR5JYy8ddZvD6MhV0tM/j16Qds4mIpJTOd1Yu9J9pJjH93bxHECF7pgtc28XvkzTD6Pxcm/0Z73Hvk7kb3Ng==", + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-named-capturing-groups-regex/-/plugin-transform-named-capturing-groups-regex-7.29.0.tgz", + "integrity": "sha512-1CZQA5KNAD6ZYQLPw7oi5ewtDNxH/2vuCh+6SmvgDfhumForvs8a1o9n0UrEoBD8HU4djO2yWngTQlXl1NDVEQ==", "license": "MIT", "dependencies": { - "@babel/helper-create-regexp-features-plugin": "^7.27.1", - "@babel/helper-plugin-utils": "^7.27.1" + "@babel/helper-create-regexp-features-plugin": "^7.28.5", + "@babel/helper-plugin-utils": "^7.28.6" }, "engines": { "node": ">=6.9.0" @@ -1390,12 +1313,12 @@ } }, "node_modules/@babel/plugin-transform-nullish-coalescing-operator": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-nullish-coalescing-operator/-/plugin-transform-nullish-coalescing-operator-7.27.1.tgz", - "integrity": "sha512-aGZh6xMo6q9vq1JGcw58lZ1Z0+i0xB2x0XaauNIUXd6O1xXc3RwoWEBlsTQrY4KQ9Jf0s5rgD6SiNkaUdJegTA==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-nullish-coalescing-operator/-/plugin-transform-nullish-coalescing-operator-7.28.6.tgz", + "integrity": "sha512-3wKbRgmzYbw24mDJXT7N+ADXw8BC/imU9yo9c9X9NKaLF1fW+e5H1U5QjMUBe4Qo4Ox/o++IyUkl1sVCLgevKg==", "license": "MIT", "dependencies": { - "@babel/helper-plugin-utils": "^7.27.1" + "@babel/helper-plugin-utils": "^7.28.6" }, "engines": { "node": ">=6.9.0" @@ -1405,12 +1328,12 @@ } }, "node_modules/@babel/plugin-transform-numeric-separator": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-numeric-separator/-/plugin-transform-numeric-separator-7.27.1.tgz", - "integrity": "sha512-fdPKAcujuvEChxDBJ5c+0BTaS6revLV7CJL08e4m3de8qJfNIuCc2nc7XJYOjBoTMJeqSmwXJ0ypE14RCjLwaw==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-numeric-separator/-/plugin-transform-numeric-separator-7.28.6.tgz", + "integrity": "sha512-SJR8hPynj8outz+SlStQSwvziMN4+Bq99it4tMIf5/Caq+3iOc0JtKyse8puvyXkk3eFRIA5ID/XfunGgO5i6w==", "license": "MIT", "dependencies": { - "@babel/helper-plugin-utils": "^7.27.1" + "@babel/helper-plugin-utils": "^7.28.6" }, "engines": { "node": ">=6.9.0" @@ -1420,16 +1343,16 @@ } }, "node_modules/@babel/plugin-transform-object-rest-spread": { - "version": "7.28.4", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-object-rest-spread/-/plugin-transform-object-rest-spread-7.28.4.tgz", - "integrity": "sha512-373KA2HQzKhQCYiRVIRr+3MjpCObqzDlyrM6u4I201wL8Mp2wHf7uB8GhDwis03k2ti8Zr65Zyyqs1xOxUF/Ew==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-object-rest-spread/-/plugin-transform-object-rest-spread-7.28.6.tgz", + "integrity": "sha512-5rh+JR4JBC4pGkXLAcYdLHZjXudVxWMXbB6u6+E9lRL5TrGVbHt1TjxGbZ8CkmYw9zjkB7jutzOROArsqtncEA==", "license": "MIT", "dependencies": { - "@babel/helper-compilation-targets": "^7.27.2", - "@babel/helper-plugin-utils": "^7.27.1", - "@babel/plugin-transform-destructuring": "^7.28.0", + "@babel/helper-compilation-targets": "^7.28.6", + "@babel/helper-plugin-utils": "^7.28.6", + "@babel/plugin-transform-destructuring": "^7.28.5", "@babel/plugin-transform-parameters": "^7.27.7", - "@babel/traverse": "^7.28.4" + "@babel/traverse": "^7.28.6" }, "engines": { "node": ">=6.9.0" @@ -1455,12 +1378,12 @@ } }, "node_modules/@babel/plugin-transform-optional-catch-binding": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-optional-catch-binding/-/plugin-transform-optional-catch-binding-7.27.1.tgz", - "integrity": "sha512-txEAEKzYrHEX4xSZN4kJ+OfKXFVSWKB2ZxM9dpcE3wT7smwkNmXo5ORRlVzMVdJbD+Q8ILTgSD7959uj+3Dm3Q==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-optional-catch-binding/-/plugin-transform-optional-catch-binding-7.28.6.tgz", + "integrity": "sha512-R8ja/Pyrv0OGAvAXQhSTmWyPJPml+0TMqXlO5w+AsMEiwb2fg3WkOvob7UxFSL3OIttFSGSRFKQsOhJ/X6HQdQ==", "license": "MIT", "dependencies": { - "@babel/helper-plugin-utils": "^7.27.1" + "@babel/helper-plugin-utils": "^7.28.6" }, "engines": { "node": ">=6.9.0" @@ -1470,12 +1393,12 @@ } }, "node_modules/@babel/plugin-transform-optional-chaining": { - "version": "7.28.5", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-optional-chaining/-/plugin-transform-optional-chaining-7.28.5.tgz", - "integrity": "sha512-N6fut9IZlPnjPwgiQkXNhb+cT8wQKFlJNqcZkWlcTqkcqx6/kU4ynGmLFoa4LViBSirn05YAwk+sQBbPfxtYzQ==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-optional-chaining/-/plugin-transform-optional-chaining-7.28.6.tgz", + "integrity": "sha512-A4zobikRGJTsX9uqVFdafzGkqD30t26ck2LmOzAuLL8b2x6k3TIqRiT2xVvA9fNmFeTX484VpsdgmKNA0bS23w==", "license": "MIT", "dependencies": { - "@babel/helper-plugin-utils": "^7.27.1", + "@babel/helper-plugin-utils": "^7.28.6", "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1" }, "engines": { @@ -1501,13 +1424,13 @@ } }, "node_modules/@babel/plugin-transform-private-methods": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-private-methods/-/plugin-transform-private-methods-7.27.1.tgz", - "integrity": "sha512-10FVt+X55AjRAYI9BrdISN9/AQWHqldOeZDUoLyif1Kn05a56xVBXb8ZouL8pZ9jem8QpXaOt8TS7RHUIS+GPA==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-private-methods/-/plugin-transform-private-methods-7.28.6.tgz", + "integrity": "sha512-piiuapX9CRv7+0st8lmuUlRSmX6mBcVeNQ1b4AYzJxfCMuBfB0vBXDiGSmm03pKJw1v6cZ8KSeM+oUnM6yAExg==", "license": "MIT", "dependencies": { - "@babel/helper-create-class-features-plugin": "^7.27.1", - "@babel/helper-plugin-utils": "^7.27.1" + "@babel/helper-create-class-features-plugin": "^7.28.6", + "@babel/helper-plugin-utils": "^7.28.6" }, "engines": { "node": ">=6.9.0" @@ -1517,14 +1440,14 @@ } }, "node_modules/@babel/plugin-transform-private-property-in-object": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-private-property-in-object/-/plugin-transform-private-property-in-object-7.27.1.tgz", - "integrity": "sha512-5J+IhqTi1XPa0DXF83jYOaARrX+41gOewWbkPyjMNRDqgOCqdffGh8L3f/Ek5utaEBZExjSAzcyjmV9SSAWObQ==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-private-property-in-object/-/plugin-transform-private-property-in-object-7.28.6.tgz", + "integrity": "sha512-b97jvNSOb5+ehyQmBpmhOCiUC5oVK4PMnpRvO7+ymFBoqYjeDHIU9jnrNUuwHOiL9RpGDoKBpSViarV+BU+eVA==", "license": "MIT", "dependencies": { - "@babel/helper-annotate-as-pure": "^7.27.1", - "@babel/helper-create-class-features-plugin": "^7.27.1", - "@babel/helper-plugin-utils": "^7.27.1" + "@babel/helper-annotate-as-pure": "^7.27.3", + "@babel/helper-create-class-features-plugin": "^7.28.6", + "@babel/helper-plugin-utils": "^7.28.6" }, "engines": { "node": ">=6.9.0" @@ -1579,16 +1502,16 @@ } }, "node_modules/@babel/plugin-transform-react-jsx": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx/-/plugin-transform-react-jsx-7.27.1.tgz", - "integrity": "sha512-2KH4LWGSrJIkVf5tSiBFYuXDAoWRq2MMwgivCf+93dd0GQi8RXLjKA/0EvRnVV5G0hrHczsquXuD01L8s6dmBw==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx/-/plugin-transform-react-jsx-7.28.6.tgz", + "integrity": "sha512-61bxqhiRfAACulXSLd/GxqmAedUSrRZIu/cbaT18T1CetkTmtDN15it7i80ru4DVqRK1WMxQhXs+Lf9kajm5Ow==", "license": "MIT", "dependencies": { - "@babel/helper-annotate-as-pure": "^7.27.1", - "@babel/helper-module-imports": "^7.27.1", - "@babel/helper-plugin-utils": "^7.27.1", - "@babel/plugin-syntax-jsx": "^7.27.1", - "@babel/types": "^7.27.1" + "@babel/helper-annotate-as-pure": "^7.27.3", + "@babel/helper-module-imports": "^7.28.6", + "@babel/helper-plugin-utils": "^7.28.6", + "@babel/plugin-syntax-jsx": "^7.28.6", + "@babel/types": "^7.28.6" }, "engines": { "node": ">=6.9.0" @@ -1629,12 +1552,12 @@ } }, "node_modules/@babel/plugin-transform-regenerator": { - "version": "7.28.4", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.28.4.tgz", - "integrity": "sha512-+ZEdQlBoRg9m2NnzvEeLgtvBMO4tkFBw5SQIUgLICgTrumLoU7lr+Oghi6km2PFj+dbUt2u1oby2w3BDO9YQnA==", + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.29.0.tgz", + "integrity": "sha512-FijqlqMA7DmRdg/aINBSs04y8XNTYw/lr1gJ2WsmBnnaNw1iS43EPkJW+zK7z65auG3AWRFXWj+NcTQwYptUog==", "license": "MIT", "dependencies": { - "@babel/helper-plugin-utils": "^7.27.1" + "@babel/helper-plugin-utils": "^7.28.6" }, "engines": { "node": ">=6.9.0" @@ -1644,13 +1567,13 @@ } }, "node_modules/@babel/plugin-transform-regexp-modifiers": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-regexp-modifiers/-/plugin-transform-regexp-modifiers-7.27.1.tgz", - "integrity": "sha512-TtEciroaiODtXvLZv4rmfMhkCv8jx3wgKpL68PuiPh2M4fvz5jhsA7697N1gMvkvr/JTF13DrFYyEbY9U7cVPA==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-regexp-modifiers/-/plugin-transform-regexp-modifiers-7.28.6.tgz", + "integrity": "sha512-QGWAepm9qxpaIs7UM9FvUSnCGlb8Ua1RhyM4/veAxLwt3gMat/LSGrZixyuj4I6+Kn9iwvqCyPTtbdxanYoWYg==", "license": "MIT", "dependencies": { - "@babel/helper-create-regexp-features-plugin": "^7.27.1", - "@babel/helper-plugin-utils": "^7.27.1" + "@babel/helper-create-regexp-features-plugin": "^7.28.5", + "@babel/helper-plugin-utils": "^7.28.6" }, "engines": { "node": ">=6.9.0" @@ -1675,13 +1598,13 @@ } }, "node_modules/@babel/plugin-transform-runtime": { - "version": "7.28.5", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-runtime/-/plugin-transform-runtime-7.28.5.tgz", - "integrity": "sha512-20NUVgOrinudkIBzQ2bNxP08YpKprUkRTiRSd2/Z5GOdPImJGkoN4Z7IQe1T5AdyKI1i5L6RBmluqdSzvaq9/w==", + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-runtime/-/plugin-transform-runtime-7.29.0.tgz", + "integrity": "sha512-jlaRT5dJtMaMCV6fAuLbsQMSwz/QkvaHOHOSXRitGGwSpR1blCY4KUKoyP2tYO8vJcqYe8cEj96cqSztv3uF9w==", "license": "MIT", "dependencies": { - "@babel/helper-module-imports": "^7.27.1", - "@babel/helper-plugin-utils": "^7.27.1", + "@babel/helper-module-imports": "^7.28.6", + "@babel/helper-plugin-utils": "^7.28.6", "babel-plugin-polyfill-corejs2": "^0.4.14", "babel-plugin-polyfill-corejs3": "^0.13.0", "babel-plugin-polyfill-regenerator": "^0.6.5", @@ -1719,12 +1642,12 @@ } }, "node_modules/@babel/plugin-transform-spread": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-spread/-/plugin-transform-spread-7.27.1.tgz", - "integrity": "sha512-kpb3HUqaILBJcRFVhFUs6Trdd4mkrzcGXss+6/mxUd273PfbWqSDHRzMT2234gIg2QYfAjvXLSquP1xECSg09Q==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-spread/-/plugin-transform-spread-7.28.6.tgz", + "integrity": "sha512-9U4QObUC0FtJl05AsUcodau/RWDytrU6uKgkxu09mLR9HLDAtUMoPuuskm5huQsoktmsYpI+bGmq+iapDcriKA==", "license": "MIT", "dependencies": { - "@babel/helper-plugin-utils": "^7.27.1", + "@babel/helper-plugin-utils": "^7.28.6", "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1" }, "engines": { @@ -1780,16 +1703,16 @@ } }, "node_modules/@babel/plugin-transform-typescript": { - "version": "7.28.5", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typescript/-/plugin-transform-typescript-7.28.5.tgz", - "integrity": "sha512-x2Qa+v/CuEoX7Dr31iAfr0IhInrVOWZU/2vJMJ00FOR/2nM0BcBEclpaf9sWCDc+v5e9dMrhSH8/atq/kX7+bA==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typescript/-/plugin-transform-typescript-7.28.6.tgz", + "integrity": "sha512-0YWL2RFxOqEm9Efk5PvreamxPME8OyY0wM5wh5lHjF+VtVhdneCWGzZeSqzOfiobVqQaNCd2z0tQvnI9DaPWPw==", "license": "MIT", "dependencies": { "@babel/helper-annotate-as-pure": "^7.27.3", - "@babel/helper-create-class-features-plugin": "^7.28.5", - "@babel/helper-plugin-utils": "^7.27.1", + "@babel/helper-create-class-features-plugin": "^7.28.6", + "@babel/helper-plugin-utils": "^7.28.6", "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1", - "@babel/plugin-syntax-typescript": "^7.27.1" + "@babel/plugin-syntax-typescript": "^7.28.6" }, "engines": { "node": ">=6.9.0" @@ -1814,13 +1737,13 @@ } }, "node_modules/@babel/plugin-transform-unicode-property-regex": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-property-regex/-/plugin-transform-unicode-property-regex-7.27.1.tgz", - "integrity": "sha512-uW20S39PnaTImxp39O5qFlHLS9LJEmANjMG7SxIhap8rCHqu0Ik+tLEPX5DKmHn6CsWQ7j3lix2tFOa5YtL12Q==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-property-regex/-/plugin-transform-unicode-property-regex-7.28.6.tgz", + "integrity": "sha512-4Wlbdl/sIZjzi/8St0evF0gEZrgOswVO6aOzqxh1kDZOl9WmLrHq2HtGhnOJZmHZYKP8WZ1MDLCt5DAWwRo57A==", "license": "MIT", "dependencies": { - "@babel/helper-create-regexp-features-plugin": "^7.27.1", - "@babel/helper-plugin-utils": "^7.27.1" + "@babel/helper-create-regexp-features-plugin": "^7.28.5", + "@babel/helper-plugin-utils": "^7.28.6" }, "engines": { "node": ">=6.9.0" @@ -1846,13 +1769,13 @@ } }, "node_modules/@babel/plugin-transform-unicode-sets-regex": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-sets-regex/-/plugin-transform-unicode-sets-regex-7.27.1.tgz", - "integrity": "sha512-EtkOujbc4cgvb0mlpQefi4NTPBzhSIevblFevACNLUspmrALgmEBdL/XfnyyITfd8fKBZrZys92zOWcik7j9Tw==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-sets-regex/-/plugin-transform-unicode-sets-regex-7.28.6.tgz", + "integrity": "sha512-/wHc/paTUmsDYN7SZkpWxogTOBNnlx7nBQYfy6JJlCT7G3mVhltk3e++N7zV0XfgGsrqBxd4rJQt9H16I21Y1Q==", "license": "MIT", "dependencies": { - "@babel/helper-create-regexp-features-plugin": "^7.27.1", - "@babel/helper-plugin-utils": "^7.27.1" + "@babel/helper-create-regexp-features-plugin": "^7.28.5", + "@babel/helper-plugin-utils": "^7.28.6" }, "engines": { "node": ">=6.9.0" @@ -1862,80 +1785,80 @@ } }, "node_modules/@babel/preset-env": { - "version": "7.28.5", - "resolved": "https://registry.npmjs.org/@babel/preset-env/-/preset-env-7.28.5.tgz", - "integrity": "sha512-S36mOoi1Sb6Fz98fBfE+UZSpYw5mJm0NUHtIKrOuNcqeFauy1J6dIvXm2KRVKobOSaGq4t/hBXdN4HGU3wL9Wg==", + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/preset-env/-/preset-env-7.29.0.tgz", + "integrity": "sha512-fNEdfc0yi16lt6IZo2Qxk3knHVdfMYX33czNb4v8yWhemoBhibCpQK/uYHtSKIiO+p/zd3+8fYVXhQdOVV608w==", "license": "MIT", "dependencies": { - "@babel/compat-data": "^7.28.5", - "@babel/helper-compilation-targets": "^7.27.2", - "@babel/helper-plugin-utils": "^7.27.1", + "@babel/compat-data": "^7.29.0", + "@babel/helper-compilation-targets": "^7.28.6", + "@babel/helper-plugin-utils": "^7.28.6", "@babel/helper-validator-option": "^7.27.1", "@babel/plugin-bugfix-firefox-class-in-computed-class-key": "^7.28.5", "@babel/plugin-bugfix-safari-class-field-initializer-scope": "^7.27.1", "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression": "^7.27.1", "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": "^7.27.1", - "@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly": "^7.28.3", + "@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly": "^7.28.6", "@babel/plugin-proposal-private-property-in-object": "7.21.0-placeholder-for-preset-env.2", - "@babel/plugin-syntax-import-assertions": "^7.27.1", - "@babel/plugin-syntax-import-attributes": "^7.27.1", + "@babel/plugin-syntax-import-assertions": "^7.28.6", + "@babel/plugin-syntax-import-attributes": "^7.28.6", "@babel/plugin-syntax-unicode-sets-regex": "^7.18.6", "@babel/plugin-transform-arrow-functions": "^7.27.1", - "@babel/plugin-transform-async-generator-functions": "^7.28.0", - "@babel/plugin-transform-async-to-generator": "^7.27.1", + "@babel/plugin-transform-async-generator-functions": "^7.29.0", + "@babel/plugin-transform-async-to-generator": "^7.28.6", "@babel/plugin-transform-block-scoped-functions": "^7.27.1", - "@babel/plugin-transform-block-scoping": "^7.28.5", - "@babel/plugin-transform-class-properties": "^7.27.1", - "@babel/plugin-transform-class-static-block": "^7.28.3", - "@babel/plugin-transform-classes": "^7.28.4", - "@babel/plugin-transform-computed-properties": "^7.27.1", + "@babel/plugin-transform-block-scoping": "^7.28.6", + "@babel/plugin-transform-class-properties": "^7.28.6", + "@babel/plugin-transform-class-static-block": "^7.28.6", + "@babel/plugin-transform-classes": "^7.28.6", + "@babel/plugin-transform-computed-properties": "^7.28.6", "@babel/plugin-transform-destructuring": "^7.28.5", - "@babel/plugin-transform-dotall-regex": "^7.27.1", + "@babel/plugin-transform-dotall-regex": "^7.28.6", "@babel/plugin-transform-duplicate-keys": "^7.27.1", - "@babel/plugin-transform-duplicate-named-capturing-groups-regex": "^7.27.1", + "@babel/plugin-transform-duplicate-named-capturing-groups-regex": "^7.29.0", "@babel/plugin-transform-dynamic-import": "^7.27.1", - "@babel/plugin-transform-explicit-resource-management": "^7.28.0", - "@babel/plugin-transform-exponentiation-operator": "^7.28.5", + "@babel/plugin-transform-explicit-resource-management": "^7.28.6", + "@babel/plugin-transform-exponentiation-operator": "^7.28.6", "@babel/plugin-transform-export-namespace-from": "^7.27.1", "@babel/plugin-transform-for-of": "^7.27.1", "@babel/plugin-transform-function-name": "^7.27.1", - "@babel/plugin-transform-json-strings": "^7.27.1", + "@babel/plugin-transform-json-strings": "^7.28.6", "@babel/plugin-transform-literals": "^7.27.1", - "@babel/plugin-transform-logical-assignment-operators": "^7.28.5", + "@babel/plugin-transform-logical-assignment-operators": "^7.28.6", "@babel/plugin-transform-member-expression-literals": "^7.27.1", "@babel/plugin-transform-modules-amd": "^7.27.1", - "@babel/plugin-transform-modules-commonjs": "^7.27.1", - "@babel/plugin-transform-modules-systemjs": "^7.28.5", + "@babel/plugin-transform-modules-commonjs": "^7.28.6", + "@babel/plugin-transform-modules-systemjs": "^7.29.0", "@babel/plugin-transform-modules-umd": "^7.27.1", - "@babel/plugin-transform-named-capturing-groups-regex": "^7.27.1", + "@babel/plugin-transform-named-capturing-groups-regex": "^7.29.0", "@babel/plugin-transform-new-target": "^7.27.1", - "@babel/plugin-transform-nullish-coalescing-operator": "^7.27.1", - "@babel/plugin-transform-numeric-separator": "^7.27.1", - "@babel/plugin-transform-object-rest-spread": "^7.28.4", + "@babel/plugin-transform-nullish-coalescing-operator": "^7.28.6", + "@babel/plugin-transform-numeric-separator": "^7.28.6", + "@babel/plugin-transform-object-rest-spread": "^7.28.6", "@babel/plugin-transform-object-super": "^7.27.1", - "@babel/plugin-transform-optional-catch-binding": "^7.27.1", - "@babel/plugin-transform-optional-chaining": "^7.28.5", + "@babel/plugin-transform-optional-catch-binding": "^7.28.6", + "@babel/plugin-transform-optional-chaining": "^7.28.6", "@babel/plugin-transform-parameters": "^7.27.7", - "@babel/plugin-transform-private-methods": "^7.27.1", - "@babel/plugin-transform-private-property-in-object": "^7.27.1", + "@babel/plugin-transform-private-methods": "^7.28.6", + "@babel/plugin-transform-private-property-in-object": "^7.28.6", "@babel/plugin-transform-property-literals": "^7.27.1", - "@babel/plugin-transform-regenerator": "^7.28.4", - "@babel/plugin-transform-regexp-modifiers": "^7.27.1", + "@babel/plugin-transform-regenerator": "^7.29.0", + "@babel/plugin-transform-regexp-modifiers": "^7.28.6", "@babel/plugin-transform-reserved-words": "^7.27.1", "@babel/plugin-transform-shorthand-properties": "^7.27.1", - "@babel/plugin-transform-spread": "^7.27.1", + "@babel/plugin-transform-spread": "^7.28.6", "@babel/plugin-transform-sticky-regex": "^7.27.1", "@babel/plugin-transform-template-literals": "^7.27.1", "@babel/plugin-transform-typeof-symbol": "^7.27.1", "@babel/plugin-transform-unicode-escapes": "^7.27.1", - "@babel/plugin-transform-unicode-property-regex": "^7.27.1", + "@babel/plugin-transform-unicode-property-regex": "^7.28.6", "@babel/plugin-transform-unicode-regex": "^7.27.1", - "@babel/plugin-transform-unicode-sets-regex": "^7.27.1", + "@babel/plugin-transform-unicode-sets-regex": "^7.28.6", "@babel/preset-modules": "0.1.6-no-external-plugins", - "babel-plugin-polyfill-corejs2": "^0.4.14", - "babel-plugin-polyfill-corejs3": "^0.13.0", - "babel-plugin-polyfill-regenerator": "^0.6.5", - "core-js-compat": "^3.43.0", + "babel-plugin-polyfill-corejs2": "^0.4.15", + "babel-plugin-polyfill-corejs3": "^0.14.0", + "babel-plugin-polyfill-regenerator": "^0.6.6", + "core-js-compat": "^3.48.0", "semver": "^6.3.1" }, "engines": { @@ -1945,6 +1868,19 @@ "@babel/core": "^7.0.0-0" } }, + "node_modules/@babel/preset-env/node_modules/babel-plugin-polyfill-corejs3": { + "version": "0.14.0", + "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.14.0.tgz", + "integrity": "sha512-AvDcMxJ34W4Wgy4KBIIePQTAOP1Ie2WFwkQp3dB7FQ/f0lI5+nM96zUnYEOE1P9sEg0es5VCP0HxiWu5fUHZAQ==", + "license": "MIT", + "dependencies": { + "@babel/helper-define-polyfill-provider": "^0.6.6", + "core-js-compat": "^3.48.0" + }, + "peerDependencies": { + "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0" + } + }, "node_modules/@babel/preset-env/node_modules/semver": { "version": "6.3.1", "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", @@ -2008,52 +1944,52 @@ } }, "node_modules/@babel/runtime": { - "version": "7.28.3", - "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.28.3.tgz", - "integrity": "sha512-9uIQ10o0WGdpP6GDhXcdOJPJuDgFtIDtN/9+ArJQ2NAfAmiuhTQdzkaTGR33v43GYS2UrSA0eX2pPPHoFVvpxA==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.28.6.tgz", + "integrity": "sha512-05WQkdpL9COIMz4LjTxGpPNCdlpyimKppYNoJ5Di5EUObifl8t4tuLuUBBZEpoLYOmfvIWrsp9fCl0HoPRVTdA==", "license": "MIT", "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/runtime-corejs3": { - "version": "7.28.4", - "resolved": "https://registry.npmjs.org/@babel/runtime-corejs3/-/runtime-corejs3-7.28.4.tgz", - "integrity": "sha512-h7iEYiW4HebClDEhtvFObtPmIvrd1SSfpI9EhOeKk4CtIK/ngBWFpuhCzhdmRKtg71ylcue+9I6dv54XYO1epQ==", + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/runtime-corejs3/-/runtime-corejs3-7.29.0.tgz", + "integrity": "sha512-TgUkdp71C9pIbBcHudc+gXZnihEDOjUAmXO1VO4HHGES7QLZcShR0stfKIxLSNIYx2fqhmJChOjm/wkF8wv4gA==", "license": "MIT", "dependencies": { - "core-js-pure": "^3.43.0" + "core-js-pure": "^3.48.0" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/template": { - "version": "7.27.2", - "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.27.2.tgz", - "integrity": "sha512-LPDZ85aEJyYSd18/DkjNh4/y1ntkE5KwUHWTiqgRxruuZL2F1yuHligVHLvcHY2vMHXttKFpJn6LwfI7cw7ODw==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.28.6.tgz", + "integrity": "sha512-YA6Ma2KsCdGb+WC6UpBVFJGXL58MDA6oyONbjyF/+5sBgxY/dwkhLogbMT2GXXyU84/IhRw/2D1Os1B/giz+BQ==", "license": "MIT", "dependencies": { - "@babel/code-frame": "^7.27.1", - "@babel/parser": "^7.27.2", - "@babel/types": "^7.27.1" + "@babel/code-frame": "^7.28.6", + "@babel/parser": "^7.28.6", + "@babel/types": "^7.28.6" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/traverse": { - "version": "7.28.5", - "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.28.5.tgz", - "integrity": "sha512-TCCj4t55U90khlYkVV/0TfkJkAkUg3jZFA3Neb7unZT8CPok7iiRfaX0F+WnqWqt7OxhOn0uBKXCw4lbL8W0aQ==", + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.0.tgz", + "integrity": "sha512-4HPiQr0X7+waHfyXPZpWPfWL/J7dcN1mx9gL6WdQVMbPnF3+ZhSMs8tCxN7oHddJE9fhNE7+lxdnlyemKfJRuA==", "license": "MIT", "dependencies": { - "@babel/code-frame": "^7.27.1", - "@babel/generator": "^7.28.5", + "@babel/code-frame": "^7.29.0", + "@babel/generator": "^7.29.0", "@babel/helper-globals": "^7.28.0", - "@babel/parser": "^7.28.5", - "@babel/template": "^7.27.2", - "@babel/types": "^7.28.5", + "@babel/parser": "^7.29.0", + "@babel/template": "^7.28.6", + "@babel/types": "^7.29.0", "debug": "^4.3.1" }, "engines": { @@ -2061,9 +1997,9 @@ } }, "node_modules/@babel/types": { - "version": "7.28.5", - "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.28.5.tgz", - "integrity": "sha512-qQ5m48eI/MFLQ5PxQj4PFaprjyCTLI37ElWMmNs0K8Lk3dVeOdNpB3ks8jc7yM5CDmVC73eMVk/trk3fgmrUpA==", + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.0.tgz", + "integrity": "sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==", "license": "MIT", "dependencies": { "@babel/helper-string-parser": "^7.27.1", @@ -2074,48 +2010,48 @@ } }, "node_modules/@braintree/sanitize-url": { - "version": "7.1.1", - "resolved": "https://registry.npmjs.org/@braintree/sanitize-url/-/sanitize-url-7.1.1.tgz", - "integrity": "sha512-i1L7noDNxtFyL5DmZafWy1wRVhGehQmzZaz1HiN5e7iylJMSZR7ekOV7NsIqa5qBldlLrsKv4HbgFUVlQrz8Mw==", + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/@braintree/sanitize-url/-/sanitize-url-7.1.2.tgz", + "integrity": "sha512-jigsZK+sMF/cuiB7sERuo9V7N9jx+dhmHHnQyDSVdpZwVutaBu7WvNYqMDLSgFgfB30n452TP3vjDAvFC973mA==", "license": "MIT" }, "node_modules/@chevrotain/cst-dts-gen": { - "version": "11.0.3", - "resolved": "https://registry.npmjs.org/@chevrotain/cst-dts-gen/-/cst-dts-gen-11.0.3.tgz", - "integrity": "sha512-BvIKpRLeS/8UbfxXxgC33xOumsacaeCKAjAeLyOn7Pcp95HiRbrpl14S+9vaZLolnbssPIUuiUd8IvgkRyt6NQ==", + "version": "11.1.2", + "resolved": "https://registry.npmjs.org/@chevrotain/cst-dts-gen/-/cst-dts-gen-11.1.2.tgz", + "integrity": "sha512-XTsjvDVB5nDZBQB8o0o/0ozNelQtn2KrUVteIHSlPd2VAV2utEb6JzyCJaJ8tGxACR4RiBNWy5uYUHX2eji88Q==", "license": "Apache-2.0", "dependencies": { - "@chevrotain/gast": "11.0.3", - "@chevrotain/types": "11.0.3", - "lodash-es": "4.17.21" + "@chevrotain/gast": "11.1.2", + "@chevrotain/types": "11.1.2", + "lodash-es": "4.17.23" } }, "node_modules/@chevrotain/gast": { - "version": "11.0.3", - "resolved": "https://registry.npmjs.org/@chevrotain/gast/-/gast-11.0.3.tgz", - "integrity": "sha512-+qNfcoNk70PyS/uxmj3li5NiECO+2YKZZQMbmjTqRI3Qchu8Hig/Q9vgkHpI3alNjr7M+a2St5pw5w5F6NL5/Q==", + "version": "11.1.2", + "resolved": "https://registry.npmjs.org/@chevrotain/gast/-/gast-11.1.2.tgz", + "integrity": "sha512-Z9zfXR5jNZb1Hlsd/p+4XWeUFugrHirq36bKzPWDSIacV+GPSVXdk+ahVWZTwjhNwofAWg/sZg58fyucKSQx5g==", "license": "Apache-2.0", "dependencies": { - "@chevrotain/types": "11.0.3", - "lodash-es": "4.17.21" + "@chevrotain/types": "11.1.2", + "lodash-es": "4.17.23" } }, "node_modules/@chevrotain/regexp-to-ast": { - "version": "11.0.3", - "resolved": "https://registry.npmjs.org/@chevrotain/regexp-to-ast/-/regexp-to-ast-11.0.3.tgz", - "integrity": "sha512-1fMHaBZxLFvWI067AVbGJav1eRY7N8DDvYCTwGBiE/ytKBgP8azTdgyrKyWZ9Mfh09eHWb5PgTSO8wi7U824RA==", + "version": "11.1.2", + "resolved": "https://registry.npmjs.org/@chevrotain/regexp-to-ast/-/regexp-to-ast-11.1.2.tgz", + "integrity": "sha512-nMU3Uj8naWer7xpZTYJdxbAs6RIv/dxYzkYU8GSwgUtcAAlzjcPfX1w+RKRcYG8POlzMeayOQ/znfwxEGo5ulw==", "license": "Apache-2.0" }, "node_modules/@chevrotain/types": { - "version": "11.0.3", - "resolved": "https://registry.npmjs.org/@chevrotain/types/-/types-11.0.3.tgz", - "integrity": "sha512-gsiM3G8b58kZC2HaWR50gu6Y1440cHiJ+i3JUvcp/35JchYejb2+5MVeJK0iKThYpAa/P2PYFV4hoi44HD+aHQ==", + "version": "11.1.2", + "resolved": "https://registry.npmjs.org/@chevrotain/types/-/types-11.1.2.tgz", + "integrity": "sha512-U+HFai5+zmJCkK86QsaJtoITlboZHBqrVketcO2ROv865xfCMSFpELQoz1GkX5GzME8pTa+3kbKrZHQtI0gdbw==", "license": "Apache-2.0" }, "node_modules/@chevrotain/utils": { - "version": "11.0.3", - "resolved": "https://registry.npmjs.org/@chevrotain/utils/-/utils-11.0.3.tgz", - "integrity": "sha512-YslZMgtJUyuMbZ+aKvfF3x1f5liK4mWNxghFRv7jqRR9C3R3fAOGTTKvxXDa2Y1s9zSbcpuO0cAxDYsc9SrXoQ==", + "version": "11.1.2", + "resolved": "https://registry.npmjs.org/@chevrotain/utils/-/utils-11.1.2.tgz", + "integrity": "sha512-4mudFAQ6H+MqBTfqLmU7G1ZwRzCLfJEooL/fsF6rCX5eePMbGhoy5n4g+G4vlh2muDcsCTJtL+uKbOzWxs5LHA==", "license": "Apache-2.0" }, "node_modules/@colors/colors": { @@ -2235,6 +2171,7 @@ } ], "license": "MIT", + "peer": true, "engines": { "node": ">=18" }, @@ -2257,6 +2194,7 @@ } ], "license": "MIT", + "peer": true, "engines": { "node": ">=18" } @@ -2362,10 +2300,11 @@ } }, "node_modules/@csstools/postcss-cascade-layers/node_modules/postcss-selector-parser": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.0.tgz", - "integrity": "sha512-8sLjZwK0R+JlxlYcTuVnyT2v+htpdrjDOKuMcOVdYjt52Lh8hWRYpxBPoKx/Zg+bcjc3wx6fmQevMmUztS/ccA==", + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.1.tgz", + "integrity": "sha512-orRsuYpJVw8LdAwqqLykBj9ecS5/cRHlI5+nvTo8LcCKmzDmqVORXtOIYEEQuL9D4BxtA1lm5isAqzQZCoQ6Eg==", "license": "MIT", + "peer": true, "dependencies": { "cssesc": "^3.0.0", "util-deprecate": "^1.0.2" @@ -2783,10 +2722,11 @@ } }, "node_modules/@csstools/postcss-is-pseudo-class/node_modules/postcss-selector-parser": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.0.tgz", - "integrity": "sha512-8sLjZwK0R+JlxlYcTuVnyT2v+htpdrjDOKuMcOVdYjt52Lh8hWRYpxBPoKx/Zg+bcjc3wx6fmQevMmUztS/ccA==", + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.1.tgz", + "integrity": "sha512-orRsuYpJVw8LdAwqqLykBj9ecS5/cRHlI5+nvTo8LcCKmzDmqVORXtOIYEEQuL9D4BxtA1lm5isAqzQZCoQ6Eg==", "license": "MIT", + "peer": true, "dependencies": { "cssesc": "^3.0.0", "util-deprecate": "^1.0.2" @@ -3022,9 +2962,9 @@ } }, "node_modules/@csstools/postcss-normalize-display-values": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/@csstools/postcss-normalize-display-values/-/postcss-normalize-display-values-4.0.0.tgz", - "integrity": "sha512-HlEoG0IDRoHXzXnkV4in47dzsxdsjdz6+j7MLjaACABX2NfvjFS6XVAnpaDyGesz9gK2SC7MbNwdCHusObKJ9Q==", + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/@csstools/postcss-normalize-display-values/-/postcss-normalize-display-values-4.0.1.tgz", + "integrity": "sha512-TQUGBuRvxdc7TgNSTevYqrL8oItxiwPDixk20qCB5me/W8uF7BPbhRrAvFuhEoywQp/woRsUZ6SJ+sU5idZAIA==", "funding": [ { "type": "github", @@ -3075,6 +3015,28 @@ "postcss": "^8.4" } }, + "node_modules/@csstools/postcss-position-area-property": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@csstools/postcss-position-area-property/-/postcss-position-area-property-1.0.0.tgz", + "integrity": "sha512-fUP6KR8qV2NuUZV3Cw8itx0Ep90aRjAZxAEzC3vrl6yjFv+pFsQbR18UuQctEKmA72K9O27CoYiKEgXxkqjg8Q==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/csstools" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + } + ], + "license": "MIT-0", + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "postcss": "^8.4" + } + }, "node_modules/@csstools/postcss-progressive-custom-properties": { "version": "4.2.1", "resolved": "https://registry.npmjs.org/@csstools/postcss-progressive-custom-properties/-/postcss-progressive-custom-properties-4.2.1.tgz", @@ -3100,6 +3062,32 @@ "postcss": "^8.4" } }, + "node_modules/@csstools/postcss-property-rule-prelude-list": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@csstools/postcss-property-rule-prelude-list/-/postcss-property-rule-prelude-list-1.0.0.tgz", + "integrity": "sha512-IxuQjUXq19fobgmSSvUDO7fVwijDJaZMvWQugxfEUxmjBeDCVaDuMpsZ31MsTm5xbnhA+ElDi0+rQ7sQQGisFA==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/csstools" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + } + ], + "license": "MIT-0", + "dependencies": { + "@csstools/css-parser-algorithms": "^3.0.5", + "@csstools/css-tokenizer": "^3.0.4" + }, + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "postcss": "^8.4" + } + }, "node_modules/@csstools/postcss-random-function": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/@csstools/postcss-random-function/-/postcss-random-function-2.0.1.tgz", @@ -3182,9 +3170,9 @@ } }, "node_modules/@csstools/postcss-scope-pseudo-class/node_modules/postcss-selector-parser": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.0.tgz", - "integrity": "sha512-8sLjZwK0R+JlxlYcTuVnyT2v+htpdrjDOKuMcOVdYjt52Lh8hWRYpxBPoKx/Zg+bcjc3wx6fmQevMmUztS/ccA==", + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.1.tgz", + "integrity": "sha512-orRsuYpJVw8LdAwqqLykBj9ecS5/cRHlI5+nvTo8LcCKmzDmqVORXtOIYEEQuL9D4BxtA1lm5isAqzQZCoQ6Eg==", "license": "MIT", "dependencies": { "cssesc": "^3.0.0", @@ -3248,10 +3236,10 @@ "postcss": "^8.4" } }, - "node_modules/@csstools/postcss-text-decoration-shorthand": { - "version": "4.0.3", - "resolved": "https://registry.npmjs.org/@csstools/postcss-text-decoration-shorthand/-/postcss-text-decoration-shorthand-4.0.3.tgz", - "integrity": "sha512-KSkGgZfx0kQjRIYnpsD7X2Om9BUXX/Kii77VBifQW9Ih929hK0KNjVngHDH0bFB9GmfWcR9vJYJJRvw/NQjkrA==", + "node_modules/@csstools/postcss-syntax-descriptor-syntax-production": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@csstools/postcss-syntax-descriptor-syntax-production/-/postcss-syntax-descriptor-syntax-production-1.0.1.tgz", + "integrity": "sha512-GneqQWefjM//f4hJ/Kbox0C6f2T7+pi4/fqTqOFGTL3EjnvOReTqO1qUQ30CaUjkwjYq9qZ41hzarrAxCc4gow==", "funding": [ { "type": "github", @@ -3264,8 +3252,7 @@ ], "license": "MIT-0", "dependencies": { - "@csstools/color-helpers": "^5.1.0", - "postcss-value-parser": "^4.2.0" + "@csstools/css-tokenizer": "^3.0.4" }, "engines": { "node": ">=18" @@ -3274,10 +3261,10 @@ "postcss": "^8.4" } }, - "node_modules/@csstools/postcss-trigonometric-functions": { - "version": "4.0.9", - "resolved": "https://registry.npmjs.org/@csstools/postcss-trigonometric-functions/-/postcss-trigonometric-functions-4.0.9.tgz", - "integrity": "sha512-Hnh5zJUdpNrJqK9v1/E3BbrQhaDTj5YiX7P61TOvUhoDHnUmsNNxcDAgkQ32RrcWx9GVUvfUNPcUkn8R3vIX6A==", + "node_modules/@csstools/postcss-system-ui-font-family": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@csstools/postcss-system-ui-font-family/-/postcss-system-ui-font-family-1.0.0.tgz", + "integrity": "sha512-s3xdBvfWYfoPSBsikDXbuorcMG1nN1M6GdU0qBsGfcmNR0A/qhloQZpTxjA3Xsyrk1VJvwb2pOfiOT3at/DuIQ==", "funding": [ { "type": "github", @@ -3290,7 +3277,6 @@ ], "license": "MIT-0", "dependencies": { - "@csstools/css-calc": "^2.1.4", "@csstools/css-parser-algorithms": "^3.0.5", "@csstools/css-tokenizer": "^3.0.4" }, @@ -3301,10 +3287,10 @@ "postcss": "^8.4" } }, - "node_modules/@csstools/postcss-unset-value": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/@csstools/postcss-unset-value/-/postcss-unset-value-4.0.0.tgz", - "integrity": "sha512-cBz3tOCI5Fw6NIFEwU3RiwK6mn3nKegjpJuzCndoGq3BZPkUjnsq7uQmIeMNeMbMk7YD2MfKcgCpZwX5jyXqCA==", + "node_modules/@csstools/postcss-text-decoration-shorthand": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/@csstools/postcss-text-decoration-shorthand/-/postcss-text-decoration-shorthand-4.0.3.tgz", + "integrity": "sha512-KSkGgZfx0kQjRIYnpsD7X2Om9BUXX/Kii77VBifQW9Ih929hK0KNjVngHDH0bFB9GmfWcR9vJYJJRvw/NQjkrA==", "funding": [ { "type": "github", @@ -3316,6 +3302,10 @@ } ], "license": "MIT-0", + "dependencies": { + "@csstools/color-helpers": "^5.1.0", + "postcss-value-parser": "^4.2.0" + }, "engines": { "node": ">=18" }, @@ -3323,12 +3313,61 @@ "postcss": "^8.4" } }, - "node_modules/@csstools/utilities": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/@csstools/utilities/-/utilities-2.0.0.tgz", - "integrity": "sha512-5VdOr0Z71u+Yp3ozOx8T11N703wIFGVRgOWbOZMKgglPJsWA54MRIoMNVMa7shUToIhx5J8vX4sOZgD2XiihiQ==", - "funding": [ - { + "node_modules/@csstools/postcss-trigonometric-functions": { + "version": "4.0.9", + "resolved": "https://registry.npmjs.org/@csstools/postcss-trigonometric-functions/-/postcss-trigonometric-functions-4.0.9.tgz", + "integrity": "sha512-Hnh5zJUdpNrJqK9v1/E3BbrQhaDTj5YiX7P61TOvUhoDHnUmsNNxcDAgkQ32RrcWx9GVUvfUNPcUkn8R3vIX6A==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/csstools" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + } + ], + "license": "MIT-0", + "dependencies": { + "@csstools/css-calc": "^2.1.4", + "@csstools/css-parser-algorithms": "^3.0.5", + "@csstools/css-tokenizer": "^3.0.4" + }, + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "postcss": "^8.4" + } + }, + "node_modules/@csstools/postcss-unset-value": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/@csstools/postcss-unset-value/-/postcss-unset-value-4.0.0.tgz", + "integrity": "sha512-cBz3tOCI5Fw6NIFEwU3RiwK6mn3nKegjpJuzCndoGq3BZPkUjnsq7uQmIeMNeMbMk7YD2MfKcgCpZwX5jyXqCA==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/csstools" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + } + ], + "license": "MIT-0", + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "postcss": "^8.4" + } + }, + "node_modules/@csstools/utilities": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/@csstools/utilities/-/utilities-2.0.0.tgz", + "integrity": "sha512-5VdOr0Z71u+Yp3ozOx8T11N703wIFGVRgOWbOZMKgglPJsWA54MRIoMNVMa7shUToIhx5J8vX4sOZgD2XiihiQ==", + "funding": [ + { "type": "github", "url": "https://github.com/sponsors/csstools" }, @@ -3355,9 +3394,9 @@ } }, "node_modules/@docsearch/core": { - "version": "4.3.1", - "resolved": "https://registry.npmjs.org/@docsearch/core/-/core-4.3.1.tgz", - "integrity": "sha512-ktVbkePE+2h9RwqCUMbWXOoebFyDOxHqImAqfs+lC8yOU+XwEW4jgvHGJK079deTeHtdhUNj0PXHSnhJINvHzQ==", + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/@docsearch/core/-/core-4.6.0.tgz", + "integrity": "sha512-IqG3oSd529jVRQ4dWZQKwZwQLVd//bWJTz2HiL0LkiHrI4U/vLrBasKB7lwQB/69nBAcCgs3TmudxTZSLH/ZQg==", "license": "MIT", "peerDependencies": { "@types/react": ">= 16.8.0 < 20.0.0", @@ -3377,25 +3416,20 @@ } }, "node_modules/@docsearch/css": { - "version": "4.3.2", - "resolved": "https://registry.npmjs.org/@docsearch/css/-/css-4.3.2.tgz", - "integrity": "sha512-K3Yhay9MgkBjJJ0WEL5MxnACModX9xuNt3UlQQkDEDZJZ0+aeWKtOkxHNndMRkMBnHdYvQjxkm6mdlneOtU1IQ==", + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/@docsearch/css/-/css-4.6.0.tgz", + "integrity": "sha512-YlcAimkXclvqta47g47efzCM5CFxDwv2ClkDfEs/fC/Ak0OxPH2b3czwa4o8O1TRBf+ujFF2RiUwszz2fPVNJQ==", "license": "MIT" }, "node_modules/@docsearch/react": { - "version": "4.3.2", - "resolved": "https://registry.npmjs.org/@docsearch/react/-/react-4.3.2.tgz", - "integrity": "sha512-74SFD6WluwvgsOPqifYOviEEVwDxslxfhakTlra+JviaNcs7KK/rjsPj89kVEoQc9FUxRkAofaJnHIR7pb4TSQ==", + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/@docsearch/react/-/react-4.6.0.tgz", + "integrity": "sha512-j8H5B4ArGxBPBWvw3X0J0Rm/Pjv2JDa2rV5OE0DLTp5oiBCptIJ/YlNOhZxuzbO2nwge+o3Z52nJRi3hryK9cA==", "license": "MIT", "dependencies": { - "@ai-sdk/react": "^2.0.30", "@algolia/autocomplete-core": "1.19.2", - "@docsearch/core": "4.3.1", - "@docsearch/css": "4.3.2", - "ai": "^5.0.30", - "algoliasearch": "^5.28.0", - "marked": "^16.3.0", - "zod": "^4.1.8" + "@docsearch/core": "4.6.0", + "@docsearch/css": "4.6.0" }, "peerDependencies": { "@types/react": ">= 16.8.0 < 20.0.0", @@ -3492,6 +3526,7 @@ "resolved": "https://registry.npmjs.org/@docusaurus/core/-/core-3.9.2.tgz", "integrity": "sha512-HbjwKeC+pHUFBfLMNzuSjqFE/58+rLVKmOU3lxQrpsxLBOGosYco/Q0GduBb0/jEMRiyEqjNT/01rRdOMWq5pw==", "license": "MIT", + "peer": true, "dependencies": { "@docusaurus/babel": "3.9.2", "@docusaurus/bundler": "3.9.2", @@ -3673,6 +3708,7 @@ "resolved": "https://registry.npmjs.org/@docusaurus/plugin-content-docs/-/plugin-content-docs-3.9.2.tgz", "integrity": "sha512-C5wZsGuKTY8jEYsqdxhhFOe1ZDjH0uIYJ9T/jebHwkyxqnr4wW0jTkB72OMqNjsoQRcb0JN3PcSeTwFlVgzCZg==", "license": "MIT", + "peer": true, "dependencies": { "@docusaurus/core": "3.9.2", "@docusaurus/logger": "3.9.2", @@ -4165,19 +4201,14 @@ "license": "MIT" }, "node_modules/@iconify/utils": { - "version": "2.3.0", - "resolved": "https://registry.npmjs.org/@iconify/utils/-/utils-2.3.0.tgz", - "integrity": "sha512-GmQ78prtwYW6EtzXRU1rY+KwOKfz32PD7iJh6Iyqw68GiKuoZ2A6pRtzWONz5VQJbp50mEjXh/7NkumtrAgRKA==", + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/@iconify/utils/-/utils-3.1.0.tgz", + "integrity": "sha512-Zlzem1ZXhI1iHeeERabLNzBHdOa4VhQbqAcOQaMKuTuyZCpwKbC2R4Dd0Zo3g9EAc+Y4fiarO8HIHRAth7+skw==", "license": "MIT", "dependencies": { - "@antfu/install-pkg": "^1.0.0", - "@antfu/utils": "^8.1.0", + "@antfu/install-pkg": "^1.1.0", "@iconify/types": "^2.0.0", - "debug": "^4.4.0", - "globals": "^15.14.0", - "kolorist": "^1.8.0", - "local-pkg": "^1.0.0", - "mlly": "^1.7.4" + "mlly": "^1.8.0" } }, "node_modules/@jest/schemas": { @@ -4255,9 +4286,9 @@ "license": "MIT" }, "node_modules/@jridgewell/trace-mapping": { - "version": "0.3.30", - "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.30.tgz", - "integrity": "sha512-GQ7Nw5G2lTu/BtHTKfXhKHok2WGetd4XYcVKGx00SjAk8GMwgJM3zr6zORiPGuOE+/vkc90KtTosSSvaCjKb2Q==", + "version": "0.3.31", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz", + "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==", "license": "MIT", "dependencies": { "@jridgewell/resolve-uri": "^3.1.0", @@ -4281,9 +4312,9 @@ } }, "node_modules/@jsonjoy.com/buffers": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/@jsonjoy.com/buffers/-/buffers-1.0.0.tgz", - "integrity": "sha512-NDigYR3PHqCnQLXYyoLbnEdzMMvzeiCWo1KOut7Q0CoIqg9tUAPKJ1iq/2nFhc5kZtexzutNY0LFjdwWL3Dw3Q==", + "version": "17.67.0", + "resolved": "https://registry.npmjs.org/@jsonjoy.com/buffers/-/buffers-17.67.0.tgz", + "integrity": "sha512-tfExRpYxBvi32vPs9ZHaTjSP4fHAfzSmcahOfNxtvGHcyJel+aibkPlGeBB+7AoC6hL7lXIE++8okecBxx7lcw==", "license": "Apache-2.0", "engines": { "node": ">=10.0" @@ -4312,18 +4343,14 @@ "tslib": "2" } }, - "node_modules/@jsonjoy.com/json-pack": { - "version": "1.14.0", - "resolved": "https://registry.npmjs.org/@jsonjoy.com/json-pack/-/json-pack-1.14.0.tgz", - "integrity": "sha512-LpWbYgVnKzphN5S6uss4M25jJ/9+m6q6UJoeN6zTkK4xAGhKsiBRPVeF7OYMWonn5repMQbE5vieRXcMUrKDKw==", + "node_modules/@jsonjoy.com/fs-core": { + "version": "4.56.11", + "resolved": "https://registry.npmjs.org/@jsonjoy.com/fs-core/-/fs-core-4.56.11.tgz", + "integrity": "sha512-wThHjzUp01ImIjfCwhs+UnFkeGPFAymwLEkOtenHewaKe2pTP12p6r1UuwikA9NEvNf9Vlck92r8fb8n/MWM5w==", "license": "Apache-2.0", "dependencies": { - "@jsonjoy.com/base64": "^1.1.2", - "@jsonjoy.com/buffers": "^1.0.0", - "@jsonjoy.com/codegen": "^1.0.0", - "@jsonjoy.com/json-pointer": "^1.0.1", - "@jsonjoy.com/util": "^1.9.0", - "hyperdyperid": "^1.2.0", + "@jsonjoy.com/fs-node-builtins": "4.56.11", + "@jsonjoy.com/fs-node-utils": "4.56.11", "thingies": "^2.5.0" }, "engines": { @@ -4337,14 +4364,16 @@ "tslib": "2" } }, - "node_modules/@jsonjoy.com/json-pointer": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/@jsonjoy.com/json-pointer/-/json-pointer-1.0.2.tgz", - "integrity": "sha512-Fsn6wM2zlDzY1U+v4Nc8bo3bVqgfNTGcn6dMgs6FjrEnt4ZCe60o6ByKRjOGlI2gow0aE/Q41QOigdTqkyK5fg==", + "node_modules/@jsonjoy.com/fs-fsa": { + "version": "4.56.11", + "resolved": "https://registry.npmjs.org/@jsonjoy.com/fs-fsa/-/fs-fsa-4.56.11.tgz", + "integrity": "sha512-ZYlF3XbMayyp97xEN8ZvYutU99PCHjM64mMZvnCseXkCJXJDVLAwlF8Q/7q/xiWQRsv3pQBj1WXHd9eEyYcaCQ==", "license": "Apache-2.0", "dependencies": { - "@jsonjoy.com/codegen": "^1.0.0", - "@jsonjoy.com/util": "^1.9.0" + "@jsonjoy.com/fs-core": "4.56.11", + "@jsonjoy.com/fs-node-builtins": "4.56.11", + "@jsonjoy.com/fs-node-utils": "4.56.11", + "thingies": "^2.5.0" }, "engines": { "node": ">=10.0" @@ -4357,14 +4386,19 @@ "tslib": "2" } }, - "node_modules/@jsonjoy.com/util": { - "version": "1.9.0", - "resolved": "https://registry.npmjs.org/@jsonjoy.com/util/-/util-1.9.0.tgz", - "integrity": "sha512-pLuQo+VPRnN8hfPqUTLTHk126wuYdXVxE6aDmjSeV4NCAgyxWbiOIeNJVtID3h1Vzpoi9m4jXezf73I6LgabgQ==", + "node_modules/@jsonjoy.com/fs-node": { + "version": "4.56.11", + "resolved": "https://registry.npmjs.org/@jsonjoy.com/fs-node/-/fs-node-4.56.11.tgz", + "integrity": "sha512-D65YrnP6wRuZyEWoSFnBJSr5zARVpVBGctnhie4rCsMuGXNzX7IHKaOt85/Aj7SSoG1N2+/xlNjWmkLvZ2H3Tg==", "license": "Apache-2.0", "dependencies": { - "@jsonjoy.com/buffers": "^1.0.0", - "@jsonjoy.com/codegen": "^1.0.0" + "@jsonjoy.com/fs-core": "4.56.11", + "@jsonjoy.com/fs-node-builtins": "4.56.11", + "@jsonjoy.com/fs-node-utils": "4.56.11", + "@jsonjoy.com/fs-print": "4.56.11", + "@jsonjoy.com/fs-snapshot": "4.56.11", + "glob-to-regex.js": "^1.0.0", + "thingies": "^2.5.0" }, "engines": { "node": ">=10.0" @@ -4377,150 +4411,595 @@ "tslib": "2" } }, - "node_modules/@leichtgewicht/ip-codec": { - "version": "2.0.5", - "resolved": "https://registry.npmjs.org/@leichtgewicht/ip-codec/-/ip-codec-2.0.5.tgz", - "integrity": "sha512-Vo+PSpZG2/fmgmiNzYK9qWRh8h/CHrwD0mo1h1DzL4yzHNSfWYujGTYsWGreD000gcgmZ7K4Ys6Tx9TxtsKdDw==", - "license": "MIT" - }, - "node_modules/@mdx-js/mdx": { - "version": "3.1.1", - "resolved": "https://registry.npmjs.org/@mdx-js/mdx/-/mdx-3.1.1.tgz", - "integrity": "sha512-f6ZO2ifpwAQIpzGWaBQT2TXxPv6z3RBzQKpVftEWN78Vl/YweF1uwussDx8ECAXVtr3Rs89fKyG9YlzUs9DyGQ==", - "license": "MIT", - "dependencies": { - "@types/estree": "^1.0.0", - "@types/estree-jsx": "^1.0.0", - "@types/hast": "^3.0.0", - "@types/mdx": "^2.0.0", - "acorn": "^8.0.0", - "collapse-white-space": "^2.0.0", - "devlop": "^1.0.0", - "estree-util-is-identifier-name": "^3.0.0", - "estree-util-scope": "^1.0.0", - "estree-walker": "^3.0.0", - "hast-util-to-jsx-runtime": "^2.0.0", - "markdown-extensions": "^2.0.0", - "recma-build-jsx": "^1.0.0", - "recma-jsx": "^1.0.0", - "recma-stringify": "^1.0.0", - "rehype-recma": "^1.0.0", - "remark-mdx": "^3.0.0", - "remark-parse": "^11.0.0", - "remark-rehype": "^11.0.0", - "source-map": "^0.7.0", - "unified": "^11.0.0", - "unist-util-position-from-estree": "^2.0.0", - "unist-util-stringify-position": "^4.0.0", - "unist-util-visit": "^5.0.0", - "vfile": "^6.0.0" + "node_modules/@jsonjoy.com/fs-node-builtins": { + "version": "4.56.11", + "resolved": "https://registry.npmjs.org/@jsonjoy.com/fs-node-builtins/-/fs-node-builtins-4.56.11.tgz", + "integrity": "sha512-CNmt3a0zMCIhniFLXtzPWuUxXFU+U+2VyQiIrgt/rRVeEJNrMQUABaRbVxR0Ouw1LyR9RjaEkPM6nYpED+y43A==", + "license": "Apache-2.0", + "engines": { + "node": ">=10.0" }, "funding": { - "type": "opencollective", - "url": "https://opencollective.com/unified" + "type": "github", + "url": "https://github.com/sponsors/streamich" + }, + "peerDependencies": { + "tslib": "2" } }, - "node_modules/@mdx-js/react": { - "version": "3.1.1", - "resolved": "https://registry.npmjs.org/@mdx-js/react/-/react-3.1.1.tgz", - "integrity": "sha512-f++rKLQgUVYDAtECQ6fn/is15GkEH9+nZPM3MS0RcxVqoTfawHvDlSCH7JbMhAM6uJ32v3eXLvLmLvjGu7PTQw==", - "license": "MIT", + "node_modules/@jsonjoy.com/fs-node-to-fsa": { + "version": "4.56.11", + "resolved": "https://registry.npmjs.org/@jsonjoy.com/fs-node-to-fsa/-/fs-node-to-fsa-4.56.11.tgz", + "integrity": "sha512-5OzGdvJDgZVo+xXWEYo72u81zpOWlxlbG4d4nL+hSiW+LKlua/dldNgPrpWxtvhgyntmdFQad2UTxFyGjJAGhA==", + "license": "Apache-2.0", "dependencies": { - "@types/mdx": "^2.0.0" + "@jsonjoy.com/fs-fsa": "4.56.11", + "@jsonjoy.com/fs-node-builtins": "4.56.11", + "@jsonjoy.com/fs-node-utils": "4.56.11" + }, + "engines": { + "node": ">=10.0" }, "funding": { - "type": "opencollective", - "url": "https://opencollective.com/unified" + "type": "github", + "url": "https://github.com/sponsors/streamich" }, "peerDependencies": { - "@types/react": ">=16", - "react": ">=16" - } - }, - "node_modules/@mermaid-js/parser": { - "version": "0.6.2", - "resolved": "https://registry.npmjs.org/@mermaid-js/parser/-/parser-0.6.2.tgz", - "integrity": "sha512-+PO02uGF6L6Cs0Bw8RpGhikVvMWEysfAyl27qTlroUB8jSWr1lL0Sf6zi78ZxlSnmgSY2AMMKVgghnN9jTtwkQ==", - "license": "MIT", - "dependencies": { - "langium": "3.3.1" + "tslib": "2" } }, - "node_modules/@nodelib/fs.scandir": { - "version": "2.1.5", - "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", - "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==", - "license": "MIT", + "node_modules/@jsonjoy.com/fs-node-utils": { + "version": "4.56.11", + "resolved": "https://registry.npmjs.org/@jsonjoy.com/fs-node-utils/-/fs-node-utils-4.56.11.tgz", + "integrity": "sha512-JADOZFDA3wRfsuxkT0+MYc4F9hJO2PYDaY66kRTG6NqGX3+bqmKu66YFYAbII/tEmQWPZeHoClUB23rtQM9UPg==", + "license": "Apache-2.0", "dependencies": { - "@nodelib/fs.stat": "2.0.5", - "run-parallel": "^1.1.9" + "@jsonjoy.com/fs-node-builtins": "4.56.11" }, "engines": { - "node": ">= 8" + "node": ">=10.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/streamich" + }, + "peerDependencies": { + "tslib": "2" } }, - "node_modules/@nodelib/fs.stat": { - "version": "2.0.5", - "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz", - "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==", - "license": "MIT", + "node_modules/@jsonjoy.com/fs-print": { + "version": "4.56.11", + "resolved": "https://registry.npmjs.org/@jsonjoy.com/fs-print/-/fs-print-4.56.11.tgz", + "integrity": "sha512-rnaKRgCRIn8JGTjxhS0JPE38YM3Pj/H7SW4/tglhIPbfKEkky7dpPayNKV2qy25SZSL15oFVgH/62dMZ/z7cyA==", + "license": "Apache-2.0", + "dependencies": { + "@jsonjoy.com/fs-node-utils": "4.56.11", + "tree-dump": "^1.1.0" + }, "engines": { - "node": ">= 8" + "node": ">=10.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/streamich" + }, + "peerDependencies": { + "tslib": "2" } }, - "node_modules/@nodelib/fs.walk": { - "version": "1.2.8", - "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz", - "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==", - "license": "MIT", + "node_modules/@jsonjoy.com/fs-snapshot": { + "version": "4.56.11", + "resolved": "https://registry.npmjs.org/@jsonjoy.com/fs-snapshot/-/fs-snapshot-4.56.11.tgz", + "integrity": "sha512-IIldPX+cIRQuUol9fQzSS3hqyECxVpYMJQMqdU3dCKZFRzEl1rkIkw4P6y7Oh493sI7YdxZlKr/yWdzEWZ1wGQ==", + "license": "Apache-2.0", "dependencies": { - "@nodelib/fs.scandir": "2.1.5", - "fastq": "^1.6.0" + "@jsonjoy.com/buffers": "^17.65.0", + "@jsonjoy.com/fs-node-utils": "4.56.11", + "@jsonjoy.com/json-pack": "^17.65.0", + "@jsonjoy.com/util": "^17.65.0" }, "engines": { - "node": ">= 8" + "node": ">=10.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/streamich" + }, + "peerDependencies": { + "tslib": "2" } }, - "node_modules/@opentelemetry/api": { - "version": "1.9.0", - "resolved": "https://registry.npmjs.org/@opentelemetry/api/-/api-1.9.0.tgz", - "integrity": "sha512-3giAOQvZiH5F9bMlMiv8+GSPMeqg0dbaeo58/0SlA9sxSqZhnUtxzX9/2FzyhS9sWQf5S0GJE0AKBrFqjpeYcg==", + "node_modules/@jsonjoy.com/fs-snapshot/node_modules/@jsonjoy.com/base64": { + "version": "17.67.0", + "resolved": "https://registry.npmjs.org/@jsonjoy.com/base64/-/base64-17.67.0.tgz", + "integrity": "sha512-5SEsJGsm15aP8TQGkDfJvz9axgPwAEm98S5DxOuYe8e1EbfajcDmgeXXzccEjh+mLnjqEKrkBdjHWS5vFNwDdw==", "license": "Apache-2.0", "engines": { - "node": ">=8.0.0" + "node": ">=10.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/streamich" + }, + "peerDependencies": { + "tslib": "2" } }, - "node_modules/@pnpm/config.env-replace": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/@pnpm/config.env-replace/-/config.env-replace-1.1.0.tgz", - "integrity": "sha512-htyl8TWnKL7K/ESFa1oW2UB5lVDxuF5DpM7tBi6Hu2LNL3mWkIzNLG6N4zoCUP1lCKNxWy/3iu8mS8MvToGd6w==", - "license": "MIT", + "node_modules/@jsonjoy.com/fs-snapshot/node_modules/@jsonjoy.com/codegen": { + "version": "17.67.0", + "resolved": "https://registry.npmjs.org/@jsonjoy.com/codegen/-/codegen-17.67.0.tgz", + "integrity": "sha512-idnkUplROpdBOV0HMcwhsCUS5TRUi9poagdGs70A6S4ux9+/aPuKbh8+UYRTLYQHtXvAdNfQWXDqZEx5k4Dj2Q==", + "license": "Apache-2.0", "engines": { - "node": ">=12.22.0" + "node": ">=10.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/streamich" + }, + "peerDependencies": { + "tslib": "2" } }, - "node_modules/@pnpm/network.ca-file": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/@pnpm/network.ca-file/-/network.ca-file-1.0.2.tgz", - "integrity": "sha512-YcPQ8a0jwYU9bTdJDpXjMi7Brhkr1mXsXrUJvjqM2mQDgkRiz8jFaQGOdaLxgjtUfQgZhKy/O3cG/YwmgKaxLA==", - "license": "MIT", + "node_modules/@jsonjoy.com/fs-snapshot/node_modules/@jsonjoy.com/json-pack": { + "version": "17.67.0", + "resolved": "https://registry.npmjs.org/@jsonjoy.com/json-pack/-/json-pack-17.67.0.tgz", + "integrity": "sha512-t0ejURcGaZsn1ClbJ/3kFqSOjlryd92eQY465IYrezsXmPcfHPE/av4twRSxf6WE+TkZgLY+71vCZbiIiFKA/w==", + "license": "Apache-2.0", "dependencies": { - "graceful-fs": "4.2.10" + "@jsonjoy.com/base64": "17.67.0", + "@jsonjoy.com/buffers": "17.67.0", + "@jsonjoy.com/codegen": "17.67.0", + "@jsonjoy.com/json-pointer": "17.67.0", + "@jsonjoy.com/util": "17.67.0", + "hyperdyperid": "^1.2.0", + "thingies": "^2.5.0", + "tree-dump": "^1.1.0" }, "engines": { - "node": ">=12.22.0" + "node": ">=10.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/streamich" + }, + "peerDependencies": { + "tslib": "2" } }, - "node_modules/@pnpm/network.ca-file/node_modules/graceful-fs": { - "version": "4.2.10", - "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.10.tgz", - "integrity": "sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA==", - "license": "ISC" - }, - "node_modules/@pnpm/npm-conf": { - "version": "2.3.1", - "resolved": "https://registry.npmjs.org/@pnpm/npm-conf/-/npm-conf-2.3.1.tgz", - "integrity": "sha512-c83qWb22rNRuB0UaVCI0uRPNRr8Z0FWnEIvT47jiHAmOIUHbBOg5XvV7pM5x+rKn9HRpjxquDbXYSXr3fAKFcw==", + "node_modules/@jsonjoy.com/fs-snapshot/node_modules/@jsonjoy.com/json-pointer": { + "version": "17.67.0", + "resolved": "https://registry.npmjs.org/@jsonjoy.com/json-pointer/-/json-pointer-17.67.0.tgz", + "integrity": "sha512-+iqOFInH+QZGmSuaybBUNdh7yvNrXvqR+h3wjXm0N/3JK1EyyFAeGJvqnmQL61d1ARLlk/wJdFKSL+LHJ1eaUA==", + "license": "Apache-2.0", + "dependencies": { + "@jsonjoy.com/util": "17.67.0" + }, + "engines": { + "node": ">=10.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/streamich" + }, + "peerDependencies": { + "tslib": "2" + } + }, + "node_modules/@jsonjoy.com/fs-snapshot/node_modules/@jsonjoy.com/util": { + "version": "17.67.0", + "resolved": "https://registry.npmjs.org/@jsonjoy.com/util/-/util-17.67.0.tgz", + "integrity": "sha512-6+8xBaz1rLSohlGh68D1pdw3AwDi9xydm8QNlAFkvnavCJYSze+pxoW2VKP8p308jtlMRLs5NTHfPlZLd4w7ew==", + "license": "Apache-2.0", + "dependencies": { + "@jsonjoy.com/buffers": "17.67.0", + "@jsonjoy.com/codegen": "17.67.0" + }, + "engines": { + "node": ">=10.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/streamich" + }, + "peerDependencies": { + "tslib": "2" + } + }, + "node_modules/@jsonjoy.com/json-pack": { + "version": "1.21.0", + "resolved": "https://registry.npmjs.org/@jsonjoy.com/json-pack/-/json-pack-1.21.0.tgz", + "integrity": "sha512-+AKG+R2cfZMShzrF2uQw34v3zbeDYUqnQ+jg7ORic3BGtfw9p/+N6RJbq/kkV8JmYZaINknaEQ2m0/f693ZPpg==", + "license": "Apache-2.0", + "dependencies": { + "@jsonjoy.com/base64": "^1.1.2", + "@jsonjoy.com/buffers": "^1.2.0", + "@jsonjoy.com/codegen": "^1.0.0", + "@jsonjoy.com/json-pointer": "^1.0.2", + "@jsonjoy.com/util": "^1.9.0", + "hyperdyperid": "^1.2.0", + "thingies": "^2.5.0", + "tree-dump": "^1.1.0" + }, + "engines": { + "node": ">=10.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/streamich" + }, + "peerDependencies": { + "tslib": "2" + } + }, + "node_modules/@jsonjoy.com/json-pack/node_modules/@jsonjoy.com/buffers": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/@jsonjoy.com/buffers/-/buffers-1.2.1.tgz", + "integrity": "sha512-12cdlDwX4RUM3QxmUbVJWqZ/mrK6dFQH4Zxq6+r1YXKXYBNgZXndx2qbCJwh3+WWkCSn67IjnlG3XYTvmvYtgA==", + "license": "Apache-2.0", + "engines": { + "node": ">=10.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/streamich" + }, + "peerDependencies": { + "tslib": "2" + } + }, + "node_modules/@jsonjoy.com/json-pointer": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/@jsonjoy.com/json-pointer/-/json-pointer-1.0.2.tgz", + "integrity": "sha512-Fsn6wM2zlDzY1U+v4Nc8bo3bVqgfNTGcn6dMgs6FjrEnt4ZCe60o6ByKRjOGlI2gow0aE/Q41QOigdTqkyK5fg==", + "license": "Apache-2.0", + "dependencies": { + "@jsonjoy.com/codegen": "^1.0.0", + "@jsonjoy.com/util": "^1.9.0" + }, + "engines": { + "node": ">=10.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/streamich" + }, + "peerDependencies": { + "tslib": "2" + } + }, + "node_modules/@jsonjoy.com/util": { + "version": "1.9.0", + "resolved": "https://registry.npmjs.org/@jsonjoy.com/util/-/util-1.9.0.tgz", + "integrity": "sha512-pLuQo+VPRnN8hfPqUTLTHk126wuYdXVxE6aDmjSeV4NCAgyxWbiOIeNJVtID3h1Vzpoi9m4jXezf73I6LgabgQ==", + "license": "Apache-2.0", + "dependencies": { + "@jsonjoy.com/buffers": "^1.0.0", + "@jsonjoy.com/codegen": "^1.0.0" + }, + "engines": { + "node": ">=10.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/streamich" + }, + "peerDependencies": { + "tslib": "2" + } + }, + "node_modules/@jsonjoy.com/util/node_modules/@jsonjoy.com/buffers": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/@jsonjoy.com/buffers/-/buffers-1.2.1.tgz", + "integrity": "sha512-12cdlDwX4RUM3QxmUbVJWqZ/mrK6dFQH4Zxq6+r1YXKXYBNgZXndx2qbCJwh3+WWkCSn67IjnlG3XYTvmvYtgA==", + "license": "Apache-2.0", + "engines": { + "node": ">=10.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/streamich" + }, + "peerDependencies": { + "tslib": "2" + } + }, + "node_modules/@leichtgewicht/ip-codec": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@leichtgewicht/ip-codec/-/ip-codec-2.0.5.tgz", + "integrity": "sha512-Vo+PSpZG2/fmgmiNzYK9qWRh8h/CHrwD0mo1h1DzL4yzHNSfWYujGTYsWGreD000gcgmZ7K4Ys6Tx9TxtsKdDw==", + "license": "MIT" + }, + "node_modules/@mdx-js/mdx": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/@mdx-js/mdx/-/mdx-3.1.1.tgz", + "integrity": "sha512-f6ZO2ifpwAQIpzGWaBQT2TXxPv6z3RBzQKpVftEWN78Vl/YweF1uwussDx8ECAXVtr3Rs89fKyG9YlzUs9DyGQ==", + "license": "MIT", + "dependencies": { + "@types/estree": "^1.0.0", + "@types/estree-jsx": "^1.0.0", + "@types/hast": "^3.0.0", + "@types/mdx": "^2.0.0", + "acorn": "^8.0.0", + "collapse-white-space": "^2.0.0", + "devlop": "^1.0.0", + "estree-util-is-identifier-name": "^3.0.0", + "estree-util-scope": "^1.0.0", + "estree-walker": "^3.0.0", + "hast-util-to-jsx-runtime": "^2.0.0", + "markdown-extensions": "^2.0.0", + "recma-build-jsx": "^1.0.0", + "recma-jsx": "^1.0.0", + "recma-stringify": "^1.0.0", + "rehype-recma": "^1.0.0", + "remark-mdx": "^3.0.0", + "remark-parse": "^11.0.0", + "remark-rehype": "^11.0.0", + "source-map": "^0.7.0", + "unified": "^11.0.0", + "unist-util-position-from-estree": "^2.0.0", + "unist-util-stringify-position": "^4.0.0", + "unist-util-visit": "^5.0.0", + "vfile": "^6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/@mdx-js/react": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/@mdx-js/react/-/react-3.1.1.tgz", + "integrity": "sha512-f++rKLQgUVYDAtECQ6fn/is15GkEH9+nZPM3MS0RcxVqoTfawHvDlSCH7JbMhAM6uJ32v3eXLvLmLvjGu7PTQw==", + "license": "MIT", + "peer": true, + "dependencies": { + "@types/mdx": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + }, + "peerDependencies": { + "@types/react": ">=16", + "react": ">=16" + } + }, + "node_modules/@mermaid-js/parser": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@mermaid-js/parser/-/parser-1.0.0.tgz", + "integrity": "sha512-vvK0Hi/VWndxoh03Mmz6wa1KDriSPjS2XMZL/1l19HFwygiObEEoEwSDxOqyLzzAI6J2PU3261JjTMTO7x+BPw==", + "license": "MIT", + "dependencies": { + "langium": "^4.0.0" + } + }, + "node_modules/@noble/hashes": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.4.0.tgz", + "integrity": "sha512-V1JJ1WTRUqHHrOSh597hURcMqVKVGL/ea3kv0gSnEdsEZ0/+VyPghM1lMNGc00z7CIQorSvbKpuJkxvuHbvdbg==", + "license": "MIT", + "engines": { + "node": ">= 16" + }, + "funding": { + "url": "https://paulmillr.com/funding/" + } + }, + "node_modules/@nodelib/fs.scandir": { + "version": "2.1.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", + "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==", + "license": "MIT", + "dependencies": { + "@nodelib/fs.stat": "2.0.5", + "run-parallel": "^1.1.9" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@nodelib/fs.stat": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz", + "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==", + "license": "MIT", + "engines": { + "node": ">= 8" + } + }, + "node_modules/@nodelib/fs.walk": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz", + "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==", + "license": "MIT", + "dependencies": { + "@nodelib/fs.scandir": "2.1.5", + "fastq": "^1.6.0" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@peculiar/asn1-cms": { + "version": "2.6.1", + "resolved": "https://registry.npmjs.org/@peculiar/asn1-cms/-/asn1-cms-2.6.1.tgz", + "integrity": "sha512-vdG4fBF6Lkirkcl53q6eOdn3XYKt+kJTG59edgRZORlg/3atWWEReRCx5rYE1ZzTTX6vLK5zDMjHh7vbrcXGtw==", + "license": "MIT", + "dependencies": { + "@peculiar/asn1-schema": "^2.6.0", + "@peculiar/asn1-x509": "^2.6.1", + "@peculiar/asn1-x509-attr": "^2.6.1", + "asn1js": "^3.0.6", + "tslib": "^2.8.1" + } + }, + "node_modules/@peculiar/asn1-csr": { + "version": "2.6.1", + "resolved": "https://registry.npmjs.org/@peculiar/asn1-csr/-/asn1-csr-2.6.1.tgz", + "integrity": "sha512-WRWnKfIocHyzFYQTka8O/tXCiBquAPSrRjXbOkHbO4qdmS6loffCEGs+rby6WxxGdJCuunnhS2duHURhjyio6w==", + "license": "MIT", + "dependencies": { + "@peculiar/asn1-schema": "^2.6.0", + "@peculiar/asn1-x509": "^2.6.1", + "asn1js": "^3.0.6", + "tslib": "^2.8.1" + } + }, + "node_modules/@peculiar/asn1-ecc": { + "version": "2.6.1", + "resolved": "https://registry.npmjs.org/@peculiar/asn1-ecc/-/asn1-ecc-2.6.1.tgz", + "integrity": "sha512-+Vqw8WFxrtDIN5ehUdvlN2m73exS2JVG0UAyfVB31gIfor3zWEAQPD+K9ydCxaj3MLen9k0JhKpu9LqviuCE1g==", + "license": "MIT", + "dependencies": { + "@peculiar/asn1-schema": "^2.6.0", + "@peculiar/asn1-x509": "^2.6.1", + "asn1js": "^3.0.6", + "tslib": "^2.8.1" + } + }, + "node_modules/@peculiar/asn1-pfx": { + "version": "2.6.1", + "resolved": "https://registry.npmjs.org/@peculiar/asn1-pfx/-/asn1-pfx-2.6.1.tgz", + "integrity": "sha512-nB5jVQy3MAAWvq0KY0R2JUZG8bO/bTLpnwyOzXyEh/e54ynGTatAR+csOnXkkVD9AFZ2uL8Z7EV918+qB1qDvw==", + "license": "MIT", + "dependencies": { + "@peculiar/asn1-cms": "^2.6.1", + "@peculiar/asn1-pkcs8": "^2.6.1", + "@peculiar/asn1-rsa": "^2.6.1", + "@peculiar/asn1-schema": "^2.6.0", + "asn1js": "^3.0.6", + "tslib": "^2.8.1" + } + }, + "node_modules/@peculiar/asn1-pkcs8": { + "version": "2.6.1", + "resolved": "https://registry.npmjs.org/@peculiar/asn1-pkcs8/-/asn1-pkcs8-2.6.1.tgz", + "integrity": "sha512-JB5iQ9Izn5yGMw3ZG4Nw3Xn/hb/G38GYF3lf7WmJb8JZUydhVGEjK/ZlFSWhnlB7K/4oqEs8HnfFIKklhR58Tw==", + "license": "MIT", + "dependencies": { + "@peculiar/asn1-schema": "^2.6.0", + "@peculiar/asn1-x509": "^2.6.1", + "asn1js": "^3.0.6", + "tslib": "^2.8.1" + } + }, + "node_modules/@peculiar/asn1-pkcs9": { + "version": "2.6.1", + "resolved": "https://registry.npmjs.org/@peculiar/asn1-pkcs9/-/asn1-pkcs9-2.6.1.tgz", + "integrity": "sha512-5EV8nZoMSxeWmcxWmmcolg22ojZRgJg+Y9MX2fnE2bGRo5KQLqV5IL9kdSQDZxlHz95tHvIq9F//bvL1OeNILw==", + "license": "MIT", + "dependencies": { + "@peculiar/asn1-cms": "^2.6.1", + "@peculiar/asn1-pfx": "^2.6.1", + "@peculiar/asn1-pkcs8": "^2.6.1", + "@peculiar/asn1-schema": "^2.6.0", + "@peculiar/asn1-x509": "^2.6.1", + "@peculiar/asn1-x509-attr": "^2.6.1", + "asn1js": "^3.0.6", + "tslib": "^2.8.1" + } + }, + "node_modules/@peculiar/asn1-rsa": { + "version": "2.6.1", + "resolved": "https://registry.npmjs.org/@peculiar/asn1-rsa/-/asn1-rsa-2.6.1.tgz", + "integrity": "sha512-1nVMEh46SElUt5CB3RUTV4EG/z7iYc7EoaDY5ECwganibQPkZ/Y2eMsTKB/LeyrUJ+W/tKoD9WUqIy8vB+CEdA==", + "license": "MIT", + "dependencies": { + "@peculiar/asn1-schema": "^2.6.0", + "@peculiar/asn1-x509": "^2.6.1", + "asn1js": "^3.0.6", + "tslib": "^2.8.1" + } + }, + "node_modules/@peculiar/asn1-schema": { + "version": "2.6.0", + "resolved": "https://registry.npmjs.org/@peculiar/asn1-schema/-/asn1-schema-2.6.0.tgz", + "integrity": "sha512-xNLYLBFTBKkCzEZIw842BxytQQATQv+lDTCEMZ8C196iJcJJMBUZxrhSTxLaohMyKK8QlzRNTRkUmanucnDSqg==", + "license": "MIT", + "dependencies": { + "asn1js": "^3.0.6", + "pvtsutils": "^1.3.6", + "tslib": "^2.8.1" + } + }, + "node_modules/@peculiar/asn1-x509": { + "version": "2.6.1", + "resolved": "https://registry.npmjs.org/@peculiar/asn1-x509/-/asn1-x509-2.6.1.tgz", + "integrity": "sha512-O9jT5F1A2+t3r7C4VT7LYGXqkGLK7Kj1xFpz7U0isPrubwU5PbDoyYtx6MiGst29yq7pXN5vZbQFKRCP+lLZlA==", + "license": "MIT", + "dependencies": { + "@peculiar/asn1-schema": "^2.6.0", + "asn1js": "^3.0.6", + "pvtsutils": "^1.3.6", + "tslib": "^2.8.1" + } + }, + "node_modules/@peculiar/asn1-x509-attr": { + "version": "2.6.1", + "resolved": "https://registry.npmjs.org/@peculiar/asn1-x509-attr/-/asn1-x509-attr-2.6.1.tgz", + "integrity": "sha512-tlW6cxoHwgcQghnJwv3YS+9OO1737zgPogZ+CgWRUK4roEwIPzRH4JEiG770xe5HX2ATfCpmX60gurfWIF9dcQ==", + "license": "MIT", + "dependencies": { + "@peculiar/asn1-schema": "^2.6.0", + "@peculiar/asn1-x509": "^2.6.1", + "asn1js": "^3.0.6", + "tslib": "^2.8.1" + } + }, + "node_modules/@peculiar/x509": { + "version": "1.14.3", + "resolved": "https://registry.npmjs.org/@peculiar/x509/-/x509-1.14.3.tgz", + "integrity": "sha512-C2Xj8FZ0uHWeCXXqX5B4/gVFQmtSkiuOolzAgutjTfseNOHT3pUjljDZsTSxXFGgio54bCzVFqmEOUrIVk8RDA==", + "license": "MIT", + "dependencies": { + "@peculiar/asn1-cms": "^2.6.0", + "@peculiar/asn1-csr": "^2.6.0", + "@peculiar/asn1-ecc": "^2.6.0", + "@peculiar/asn1-pkcs9": "^2.6.0", + "@peculiar/asn1-rsa": "^2.6.0", + "@peculiar/asn1-schema": "^2.6.0", + "@peculiar/asn1-x509": "^2.6.0", + "pvtsutils": "^1.3.6", + "reflect-metadata": "^0.2.2", + "tslib": "^2.8.1", + "tsyringe": "^4.10.0" + }, + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/@pnpm/config.env-replace": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@pnpm/config.env-replace/-/config.env-replace-1.1.0.tgz", + "integrity": "sha512-htyl8TWnKL7K/ESFa1oW2UB5lVDxuF5DpM7tBi6Hu2LNL3mWkIzNLG6N4zoCUP1lCKNxWy/3iu8mS8MvToGd6w==", + "license": "MIT", + "engines": { + "node": ">=12.22.0" + } + }, + "node_modules/@pnpm/network.ca-file": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/@pnpm/network.ca-file/-/network.ca-file-1.0.2.tgz", + "integrity": "sha512-YcPQ8a0jwYU9bTdJDpXjMi7Brhkr1mXsXrUJvjqM2mQDgkRiz8jFaQGOdaLxgjtUfQgZhKy/O3cG/YwmgKaxLA==", + "license": "MIT", + "dependencies": { + "graceful-fs": "4.2.10" + }, + "engines": { + "node": ">=12.22.0" + } + }, + "node_modules/@pnpm/network.ca-file/node_modules/graceful-fs": { + "version": "4.2.10", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.10.tgz", + "integrity": "sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA==", + "license": "ISC" + }, + "node_modules/@pnpm/npm-conf": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/@pnpm/npm-conf/-/npm-conf-3.0.2.tgz", + "integrity": "sha512-h104Kh26rR8tm+a3Qkc5S4VLYint3FE48as7+/5oCEcKR2idC/pF1G6AhIXKI+eHPJa/3J9i5z0Al47IeGHPkA==", "license": "MIT", "dependencies": { "@pnpm/config.env-replace": "^1.1.0", @@ -4569,9 +5048,9 @@ "license": "BSD-3-Clause" }, "node_modules/@sinclair/typebox": { - "version": "0.27.8", - "resolved": "https://registry.npmjs.org/@sinclair/typebox/-/typebox-0.27.8.tgz", - "integrity": "sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA==", + "version": "0.27.10", + "resolved": "https://registry.npmjs.org/@sinclair/typebox/-/typebox-0.27.10.tgz", + "integrity": "sha512-MTBk/3jGLNB2tVxv6uLlFh1iu64iYOQ2PbdOSK3NW8JZsmlaOh2q6sdtKowBhfw8QFLmYNzTW4/oK4uATIi6ZA==", "license": "MIT" }, "node_modules/@sindresorhus/is": { @@ -4597,12 +5076,6 @@ "micromark-util-symbol": "^1.0.1" } }, - "node_modules/@standard-schema/spec": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.0.0.tgz", - "integrity": "sha512-m2bOd0f2RT9k8QJx1JN85cZYyH1RqFBdlwtkSlf4tBDYLCiiZnv1fIIwacK6cqwXavOydf0NPToMQgpKq+dVlA==", - "license": "MIT" - }, "node_modules/@svgr/babel-plugin-add-jsx-attribute": { "version": "8.0.0", "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-add-jsx-attribute/-/babel-plugin-add-jsx-attribute-8.0.0.tgz", @@ -4762,6 +5235,7 @@ "resolved": "https://registry.npmjs.org/@svgr/core/-/core-8.1.0.tgz", "integrity": "sha512-8QqtOQT5ACVlmsvKOJNEaWmRPmcojMOzCz4Hs2BGG/toAp/K38LcsMRyLp349glq5AzJbCEeimEoxaX6v/fLrA==", "license": "MIT", + "peer": true, "dependencies": { "@babel/core": "^7.21.3", "@svgr/babel-preset": "8.1.0", @@ -4873,19 +5347,19 @@ } }, "node_modules/@tailwindcss/node": { - "version": "4.1.18", - "resolved": "https://registry.npmjs.org/@tailwindcss/node/-/node-4.1.18.tgz", - "integrity": "sha512-DoR7U1P7iYhw16qJ49fgXUlry1t4CpXeErJHnQ44JgTSKMaZUdf17cfn5mHchfJ4KRBZRFA/Coo+MUF5+gOaCQ==", + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/@tailwindcss/node/-/node-4.2.1.tgz", + "integrity": "sha512-jlx6sLk4EOwO6hHe1oCGm1Q4AN/s0rSrTTPBGPM0/RQ6Uylwq17FuU8IeJJKEjtc6K6O07zsvP+gDO6MMWo7pg==", "dev": true, "license": "MIT", "dependencies": { - "@jridgewell/remapping": "^2.3.4", - "enhanced-resolve": "^5.18.3", + "@jridgewell/remapping": "^2.3.5", + "enhanced-resolve": "^5.19.0", "jiti": "^2.6.1", - "lightningcss": "1.30.2", + "lightningcss": "1.31.1", "magic-string": "^0.30.21", "source-map-js": "^1.2.1", - "tailwindcss": "4.1.18" + "tailwindcss": "4.2.1" } }, "node_modules/@tailwindcss/node/node_modules/jiti": { @@ -4899,33 +5373,33 @@ } }, "node_modules/@tailwindcss/oxide": { - "version": "4.1.18", - "resolved": "https://registry.npmjs.org/@tailwindcss/oxide/-/oxide-4.1.18.tgz", - "integrity": "sha512-EgCR5tTS5bUSKQgzeMClT6iCY3ToqE1y+ZB0AKldj809QXk1Y+3jB0upOYZrn9aGIzPtUsP7sX4QQ4XtjBB95A==", + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide/-/oxide-4.2.1.tgz", + "integrity": "sha512-yv9jeEFWnjKCI6/T3Oq50yQEOqmpmpfzG1hcZsAOaXFQPfzWprWrlHSdGPEF3WQTi8zu8ohC9Mh9J470nT5pUw==", "dev": true, "license": "MIT", "engines": { - "node": ">= 10" + "node": ">= 20" }, "optionalDependencies": { - "@tailwindcss/oxide-android-arm64": "4.1.18", - "@tailwindcss/oxide-darwin-arm64": "4.1.18", - "@tailwindcss/oxide-darwin-x64": "4.1.18", - "@tailwindcss/oxide-freebsd-x64": "4.1.18", - "@tailwindcss/oxide-linux-arm-gnueabihf": "4.1.18", - "@tailwindcss/oxide-linux-arm64-gnu": "4.1.18", - "@tailwindcss/oxide-linux-arm64-musl": "4.1.18", - "@tailwindcss/oxide-linux-x64-gnu": "4.1.18", - "@tailwindcss/oxide-linux-x64-musl": "4.1.18", - "@tailwindcss/oxide-wasm32-wasi": "4.1.18", - "@tailwindcss/oxide-win32-arm64-msvc": "4.1.18", - "@tailwindcss/oxide-win32-x64-msvc": "4.1.18" + "@tailwindcss/oxide-android-arm64": "4.2.1", + "@tailwindcss/oxide-darwin-arm64": "4.2.1", + "@tailwindcss/oxide-darwin-x64": "4.2.1", + "@tailwindcss/oxide-freebsd-x64": "4.2.1", + "@tailwindcss/oxide-linux-arm-gnueabihf": "4.2.1", + "@tailwindcss/oxide-linux-arm64-gnu": "4.2.1", + "@tailwindcss/oxide-linux-arm64-musl": "4.2.1", + "@tailwindcss/oxide-linux-x64-gnu": "4.2.1", + "@tailwindcss/oxide-linux-x64-musl": "4.2.1", + "@tailwindcss/oxide-wasm32-wasi": "4.2.1", + "@tailwindcss/oxide-win32-arm64-msvc": "4.2.1", + "@tailwindcss/oxide-win32-x64-msvc": "4.2.1" } }, "node_modules/@tailwindcss/oxide-android-arm64": { - "version": "4.1.18", - "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-android-arm64/-/oxide-android-arm64-4.1.18.tgz", - "integrity": "sha512-dJHz7+Ugr9U/diKJA0W6N/6/cjI+ZTAoxPf9Iz9BFRF2GzEX8IvXxFIi/dZBloVJX/MZGvRuFA9rqwdiIEZQ0Q==", + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-android-arm64/-/oxide-android-arm64-4.2.1.tgz", + "integrity": "sha512-eZ7G1Zm5EC8OOKaesIKuw77jw++QJ2lL9N+dDpdQiAB/c/B2wDh0QPFHbkBVrXnwNugvrbJFk1gK2SsVjwWReg==", "cpu": [ "arm64" ], @@ -4936,13 +5410,13 @@ "android" ], "engines": { - "node": ">= 10" + "node": ">= 20" } }, "node_modules/@tailwindcss/oxide-darwin-arm64": { - "version": "4.1.18", - "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-darwin-arm64/-/oxide-darwin-arm64-4.1.18.tgz", - "integrity": "sha512-Gc2q4Qhs660bhjyBSKgq6BYvwDz4G+BuyJ5H1xfhmDR3D8HnHCmT/BSkvSL0vQLy/nkMLY20PQ2OoYMO15Jd0A==", + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-darwin-arm64/-/oxide-darwin-arm64-4.2.1.tgz", + "integrity": "sha512-q/LHkOstoJ7pI1J0q6djesLzRvQSIfEto148ppAd+BVQK0JYjQIFSK3JgYZJa+Yzi0DDa52ZsQx2rqytBnf8Hw==", "cpu": [ "arm64" ], @@ -4953,13 +5427,13 @@ "darwin" ], "engines": { - "node": ">= 10" + "node": ">= 20" } }, "node_modules/@tailwindcss/oxide-darwin-x64": { - "version": "4.1.18", - "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-darwin-x64/-/oxide-darwin-x64-4.1.18.tgz", - "integrity": "sha512-FL5oxr2xQsFrc3X9o1fjHKBYBMD1QZNyc1Xzw/h5Qu4XnEBi3dZn96HcHm41c/euGV+GRiXFfh2hUCyKi/e+yw==", + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-darwin-x64/-/oxide-darwin-x64-4.2.1.tgz", + "integrity": "sha512-/f/ozlaXGY6QLbpvd/kFTro2l18f7dHKpB+ieXz+Cijl4Mt9AI2rTrpq7V+t04nK+j9XBQHnSMdeQRhbGyt6fw==", "cpu": [ "x64" ], @@ -4970,13 +5444,13 @@ "darwin" ], "engines": { - "node": ">= 10" + "node": ">= 20" } }, "node_modules/@tailwindcss/oxide-freebsd-x64": { - "version": "4.1.18", - "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-freebsd-x64/-/oxide-freebsd-x64-4.1.18.tgz", - "integrity": "sha512-Fj+RHgu5bDodmV1dM9yAxlfJwkkWvLiRjbhuO2LEtwtlYlBgiAT4x/j5wQr1tC3SANAgD+0YcmWVrj8R9trVMA==", + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-freebsd-x64/-/oxide-freebsd-x64-4.2.1.tgz", + "integrity": "sha512-5e/AkgYJT/cpbkys/OU2Ei2jdETCLlifwm7ogMC7/hksI2fC3iiq6OcXwjibcIjPung0kRtR3TxEITkqgn0TcA==", "cpu": [ "x64" ], @@ -4987,13 +5461,13 @@ "freebsd" ], "engines": { - "node": ">= 10" + "node": ">= 20" } }, "node_modules/@tailwindcss/oxide-linux-arm-gnueabihf": { - "version": "4.1.18", - "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-arm-gnueabihf/-/oxide-linux-arm-gnueabihf-4.1.18.tgz", - "integrity": "sha512-Fp+Wzk/Ws4dZn+LV2Nqx3IilnhH51YZoRaYHQsVq3RQvEl+71VGKFpkfHrLM/Li+kt5c0DJe/bHXK1eHgDmdiA==", + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-arm-gnueabihf/-/oxide-linux-arm-gnueabihf-4.2.1.tgz", + "integrity": "sha512-Uny1EcVTTmerCKt/1ZuKTkb0x8ZaiuYucg2/kImO5A5Y/kBz41/+j0gxUZl+hTF3xkWpDmHX+TaWhOtba2Fyuw==", "cpu": [ "arm" ], @@ -5004,13 +5478,13 @@ "linux" ], "engines": { - "node": ">= 10" + "node": ">= 20" } }, "node_modules/@tailwindcss/oxide-linux-arm64-gnu": { - "version": "4.1.18", - "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-arm64-gnu/-/oxide-linux-arm64-gnu-4.1.18.tgz", - "integrity": "sha512-S0n3jboLysNbh55Vrt7pk9wgpyTTPD0fdQeh7wQfMqLPM/Hrxi+dVsLsPrycQjGKEQk85Kgbx+6+QnYNiHalnw==", + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-arm64-gnu/-/oxide-linux-arm64-gnu-4.2.1.tgz", + "integrity": "sha512-CTrwomI+c7n6aSSQlsPL0roRiNMDQ/YzMD9EjcR+H4f0I1SQ8QqIuPnsVp7QgMkC1Qi8rtkekLkOFjo7OlEFRQ==", "cpu": [ "arm64" ], @@ -5021,13 +5495,13 @@ "linux" ], "engines": { - "node": ">= 10" + "node": ">= 20" } }, "node_modules/@tailwindcss/oxide-linux-arm64-musl": { - "version": "4.1.18", - "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-arm64-musl/-/oxide-linux-arm64-musl-4.1.18.tgz", - "integrity": "sha512-1px92582HkPQlaaCkdRcio71p8bc8i/ap5807tPRDK/uw953cauQBT8c5tVGkOwrHMfc2Yh6UuxaH4vtTjGvHg==", + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-arm64-musl/-/oxide-linux-arm64-musl-4.2.1.tgz", + "integrity": "sha512-WZA0CHRL/SP1TRbA5mp9htsppSEkWuQ4KsSUumYQnyl8ZdT39ntwqmz4IUHGN6p4XdSlYfJwM4rRzZLShHsGAQ==", "cpu": [ "arm64" ], @@ -5038,13 +5512,13 @@ "linux" ], "engines": { - "node": ">= 10" + "node": ">= 20" } }, "node_modules/@tailwindcss/oxide-linux-x64-gnu": { - "version": "4.1.18", - "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-x64-gnu/-/oxide-linux-x64-gnu-4.1.18.tgz", - "integrity": "sha512-v3gyT0ivkfBLoZGF9LyHmts0Isc8jHZyVcbzio6Wpzifg/+5ZJpDiRiUhDLkcr7f/r38SWNe7ucxmGW3j3Kb/g==", + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-x64-gnu/-/oxide-linux-x64-gnu-4.2.1.tgz", + "integrity": "sha512-qMFzxI2YlBOLW5PhblzuSWlWfwLHaneBE0xHzLrBgNtqN6mWfs+qYbhryGSXQjFYB1Dzf5w+LN5qbUTPhW7Y5g==", "cpu": [ "x64" ], @@ -5055,13 +5529,13 @@ "linux" ], "engines": { - "node": ">= 10" + "node": ">= 20" } }, "node_modules/@tailwindcss/oxide-linux-x64-musl": { - "version": "4.1.18", - "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-x64-musl/-/oxide-linux-x64-musl-4.1.18.tgz", - "integrity": "sha512-bhJ2y2OQNlcRwwgOAGMY0xTFStt4/wyU6pvI6LSuZpRgKQwxTec0/3Scu91O8ir7qCR3AuepQKLU/kX99FouqQ==", + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-x64-musl/-/oxide-linux-x64-musl-4.2.1.tgz", + "integrity": "sha512-5r1X2FKnCMUPlXTWRYpHdPYUY6a1Ar/t7P24OuiEdEOmms5lyqjDRvVY1yy9Rmioh+AunQ0rWiOTPE8F9A3v5g==", "cpu": [ "x64" ], @@ -5072,13 +5546,13 @@ "linux" ], "engines": { - "node": ">= 10" + "node": ">= 20" } }, "node_modules/@tailwindcss/oxide-wasm32-wasi": { - "version": "4.1.18", - "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-wasm32-wasi/-/oxide-wasm32-wasi-4.1.18.tgz", - "integrity": "sha512-LffYTvPjODiP6PT16oNeUQJzNVyJl1cjIebq/rWWBF+3eDst5JGEFSc5cWxyRCJ0Mxl+KyIkqRxk1XPEs9x8TA==", + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-wasm32-wasi/-/oxide-wasm32-wasi-4.2.1.tgz", + "integrity": "sha512-MGFB5cVPvshR85MTJkEvqDUnuNoysrsRxd6vnk1Lf2tbiqNlXpHYZqkqOQalydienEWOHHFyyuTSYRsLfxFJ2Q==", "bundleDependencies": [ "@napi-rs/wasm-runtime", "@emnapi/core", @@ -5094,81 +5568,21 @@ "license": "MIT", "optional": true, "dependencies": { - "@emnapi/core": "^1.7.1", - "@emnapi/runtime": "^1.7.1", + "@emnapi/core": "^1.8.1", + "@emnapi/runtime": "^1.8.1", "@emnapi/wasi-threads": "^1.1.0", - "@napi-rs/wasm-runtime": "^1.1.0", + "@napi-rs/wasm-runtime": "^1.1.1", "@tybys/wasm-util": "^0.10.1", - "tslib": "^2.4.0" + "tslib": "^2.8.1" }, "engines": { "node": ">=14.0.0" } }, - "node_modules/@tailwindcss/oxide-wasm32-wasi/node_modules/@emnapi/core": { - "version": "1.7.1", - "dev": true, - "inBundle": true, - "license": "MIT", - "optional": true, - "dependencies": { - "@emnapi/wasi-threads": "1.1.0", - "tslib": "^2.4.0" - } - }, - "node_modules/@tailwindcss/oxide-wasm32-wasi/node_modules/@emnapi/runtime": { - "version": "1.7.1", - "dev": true, - "inBundle": true, - "license": "MIT", - "optional": true, - "dependencies": { - "tslib": "^2.4.0" - } - }, - "node_modules/@tailwindcss/oxide-wasm32-wasi/node_modules/@emnapi/wasi-threads": { - "version": "1.1.0", - "dev": true, - "inBundle": true, - "license": "MIT", - "optional": true, - "dependencies": { - "tslib": "^2.4.0" - } - }, - "node_modules/@tailwindcss/oxide-wasm32-wasi/node_modules/@napi-rs/wasm-runtime": { - "version": "1.1.0", - "dev": true, - "inBundle": true, - "license": "MIT", - "optional": true, - "dependencies": { - "@emnapi/core": "^1.7.1", - "@emnapi/runtime": "^1.7.1", - "@tybys/wasm-util": "^0.10.1" - } - }, - "node_modules/@tailwindcss/oxide-wasm32-wasi/node_modules/@tybys/wasm-util": { - "version": "0.10.1", - "dev": true, - "inBundle": true, - "license": "MIT", - "optional": true, - "dependencies": { - "tslib": "^2.4.0" - } - }, - "node_modules/@tailwindcss/oxide-wasm32-wasi/node_modules/tslib": { - "version": "2.8.1", - "dev": true, - "inBundle": true, - "license": "0BSD", - "optional": true - }, "node_modules/@tailwindcss/oxide-win32-arm64-msvc": { - "version": "4.1.18", - "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-win32-arm64-msvc/-/oxide-win32-arm64-msvc-4.1.18.tgz", - "integrity": "sha512-HjSA7mr9HmC8fu6bdsZvZ+dhjyGCLdotjVOgLA2vEqxEBZaQo9YTX4kwgEvPCpRh8o4uWc4J/wEoFzhEmjvPbA==", + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-win32-arm64-msvc/-/oxide-win32-arm64-msvc-4.2.1.tgz", + "integrity": "sha512-YlUEHRHBGnCMh4Nj4GnqQyBtsshUPdiNroZj8VPkvTZSoHsilRCwXcVKnG9kyi0ZFAS/3u+qKHBdDc81SADTRA==", "cpu": [ "arm64" ], @@ -5179,13 +5593,13 @@ "win32" ], "engines": { - "node": ">= 10" + "node": ">= 20" } }, "node_modules/@tailwindcss/oxide-win32-x64-msvc": { - "version": "4.1.18", - "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-win32-x64-msvc/-/oxide-win32-x64-msvc-4.1.18.tgz", - "integrity": "sha512-bJWbyYpUlqamC8dpR7pfjA0I7vdF6t5VpUGMWRkXVE3AXgIZjYUYAK7II1GNaxR8J1SSrSrppRar8G++JekE3Q==", + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-win32-x64-msvc/-/oxide-win32-x64-msvc-4.2.1.tgz", + "integrity": "sha512-rbO34G5sMWWyrN/idLeVxAZgAKWrn5LiR3/I90Q9MkA67s6T1oB0xtTe+0heoBvHSpbU9Mk7i6uwJnpo4u21XQ==", "cpu": [ "x64" ], @@ -5196,21 +5610,21 @@ "win32" ], "engines": { - "node": ">= 10" + "node": ">= 20" } }, "node_modules/@tailwindcss/postcss": { - "version": "4.1.18", - "resolved": "https://registry.npmjs.org/@tailwindcss/postcss/-/postcss-4.1.18.tgz", - "integrity": "sha512-Ce0GFnzAOuPyfV5SxjXGn0CubwGcuDB0zcdaPuCSzAa/2vII24JTkH+I6jcbXLb1ctjZMZZI6OjDaLPJQL1S0g==", + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/@tailwindcss/postcss/-/postcss-4.2.1.tgz", + "integrity": "sha512-OEwGIBnXnj7zJeonOh6ZG9woofIjGrd2BORfvE5p9USYKDCZoQmfqLcfNiRWoJlRWLdNPn2IgVZuWAOM4iTYMw==", "dev": true, "license": "MIT", "dependencies": { "@alloc/quick-lru": "^5.2.0", - "@tailwindcss/node": "4.1.18", - "@tailwindcss/oxide": "4.1.18", - "postcss": "^8.4.41", - "tailwindcss": "4.1.18" + "@tailwindcss/node": "4.2.1", + "@tailwindcss/oxide": "4.2.1", + "postcss": "^8.5.6", + "tailwindcss": "4.2.1" } }, "node_modules/@tippyjs/react": { @@ -5226,15 +5640,6 @@ "react-dom": ">=16.8" } }, - "node_modules/@trysound/sax": { - "version": "0.2.0", - "resolved": "https://registry.npmjs.org/@trysound/sax/-/sax-0.2.0.tgz", - "integrity": "sha512-L7z9BgrNEcYyUYtF+HaEfiS5ebkh9jXqbszz7pC0hRBPaatV0XjSD3+eHrpqFemQfgwiFF0QPIarnIihIDn7OA==", - "license": "ISC", - "engines": { - "node": ">=10.13.0" - } - }, "node_modules/@types/body-parser": { "version": "1.19.6", "resolved": "https://registry.npmjs.org/@types/body-parser/-/body-parser-1.19.6.tgz", @@ -5312,9 +5717,9 @@ } }, "node_modules/@types/d3-array": { - "version": "3.2.1", - "resolved": "https://registry.npmjs.org/@types/d3-array/-/d3-array-3.2.1.tgz", - "integrity": "sha512-Y2Jn2idRrLzUfAKV2LyRImR+y4oa2AntrgID95SHJxuMUrkNXmanDSed71sRNZysveJVt1hLLemQZIady0FpEg==", + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/@types/d3-array/-/d3-array-3.2.2.tgz", + "integrity": "sha512-hOLWVbm7uRza0BYXpIIW5pxfrKe0W+D5lrFiAEYR+pb6w3N2SwSMaJbXdUfSEv+dT4MfHBLtn5js0LAWaO6otw==", "license": "MIT" }, "node_modules/@types/d3-axis": { @@ -5481,9 +5886,9 @@ "license": "MIT" }, "node_modules/@types/d3-shape": { - "version": "3.1.7", - "resolved": "https://registry.npmjs.org/@types/d3-shape/-/d3-shape-3.1.7.tgz", - "integrity": "sha512-VLvUQ33C+3J+8p+Daf+nYSOsjB4GXp19/S/aGo60m9h1v6XaxjiT82lKVWJCfzhtuZ3yD7i/TPeC/fuKLLOSmg==", + "version": "3.1.8", + "resolved": "https://registry.npmjs.org/@types/d3-shape/-/d3-shape-3.1.8.tgz", + "integrity": "sha512-lae0iWfcDeR7qt7rA88BNiqdvPS5pFVPpo5OfjElwNaT2yyekbM0C9vK+yqBqEmHr6lDkRnYNoTBYlAgJa7a4w==", "license": "MIT", "dependencies": { "@types/d3-path": "*" @@ -5571,21 +5976,21 @@ } }, "node_modules/@types/express": { - "version": "4.17.23", - "resolved": "https://registry.npmjs.org/@types/express/-/express-4.17.23.tgz", - "integrity": "sha512-Crp6WY9aTYP3qPi2wGDo9iUe/rceX01UMhnF1jmwDcKCFM6cx7YhGP/Mpr3y9AASpfHixIG0E6azCcL5OcDHsQ==", + "version": "4.17.25", + "resolved": "https://registry.npmjs.org/@types/express/-/express-4.17.25.tgz", + "integrity": "sha512-dVd04UKsfpINUnK0yBoYHDF3xu7xVH4BuDotC/xGuycx4CgbP48X/KF/586bcObxT0HENHXEU8Nqtu6NR+eKhw==", "license": "MIT", "dependencies": { "@types/body-parser": "*", "@types/express-serve-static-core": "^4.17.33", "@types/qs": "*", - "@types/serve-static": "*" + "@types/serve-static": "^1" } }, "node_modules/@types/express-serve-static-core": { - "version": "4.19.6", - "resolved": "https://registry.npmjs.org/@types/express-serve-static-core/-/express-serve-static-core-4.19.6.tgz", - "integrity": "sha512-N4LZ2xG7DatVqhCZzOGb1Yi5lMbXSZcmdLDe9EzSndPV2HpWYWzRbaerl2n27irrm94EPpprqa8KpskPT085+A==", + "version": "4.19.8", + "resolved": "https://registry.npmjs.org/@types/express-serve-static-core/-/express-serve-static-core-4.19.8.tgz", + "integrity": "sha512-02S5fmqeoKzVZCHPZid4b8JH2eM5HzQLZWN2FohQEy/0eXTq8VXZfSN6Pcr3F6N9R/vNrj7cpgbhjie6m/1tCA==", "license": "MIT", "dependencies": { "@types/node": "*", @@ -5628,9 +6033,9 @@ "license": "MIT" }, "node_modules/@types/http-cache-semantics": { - "version": "4.0.4", - "resolved": "https://registry.npmjs.org/@types/http-cache-semantics/-/http-cache-semantics-4.0.4.tgz", - "integrity": "sha512-1m0bIFVc7eJWyve9S0RnuRgcQqF/Xd5QsUZAZeQFr1Q3/p9JWoQQEqmVy+DPTNpGXwhgIetAoYF8JSc33q29QA==", + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/@types/http-cache-semantics/-/http-cache-semantics-4.2.0.tgz", + "integrity": "sha512-L3LgimLHXtGkWikKnsPg0/VFx9OGZaC+eN1u4r+OB1XRqH3meBIAVC2zr1WdMH+RHmnRkqliQAOHNJ/E0j/e0Q==", "license": "MIT" }, "node_modules/@types/http-errors": { @@ -5640,9 +6045,9 @@ "license": "MIT" }, "node_modules/@types/http-proxy": { - "version": "1.17.16", - "resolved": "https://registry.npmjs.org/@types/http-proxy/-/http-proxy-1.17.16.tgz", - "integrity": "sha512-sdWoUajOB1cd0A8cRRQ1cfyWNbmFKLAqBB89Y8x5iYyG/mkJHc0YUH8pdWBy2omi9qtCpiIgGjuwO0dQST2l5w==", + "version": "1.17.17", + "resolved": "https://registry.npmjs.org/@types/http-proxy/-/http-proxy-1.17.17.tgz", + "integrity": "sha512-ED6LB+Z1AVylNTu7hdzuBqOgMnvG/ld6wGCG8wFnAzKX5uyW2K3WD52v0gnLCTK/VLpXtKckgWuyScYK6cSPaw==", "license": "MIT", "dependencies": { "@types/node": "*" @@ -5706,21 +6111,12 @@ "license": "MIT" }, "node_modules/@types/node": { - "version": "24.3.0", - "resolved": "https://registry.npmjs.org/@types/node/-/node-24.3.0.tgz", - "integrity": "sha512-aPTXCrfwnDLj4VvXrm+UUCQjNEvJgNA8s5F1cvwQU+3KNltTOkBm1j30uNLyqqPNe7gE3KFzImYoZEfLhp4Yow==", - "license": "MIT", - "dependencies": { - "undici-types": "~7.10.0" - } - }, - "node_modules/@types/node-forge": { - "version": "1.3.14", - "resolved": "https://registry.npmjs.org/@types/node-forge/-/node-forge-1.3.14.tgz", - "integrity": "sha512-mhVF2BnD4BO+jtOp7z1CdzaK4mbuK0LLQYAvdOLqHTavxFNq4zA1EmYkpnFjP8HOUzedfQkRnp0E2ulSAYSzAw==", + "version": "25.3.3", + "resolved": "https://registry.npmjs.org/@types/node/-/node-25.3.3.tgz", + "integrity": "sha512-DpzbrH7wIcBaJibpKo9nnSQL0MTRdnWttGyE5haGwK86xgMOkFLp7vEyfQPGLOJh5wNYiJ3V9PmUMDhV9u8kkQ==", "license": "MIT", "dependencies": { - "@types/node": "*" + "undici-types": "~7.18.0" } }, "node_modules/@types/parse5": { @@ -5730,9 +6126,9 @@ "license": "MIT" }, "node_modules/@types/prismjs": { - "version": "1.26.5", - "resolved": "https://registry.npmjs.org/@types/prismjs/-/prismjs-1.26.5.tgz", - "integrity": "sha512-AUZTa7hQ2KY5L7AmtSiqxlhWxb4ina0yd8hNbl4TWuqnv/pFP0nDMb3YrfSBf4hJVGLh2YEIBfKaBW/9UEl6IQ==", + "version": "1.26.6", + "resolved": "https://registry.npmjs.org/@types/prismjs/-/prismjs-1.26.6.tgz", + "integrity": "sha512-vqlvI7qlMvcCBbVe0AKAb4f97//Hy0EBTaiW8AalRnG/xAN5zOiWWyrNqNXeq8+KAuvRewjCVY1+IPxk4RdNYw==", "license": "MIT" }, "node_modules/@types/qs": { @@ -5748,12 +6144,13 @@ "license": "MIT" }, "node_modules/@types/react": { - "version": "19.1.12", - "resolved": "https://registry.npmjs.org/@types/react/-/react-19.1.12.tgz", - "integrity": "sha512-cMoR+FoAf/Jyq6+Df2/Z41jISvGZZ2eTlnsaJRptmZ76Caldwy1odD4xTr/gNV9VLj0AWgg/nmkevIyUfIIq5w==", + "version": "19.2.14", + "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.14.tgz", + "integrity": "sha512-ilcTH/UniCkMdtexkoCN0bI7pMcJDvmQFPvuPvmEaYA/NSfFTAgdUSLAoVjaRJm7+6PvcM+q1zYOwS4wTYMF9w==", "license": "MIT", + "peer": true, "dependencies": { - "csstype": "^3.0.2" + "csstype": "^3.2.2" } }, "node_modules/@types/react-router": { @@ -5804,12 +6201,11 @@ } }, "node_modules/@types/send": { - "version": "0.17.5", - "resolved": "https://registry.npmjs.org/@types/send/-/send-0.17.5.tgz", - "integrity": "sha512-z6F2D3cOStZvuk2SaP6YrwkNO65iTZcwA2ZkSABegdkAh/lf+Aa/YQndZVfmEXT5vgAp6zv06VQ3ejSVjAny4w==", + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/@types/send/-/send-1.2.1.tgz", + "integrity": "sha512-arsCikDvlU99zl1g69TcAB3mzZPpxgw0UQnaHeC1Nwb015xp8bknZv5rIfri9xTOcMuaVgvabfIRA7PSZVuZIQ==", "license": "MIT", "dependencies": { - "@types/mime": "^1", "@types/node": "*" } }, @@ -5823,14 +6219,24 @@ } }, "node_modules/@types/serve-static": { - "version": "1.15.8", - "resolved": "https://registry.npmjs.org/@types/serve-static/-/serve-static-1.15.8.tgz", - "integrity": "sha512-roei0UY3LhpOJvjbIP6ZZFngyLKl5dskOtDhxY5THRSpO+ZI+nzJ+m5yUMzGrp89YRa7lvknKkMYjqQFGwA7Sg==", + "version": "1.15.10", + "resolved": "https://registry.npmjs.org/@types/serve-static/-/serve-static-1.15.10.tgz", + "integrity": "sha512-tRs1dB+g8Itk72rlSI2ZrW6vZg0YrLI81iQSTkMmOqnqCaNr/8Ek4VwWcN5vZgCYWbg/JJSGBlUaYGAOP73qBw==", "license": "MIT", "dependencies": { "@types/http-errors": "*", "@types/node": "*", - "@types/send": "*" + "@types/send": "<1" + } + }, + "node_modules/@types/serve-static/node_modules/@types/send": { + "version": "0.17.6", + "resolved": "https://registry.npmjs.org/@types/send/-/send-0.17.6.tgz", + "integrity": "sha512-Uqt8rPBE8SY0RK8JB1EzVOIZ32uqy8HwdxCnoCOsYrvnswqmFZ/k+9Ikidlk/ImhsdvBsloHbAlewb2IEBV/Og==", + "license": "MIT", + "dependencies": { + "@types/mime": "^1", + "@types/node": "*" } }, "node_modules/@types/sockjs": { @@ -5885,15 +6291,6 @@ "integrity": "sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g==", "license": "ISC" }, - "node_modules/@vercel/oidc": { - "version": "3.0.5", - "resolved": "https://registry.npmjs.org/@vercel/oidc/-/oidc-3.0.5.tgz", - "integrity": "sha512-fnYhv671l+eTTp48gB4zEsTW/YtRgRPnkI2nT7x6qw5rkI1Lq2hTmQIpHPgyThI0znLK+vX2n9XxKdXZ7BUbbw==", - "license": "Apache-2.0", - "engines": { - "node": ">= 20" - } - }, "node_modules/@webassemblyjs/ast": { "version": "1.14.1", "resolved": "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.14.1.tgz", @@ -6102,10 +6499,11 @@ } }, "node_modules/acorn": { - "version": "8.15.0", - "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz", - "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==", + "version": "8.16.0", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.16.0.tgz", + "integrity": "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==", "license": "MIT", + "peer": true, "bin": { "acorn": "bin/acorn" }, @@ -6135,9 +6533,9 @@ } }, "node_modules/acorn-walk": { - "version": "8.3.4", - "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.3.4.tgz", - "integrity": "sha512-ueEepnujpqee2o5aIYnvHU6C0A42MNdsIDeqy5BydrkuC5R1ZuUFnm27EeFJGoEHJQgn3uleRvmTXaJgfXbt4g==", + "version": "8.3.5", + "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.3.5.tgz", + "integrity": "sha512-HEHNfbars9v4pgpW6SO1KSPkfoS0xVOM/9UzkJltjlsHZmJasxg8aXkuZa7SMf8vKGIBhpUsPluQSqhJFCqebw==", "license": "MIT", "dependencies": { "acorn": "^8.11.0" @@ -6168,29 +6566,12 @@ "node": ">=8" } }, - "node_modules/ai": { - "version": "5.0.97", - "resolved": "https://registry.npmjs.org/ai/-/ai-5.0.97.tgz", - "integrity": "sha512-8zBx0b/owis4eJI2tAlV8a1Rv0BANmLxontcAelkLNwEHhgfgXeKpDkhNB6OgV+BJSwboIUDkgd9312DdJnCOQ==", - "license": "Apache-2.0", - "dependencies": { - "@ai-sdk/gateway": "2.0.12", - "@ai-sdk/provider": "2.0.0", - "@ai-sdk/provider-utils": "3.0.17", - "@opentelemetry/api": "1.9.0" - }, - "engines": { - "node": ">=18" - }, - "peerDependencies": { - "zod": "^3.25.76 || ^4.1.8" - } - }, "node_modules/ajv": { - "version": "8.17.1", - "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz", - "integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==", + "version": "8.18.0", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.18.0.tgz", + "integrity": "sha512-PlXPeEWMXMZ7sPYOHqmDyCJzcfNrUr3fGNKtezX14ykXOEIvyK81d+qydx89KY5O71FKMPaQ2vBfBFI5NHR63A==", "license": "MIT", + "peer": true, "dependencies": { "fast-deep-equal": "^3.1.3", "fast-uri": "^3.0.1", @@ -6232,34 +6613,35 @@ } }, "node_modules/algoliasearch": { - "version": "5.44.0", - "resolved": "https://registry.npmjs.org/algoliasearch/-/algoliasearch-5.44.0.tgz", - "integrity": "sha512-f8IpsbdQjzTjr/4mJ/jv5UplrtyMnnciGax6/B0OnLCs2/GJTK13O4Y7Ff1AvJVAaztanH+m5nzPoUq6EAy+aA==", - "license": "MIT", - "dependencies": { - "@algolia/abtesting": "1.10.0", - "@algolia/client-abtesting": "5.44.0", - "@algolia/client-analytics": "5.44.0", - "@algolia/client-common": "5.44.0", - "@algolia/client-insights": "5.44.0", - "@algolia/client-personalization": "5.44.0", - "@algolia/client-query-suggestions": "5.44.0", - "@algolia/client-search": "5.44.0", - "@algolia/ingestion": "1.44.0", - "@algolia/monitoring": "1.44.0", - "@algolia/recommend": "5.44.0", - "@algolia/requester-browser-xhr": "5.44.0", - "@algolia/requester-fetch": "5.44.0", - "@algolia/requester-node-http": "5.44.0" + "version": "5.49.1", + "resolved": "https://registry.npmjs.org/algoliasearch/-/algoliasearch-5.49.1.tgz", + "integrity": "sha512-X3Pp2aRQhg4xUC6PQtkubn5NpRKuUPQ9FPDQlx36SmpFwwH2N0/tw4c+NXV3nw3PsgeUs+BuWGP0gjz3TvENLQ==", + "license": "MIT", + "peer": true, + "dependencies": { + "@algolia/abtesting": "1.15.1", + "@algolia/client-abtesting": "5.49.1", + "@algolia/client-analytics": "5.49.1", + "@algolia/client-common": "5.49.1", + "@algolia/client-insights": "5.49.1", + "@algolia/client-personalization": "5.49.1", + "@algolia/client-query-suggestions": "5.49.1", + "@algolia/client-search": "5.49.1", + "@algolia/ingestion": "1.49.1", + "@algolia/monitoring": "1.49.1", + "@algolia/recommend": "5.49.1", + "@algolia/requester-browser-xhr": "5.49.1", + "@algolia/requester-fetch": "5.49.1", + "@algolia/requester-node-http": "5.49.1" }, "engines": { "node": ">= 14.0.0" } }, "node_modules/algoliasearch-helper": { - "version": "3.26.1", - "resolved": "https://registry.npmjs.org/algoliasearch-helper/-/algoliasearch-helper-3.26.1.tgz", - "integrity": "sha512-CAlCxm4fYBXtvc5MamDzP6Svu8rW4z9me4DCBY1rQ2UDJ0u0flWmusQ8M3nOExZsLLRcUwUPoRAPMrhzOG3erw==", + "version": "3.28.0", + "resolved": "https://registry.npmjs.org/algoliasearch-helper/-/algoliasearch-helper-3.28.0.tgz", + "integrity": "sha512-GBN0xsxGggaCPElZq24QzMdfphrjIiV2xA+hRXE4/UMpN3nsF2WrM8q+x80OGvGpJWtB7F+4Hq5eSfWwuejXrg==", "license": "MIT", "dependencies": { "@algolia/events": "^4.0.1" @@ -6406,6 +6788,20 @@ "node": ">=8" } }, + "node_modules/asn1js": { + "version": "3.0.7", + "resolved": "https://registry.npmjs.org/asn1js/-/asn1js-3.0.7.tgz", + "integrity": "sha512-uLvq6KJu04qoQM6gvBfKFjlh6Gl0vOKQuR5cJMDHQkmwfMOQeN3F3SHCv9SNYSL+CRoHvOGFfllDlVz03GQjvQ==", + "license": "BSD-3-Clause", + "dependencies": { + "pvtsutils": "^1.3.6", + "pvutils": "^1.1.3", + "tslib": "^2.8.1" + }, + "engines": { + "node": ">=12.0.0" + } + }, "node_modules/astring": { "version": "1.9.0", "resolved": "https://registry.npmjs.org/astring/-/astring-1.9.0.tgz", @@ -6425,9 +6821,9 @@ } }, "node_modules/autoprefixer": { - "version": "10.4.24", - "resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.4.24.tgz", - "integrity": "sha512-uHZg7N9ULTVbutaIsDRoUkoS8/h3bdsmVJYZ5l3wv8Cp/6UIIoRDm90hZ+BwxUj/hGBEzLxdHNSKuFpn8WOyZw==", + "version": "10.4.27", + "resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.4.27.tgz", + "integrity": "sha512-NP9APE+tO+LuJGn7/9+cohklunJsXWiaWEfV3si4Gi/XHDwVNgkwr1J3RQYFIvPy76GmJ9/bW8vyoU1LcxwKHA==", "funding": [ { "type": "opencollective", @@ -6445,7 +6841,7 @@ "license": "MIT", "dependencies": { "browserslist": "^4.28.1", - "caniuse-lite": "^1.0.30001766", + "caniuse-lite": "^1.0.30001774", "fraction.js": "^5.3.4", "picocolors": "^1.1.1", "postcss-value-parser": "^4.2.0" @@ -6487,13 +6883,13 @@ } }, "node_modules/babel-plugin-polyfill-corejs2": { - "version": "0.4.14", - "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.4.14.tgz", - "integrity": "sha512-Co2Y9wX854ts6U8gAAPXfn0GmAyctHuK8n0Yhfjd6t30g7yvKjspvvOo9yG+z52PZRgFErt7Ka2pYnXCjLKEpg==", + "version": "0.4.15", + "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.4.15.tgz", + "integrity": "sha512-hR3GwrRwHUfYwGfrisXPIDP3JcYfBrW7wKE7+Au6wDYl7fm/ka1NEII6kORzxNU556JjfidZeBsO10kYvtV1aw==", "license": "MIT", "dependencies": { - "@babel/compat-data": "^7.27.7", - "@babel/helper-define-polyfill-provider": "^0.6.5", + "@babel/compat-data": "^7.28.6", + "@babel/helper-define-polyfill-provider": "^0.6.6", "semver": "^6.3.1" }, "peerDependencies": { @@ -6523,12 +6919,12 @@ } }, "node_modules/babel-plugin-polyfill-regenerator": { - "version": "0.6.5", - "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.6.5.tgz", - "integrity": "sha512-ISqQ2frbiNU9vIJkzg7dlPpznPZ4jOiUQ1uSmB0fEHeowtN3COYRsXr/xexn64NpU13P06jc/L5TgiJXOgrbEg==", + "version": "0.6.6", + "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.6.6.tgz", + "integrity": "sha512-hYm+XLYRMvupxiQzrvXUj7YyvFFVfv5gI0R71AJzudg1g2AI2vyCPPIFEBjk162/wFzti3inBHo7isWFuEVS/A==", "license": "MIT", "dependencies": { - "@babel/helper-define-polyfill-provider": "^0.6.5" + "@babel/helper-define-polyfill-provider": "^0.6.6" }, "peerDependencies": { "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0" @@ -6551,12 +6947,15 @@ "license": "MIT" }, "node_modules/baseline-browser-mapping": { - "version": "2.9.7", - "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.9.7.tgz", - "integrity": "sha512-k9xFKplee6KIio3IDbwj+uaCLpqzOwakOgmqzPezM0sFJlFKcg30vk2wOiAJtkTSfx0SSQDSe8q+mWA/fSH5Zg==", + "version": "2.10.0", + "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.0.tgz", + "integrity": "sha512-lIyg0szRfYbiy67j9KN8IyeD7q7hcmqnJ1ddWmNt19ItGpNN64mnllmxUNFIOdOm6by97jlL6wfpTTJrmnjWAA==", "license": "Apache-2.0", "bin": { - "baseline-browser-mapping": "dist/cli.js" + "baseline-browser-mapping": "dist/cli.cjs" + }, + "engines": { + "node": ">=6.0.0" } }, "node_modules/batch": { @@ -6597,23 +6996,23 @@ } }, "node_modules/body-parser": { - "version": "1.20.3", - "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.3.tgz", - "integrity": "sha512-7rAxByjUMqQ3/bHJy7D6OGXvx/MMc4IqBn/X0fcM1QUcAItpZrBEYhWGem+tzXH90c+G01ypMcYJBO9Y30203g==", + "version": "1.20.4", + "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.4.tgz", + "integrity": "sha512-ZTgYYLMOXY9qKU/57FAo8F+HA2dGX7bqGc71txDRC1rS4frdFI5R7NhluHxH6M0YItAP0sHB4uqAOcYKxO6uGA==", "license": "MIT", "dependencies": { - "bytes": "3.1.2", + "bytes": "~3.1.2", "content-type": "~1.0.5", "debug": "2.6.9", "depd": "2.0.0", - "destroy": "1.2.0", - "http-errors": "2.0.0", - "iconv-lite": "0.4.24", - "on-finished": "2.4.1", - "qs": "6.13.0", - "raw-body": "2.5.2", + "destroy": "~1.2.0", + "http-errors": "~2.0.1", + "iconv-lite": "~0.4.24", + "on-finished": "~2.4.1", + "qs": "~6.14.0", + "raw-body": "~2.5.3", "type-is": "~1.6.18", - "unpipe": "1.0.0" + "unpipe": "~1.0.0" }, "engines": { "node": ">= 0.8", @@ -6638,6 +7037,18 @@ "ms": "2.0.0" } }, + "node_modules/body-parser/node_modules/iconv-lite": { + "version": "0.4.24", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz", + "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==", + "license": "MIT", + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3" + }, + "engines": { + "node": ">=0.10.0" + } + }, "node_modules/body-parser/node_modules/ms": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", @@ -6723,6 +7134,7 @@ } ], "license": "MIT", + "peer": true, "dependencies": { "baseline-browser-mapping": "^2.9.0", "caniuse-lite": "^1.0.30001759", @@ -6767,6 +7179,15 @@ "node": ">= 0.8" } }, + "node_modules/bytestreamjs": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/bytestreamjs/-/bytestreamjs-2.0.1.tgz", + "integrity": "sha512-U1Z/ob71V/bXfVABvNr/Kumf5VyeQRBEm6Txb0PQ6S7V5GpBM3w4Cbqz/xPDicR5tN0uvDifng8C+5qECeGwyQ==", + "license": "BSD-3-Clause", + "engines": { + "node": ">=6.0.0" + } + }, "node_modules/cacheable-lookup": { "version": "7.0.0", "resolved": "https://registry.npmjs.org/cacheable-lookup/-/cacheable-lookup-7.0.0.tgz", @@ -6885,9 +7306,9 @@ } }, "node_modules/caniuse-lite": { - "version": "1.0.30001767", - "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001767.tgz", - "integrity": "sha512-34+zUAMhSH+r+9eKmYG+k2Rpt8XttfE4yXAjoZvkAPs15xcYQhyBYdalJ65BzivAvGRMViEjy6oKr/S91loekQ==", + "version": "1.0.30001776", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001776.tgz", + "integrity": "sha512-sg01JDPzZ9jGshqKSckOQthXnYwOEP50jeVFhaSFbZcOy05TiuuaffDOfcwtCisJ9kNQuLBFibYywv2Bgm9osw==", "funding": [ { "type": "opencollective", @@ -7018,17 +7439,18 @@ } }, "node_modules/chevrotain": { - "version": "11.0.3", - "resolved": "https://registry.npmjs.org/chevrotain/-/chevrotain-11.0.3.tgz", - "integrity": "sha512-ci2iJH6LeIkvP9eJW6gpueU8cnZhv85ELY8w8WiFtNjMHA5ad6pQLaJo9mEly/9qUyCpvqX8/POVUTf18/HFdw==", + "version": "11.1.2", + "resolved": "https://registry.npmjs.org/chevrotain/-/chevrotain-11.1.2.tgz", + "integrity": "sha512-opLQzEVriiH1uUQ4Kctsd49bRoFDXGGSC4GUqj7pGyxM3RehRhvTlZJc1FL/Flew2p5uwxa1tUDWKzI4wNM8pg==", "license": "Apache-2.0", + "peer": true, "dependencies": { - "@chevrotain/cst-dts-gen": "11.0.3", - "@chevrotain/gast": "11.0.3", - "@chevrotain/regexp-to-ast": "11.0.3", - "@chevrotain/types": "11.0.3", - "@chevrotain/utils": "11.0.3", - "lodash-es": "4.17.21" + "@chevrotain/cst-dts-gen": "11.1.2", + "@chevrotain/gast": "11.1.2", + "@chevrotain/regexp-to-ast": "11.1.2", + "@chevrotain/types": "11.1.2", + "@chevrotain/utils": "11.1.2", + "lodash-es": "4.17.23" } }, "node_modules/chevrotain-allstar": { @@ -7250,9 +7672,9 @@ } }, "node_modules/comma-separated-tokens": { - "version": "2.0.3", - "resolved": "https://registry.npmjs.org/comma-separated-tokens/-/comma-separated-tokens-2.0.3.tgz", - "integrity": "sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg==", + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/comma-separated-tokens/-/comma-separated-tokens-1.0.8.tgz", + "integrity": "sha512-GHuDRO12Sypu2cV70d1dkA2EUmXHgntrzbpvOB+Qy+49ypNfGgFQIC2fhhXbnyrJRynDCAARsT7Ou0M6hirpfw==", "license": "MIT", "funding": { "type": "github", @@ -7344,9 +7766,9 @@ "license": "MIT" }, "node_modules/confbox": { - "version": "0.2.2", - "resolved": "https://registry.npmjs.org/confbox/-/confbox-0.2.2.tgz", - "integrity": "sha512-1NB+BKqhtNipMsov4xI/NnhCKp9XG9NamYp5PVm9klAT0fsrNPjaFICsCFhNhwZJKNh7zB/3q8qXz0E9oaMNtQ==", + "version": "0.1.8", + "resolved": "https://registry.npmjs.org/confbox/-/confbox-0.1.8.tgz", + "integrity": "sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w==", "license": "MIT" }, "node_modules/config-chain": { @@ -7433,18 +7855,18 @@ "license": "MIT" }, "node_modules/cookie": { - "version": "0.7.1", - "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.1.tgz", - "integrity": "sha512-6DnInpx7SJ2AK3+CTUE/ZM0vWTUboZCegxhC2xiIydHR9jNuTAASBrfEpHhiGOZw/nX51bHt6YQl8jsGo4y/0w==", + "version": "0.7.2", + "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz", + "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==", "license": "MIT", "engines": { "node": ">= 0.6" } }, "node_modules/cookie-signature": { - "version": "1.0.6", - "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.6.tgz", - "integrity": "sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ==", + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.7.tgz", + "integrity": "sha512-NXdYc3dLr47pBkpUCHtKSwIOQXLVn8dZEuywboCOJY/osA0wFSLlSawr3KN8qXJEyX66FcONTH8EIlVuK0yyFA==", "license": "MIT" }, "node_modules/copy-webpack-plugin": { @@ -7515,9 +7937,9 @@ } }, "node_modules/core-js": { - "version": "3.45.1", - "resolved": "https://registry.npmjs.org/core-js/-/core-js-3.45.1.tgz", - "integrity": "sha512-L4NPsJlCfZsPeXukyzHFlg/i7IIVwHSItR0wg0FLNqYClJ4MQYTYLbC7EkjKYRLZF2iof2MUgN0EGy7MdQFChg==", + "version": "3.48.0", + "resolved": "https://registry.npmjs.org/core-js/-/core-js-3.48.0.tgz", + "integrity": "sha512-zpEHTy1fjTMZCKLHUZoVeylt9XrzaIN2rbPXEt0k+q7JE5CkCZdo6bNq55bn24a69CH7ErAVLKijxJja4fw+UQ==", "hasInstallScript": true, "license": "MIT", "funding": { @@ -7526,12 +7948,12 @@ } }, "node_modules/core-js-compat": { - "version": "3.47.0", - "resolved": "https://registry.npmjs.org/core-js-compat/-/core-js-compat-3.47.0.tgz", - "integrity": "sha512-IGfuznZ/n7Kp9+nypamBhvwdwLsW6KC8IOaURw2doAK5e98AG3acVLdh0woOnEqCfUtS+Vu882JE4k/DAm3ItQ==", + "version": "3.48.0", + "resolved": "https://registry.npmjs.org/core-js-compat/-/core-js-compat-3.48.0.tgz", + "integrity": "sha512-OM4cAF3D6VtH/WkLtWvyNC56EZVXsZdU3iqaMG2B4WvYrlqU831pc4UtG5yp0sE9z8Y02wVN7PjW5Zf9Gt0f1Q==", "license": "MIT", "dependencies": { - "browserslist": "^4.28.0" + "browserslist": "^4.28.1" }, "funding": { "type": "opencollective", @@ -7539,9 +7961,9 @@ } }, "node_modules/core-js-pure": { - "version": "3.47.0", - "resolved": "https://registry.npmjs.org/core-js-pure/-/core-js-pure-3.47.0.tgz", - "integrity": "sha512-BcxeDbzUrRnXGYIVAGFtcGQVNpFcUhVjr6W7F8XktvQW2iJP9e66GP6xdKotCRFlrxBvNIBrhwKteRXqMV86Nw==", + "version": "3.48.0", + "resolved": "https://registry.npmjs.org/core-js-pure/-/core-js-pure-3.48.0.tgz", + "integrity": "sha512-1slJgk89tWC51HQ1AEqG+s2VuwpTRr8ocu4n20QUcH1v9lAN0RXen0Q0AABa/DK1I7RrNWLucplOHMx8hfTGTw==", "hasInstallScript": true, "license": "MIT", "funding": { @@ -7657,9 +8079,9 @@ } }, "node_modules/css-blank-pseudo/node_modules/postcss-selector-parser": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.0.tgz", - "integrity": "sha512-8sLjZwK0R+JlxlYcTuVnyT2v+htpdrjDOKuMcOVdYjt52Lh8hWRYpxBPoKx/Zg+bcjc3wx6fmQevMmUztS/ccA==", + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.1.tgz", + "integrity": "sha512-orRsuYpJVw8LdAwqqLykBj9ecS5/cRHlI5+nvTo8LcCKmzDmqVORXtOIYEEQuL9D4BxtA1lm5isAqzQZCoQ6Eg==", "license": "MIT", "dependencies": { "cssesc": "^3.0.0", @@ -7670,9 +8092,9 @@ } }, "node_modules/css-declaration-sorter": { - "version": "7.3.0", - "resolved": "https://registry.npmjs.org/css-declaration-sorter/-/css-declaration-sorter-7.3.0.tgz", - "integrity": "sha512-LQF6N/3vkAMYF4xoHLJfG718HRJh34Z8BnNhd6bosOMIVjMlhuZK5++oZa3uYAgrI5+7x2o27gUqTR2U/KjUOQ==", + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/css-declaration-sorter/-/css-declaration-sorter-7.3.1.tgz", + "integrity": "sha512-gz6x+KkgNCjxq3Var03pRYLhyNfwhkKF1g/yoLgDNtFvVu0/fOLV9C8fFEZRjACp/XQLumjAYo7JVjzH3wLbxA==", "license": "ISC", "engines": { "node": "^14 || ^16 || >=18" @@ -7731,10 +8153,11 @@ } }, "node_modules/css-has-pseudo/node_modules/postcss-selector-parser": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.0.tgz", - "integrity": "sha512-8sLjZwK0R+JlxlYcTuVnyT2v+htpdrjDOKuMcOVdYjt52Lh8hWRYpxBPoKx/Zg+bcjc3wx6fmQevMmUztS/ccA==", + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.1.tgz", + "integrity": "sha512-orRsuYpJVw8LdAwqqLykBj9ecS5/cRHlI5+nvTo8LcCKmzDmqVORXtOIYEEQuL9D4BxtA1lm5isAqzQZCoQ6Eg==", "license": "MIT", + "peer": true, "dependencies": { "cssesc": "^3.0.0", "util-deprecate": "^1.0.2" @@ -7892,9 +8315,9 @@ } }, "node_modules/cssdb": { - "version": "8.4.2", - "resolved": "https://registry.npmjs.org/cssdb/-/cssdb-8.4.2.tgz", - "integrity": "sha512-PzjkRkRUS+IHDJohtxkIczlxPPZqRo0nXplsYXOMBRPjcVRjj1W4DfvRgshUYTVuUigU7ptVYkFJQ7abUB0nyg==", + "version": "8.8.0", + "resolved": "https://registry.npmjs.org/cssdb/-/cssdb-8.8.0.tgz", + "integrity": "sha512-QbLeyz2Bgso1iRlh7IpWk6OKa3lLNGXsujVjDMPl9rOZpxKeiG69icLpbLCFxeURwmcdIfZqQyhlooKJYM4f8Q==", "funding": [ { "type": "opencollective", @@ -8050,9 +8473,9 @@ "license": "CC0-1.0" }, "node_modules/csstype": { - "version": "3.1.3", - "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.3.tgz", - "integrity": "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==", + "version": "3.2.3", + "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz", + "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==", "license": "MIT" }, "node_modules/cytoscape": { @@ -8060,6 +8483,7 @@ "resolved": "https://registry.npmjs.org/cytoscape/-/cytoscape-3.33.1.tgz", "integrity": "sha512-iJc4TwyANnOGR1OmWhsS9ayRS3s+XQ185FmuHObThD+5AeJCakAAbWv8KimMTt08xCCLNgneQwFp+JRJOr9qGQ==", "license": "MIT", + "peer": true, "engines": { "node": ">=0.10" } @@ -8282,18 +8706,6 @@ "node": ">= 10" } }, - "node_modules/d3-dsv/node_modules/iconv-lite": { - "version": "0.6.3", - "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz", - "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==", - "license": "MIT", - "dependencies": { - "safer-buffer": ">= 2.1.2 < 3.0.0" - }, - "engines": { - "node": ">=0.10.0" - } - }, "node_modules/d3-ease": { "version": "3.0.1", "resolved": "https://registry.npmjs.org/d3-ease/-/d3-ease-3.0.1.tgz", @@ -8330,9 +8742,9 @@ } }, "node_modules/d3-format": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/d3-format/-/d3-format-3.1.0.tgz", - "integrity": "sha512-YyUI6AEuY/Wpt8KWLgZHsIU86atmikuoOmCfommt0LYHiQSPjvX2AcFc38PX0CBpr2RCyZhjex+NS/LPOv6YqA==", + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/d3-format/-/d3-format-3.1.2.tgz", + "integrity": "sha512-AJDdYOdnyRDV5b6ArilzCPPwc1ejkHcoyFarqlPqT7zRYjhavcT3uSrqcMvsgh2CgoPbK3RCwyHaVyxYcP2Arg==", "license": "ISC", "engines": { "node": ">=12" @@ -8481,6 +8893,7 @@ "resolved": "https://registry.npmjs.org/d3-selection/-/d3-selection-3.0.0.tgz", "integrity": "sha512-fmTRWbNMmsmWq6xJV8D19U/gw/bwrHfNXxrIN+HfZgnzqTHp9jOmKMhsTUjXOJnZOdZY9Q28y4yebKzqDKlxlQ==", "license": "ISC", + "peer": true, "engines": { "node": ">=12" } @@ -8566,9 +8979,9 @@ } }, "node_modules/dagre-d3-es": { - "version": "7.0.11", - "resolved": "https://registry.npmjs.org/dagre-d3-es/-/dagre-d3-es-7.0.11.tgz", - "integrity": "sha512-tvlJLyQf834SylNKax8Wkzco/1ias1OPw8DcUMDE7oUIoSEW25riQVuiu/0OWEFqT0cxHT3Pa9/D82Jr47IONw==", + "version": "7.0.13", + "resolved": "https://registry.npmjs.org/dagre-d3-es/-/dagre-d3-es-7.0.13.tgz", + "integrity": "sha512-efEhnxpSuwpYOKRm/L5KbqoZmNNukHa/Flty4Wp62JRvgH2ojwVgPgdYyr4twpieZnyRDdIH7PY2mopX26+j2Q==", "license": "MIT", "dependencies": { "d3": "^7.9.0", @@ -8576,9 +8989,9 @@ } }, "node_modules/dayjs": { - "version": "1.11.18", - "resolved": "https://registry.npmjs.org/dayjs/-/dayjs-1.11.18.tgz", - "integrity": "sha512-zFBQ7WFRvVRhKcWoUh+ZA1g2HVgUbsZm9sbddh8EC5iv93sui8DVVz1Npvz+r6meo9VKfa8NyLWBsQK1VvIKPA==", + "version": "1.11.19", + "resolved": "https://registry.npmjs.org/dayjs/-/dayjs-1.11.19.tgz", + "integrity": "sha512-t5EcLVS6QPBNqM2z8fakk/NKel+Xzshgt8FFKAn+qwlD1pzZWxh0nVCrvFK7ZDb6XucZeF9z8C7CBWTRIVApAw==", "license": "MIT" }, "node_modules/debounce": { @@ -8588,9 +9001,9 @@ "license": "MIT" }, "node_modules/debug": { - "version": "4.4.1", - "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz", - "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==", + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", "license": "MIT", "dependencies": { "ms": "^2.1.3" @@ -8605,9 +9018,9 @@ } }, "node_modules/decode-named-character-reference": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/decode-named-character-reference/-/decode-named-character-reference-1.2.0.tgz", - "integrity": "sha512-c6fcElNV6ShtZXmsgNgFFV5tVX2PaV4g+MOAkb8eXHvn6sryJBrZa9r0zV6+dtTyoCKxtDy5tyQ5ZwQuidtd+Q==", + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/decode-named-character-reference/-/decode-named-character-reference-1.3.0.tgz", + "integrity": "sha512-GtpQYB283KrPp6nRw50q3U9/VfOutZOe103qlN7BPP6Ad27xYnOIWv4lPzo8HCAL+mMZofJ9KEy30fq6MfaK6Q==", "license": "MIT", "dependencies": { "character-entities": "^2.0.0" @@ -8663,9 +9076,9 @@ } }, "node_modules/default-browser": { - "version": "5.2.1", - "resolved": "https://registry.npmjs.org/default-browser/-/default-browser-5.2.1.tgz", - "integrity": "sha512-WY/3TUME0x3KPYdRRxEJJvXRHV4PyPoUsxtZa78lwItwRQRHhd2U9xOscaT/YTf8uCXIAjeJOFBVEh/7FtD8Xg==", + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/default-browser/-/default-browser-5.5.0.tgz", + "integrity": "sha512-H9LMLr5zwIbSxrmvikGuI/5KGhZ8E2zH3stkMgM5LpOWDutGM2JZaj460Udnf1a+946zc7YBgrqEWwbk7zHvGw==", "license": "MIT", "dependencies": { "bundle-name": "^4.1.0", @@ -8679,9 +9092,9 @@ } }, "node_modules/default-browser-id": { - "version": "5.0.0", - "resolved": "https://registry.npmjs.org/default-browser-id/-/default-browser-id-5.0.0.tgz", - "integrity": "sha512-A6p/pu/6fyBcA1TRz/GqWYPViplrftcW2gZC9q79ngNCKAeR/X3gcEdXQHl4KNXV+3wgIJ1CPkJQ3IHM6lcsyA==", + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/default-browser-id/-/default-browser-id-5.0.1.tgz", + "integrity": "sha512-x1VCxdX4t+8wVfd1so/9w+vQ4vx7lKd2Qp5tDRutErwmR85OgmfX7RlLRMWafRMY7hbEiXIbudNrjOAPa/hL8Q==", "license": "MIT", "engines": { "node": ">=18" @@ -8945,16 +9358,6 @@ "url": "https://opencollective.com/unified" } }, - "node_modules/docusaurus-lunr-search/node_modules/unist-util-is": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-4.1.0.tgz", - "integrity": "sha512-ZOQSsnce92GrxSqlnEEseX0gi7GH9zTJZ0p9dtu87WRb/37mMPO2Ilx1s/t9vBHrFhbgweUwb+t7cIn5dxPhZg==", - "license": "MIT", - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/unified" - } - }, "node_modules/docusaurus-lunr-search/node_modules/unist-util-stringify-position": { "version": "2.0.3", "resolved": "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-2.0.3.tgz", @@ -9049,10 +9452,13 @@ } }, "node_modules/dompurify": { - "version": "3.2.6", - "resolved": "https://registry.npmjs.org/dompurify/-/dompurify-3.2.6.tgz", - "integrity": "sha512-/2GogDQlohXPZe6D6NOgQvXLPSYBqIWMnZ8zzOhn09REE4eyAzb+Hed3jhoM9OkuaJ8P6ZGTTVWQKAi8ieIzfQ==", + "version": "3.3.2", + "resolved": "https://registry.npmjs.org/dompurify/-/dompurify-3.3.2.tgz", + "integrity": "sha512-6obghkliLdmKa56xdbLOpUZ43pAR6xFy1uOrxBaIDjT+yaRuuybLjGS9eVBoSR/UPU5fq3OXClEHLJNGvbxKpQ==", "license": "(MPL-2.0 OR Apache-2.0)", + "engines": { + "node": ">=20" + }, "optionalDependencies": { "@types/trusted-types": "^2.0.7" } @@ -9138,9 +9544,9 @@ "license": "MIT" }, "node_modules/electron-to-chromium": { - "version": "1.5.267", - "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.267.tgz", - "integrity": "sha512-0Drusm6MVRXSOJpGbaSVgcQsuB4hEkMpHXaVstcPmhu5LIedxs1xNK/nIxmQIU/RPC0+1/o0AVZfBTkTNJOdUw==", + "version": "1.5.307", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.307.tgz", + "integrity": "sha512-5z3uFKBWjiNR44nFcYdkcXjKMbg5KXNdciu7mhTPo9tB7NbqSNP2sSnGR+fqknZSCwKkBN+oxiiajWs4dT6ORg==", "license": "ISC" }, "node_modules/emoji-regex": { @@ -9184,9 +9590,9 @@ } }, "node_modules/enhanced-resolve": { - "version": "5.19.0", - "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.19.0.tgz", - "integrity": "sha512-phv3E1Xl4tQOShqSte26C7Fl84EwUdZsyOuSSk9qtAGyyQs2s3jJzComh+Abf4g187lUUAvH+H26omrqia2aGg==", + "version": "5.20.0", + "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.20.0.tgz", + "integrity": "sha512-/ce7+jQ1PQ6rVXwe+jKEg5hW5ciicHwIQUagZkp6IufBoY3YDgdTTY1azVs0qoRgVmvsNB+rbjLJxDAeHHtwsQ==", "license": "MIT", "dependencies": { "graceful-fs": "^4.2.4", @@ -9540,15 +9946,6 @@ "node": ">=0.8.x" } }, - "node_modules/eventsource-parser": { - "version": "3.0.6", - "resolved": "https://registry.npmjs.org/eventsource-parser/-/eventsource-parser-3.0.6.tgz", - "integrity": "sha512-Vo1ab+QXPzZ4tCa8SwIHJFaSzy4R6SHf7BY79rFBDf0idraZWAkYrDjDj8uWaSm3S2TK+hJ7/t1CEmZ7jXw+pg==", - "license": "MIT", - "engines": { - "node": ">=18.0.0" - } - }, "node_modules/execa": { "version": "5.1.1", "resolved": "https://registry.npmjs.org/execa/-/execa-5.1.1.tgz", @@ -9651,21 +10048,6 @@ "integrity": "sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ==", "license": "MIT" }, - "node_modules/express/node_modules/qs": { - "version": "6.14.1", - "resolved": "https://registry.npmjs.org/qs/-/qs-6.14.1.tgz", - "integrity": "sha512-4EK3+xJl8Ts67nLYNwqw/dsFVnCf+qR7RgXSK9jEEm9unao3njwMDdmsdvoKBKHzxd7tCYz5e5M+SnMjdtXGQQ==", - "license": "BSD-3-Clause", - "dependencies": { - "side-channel": "^1.1.0" - }, - "engines": { - "node": ">=0.6" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, "node_modules/express/node_modules/range-parser": { "version": "1.2.1", "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz", @@ -9675,12 +10057,6 @@ "node": ">= 0.6" } }, - "node_modules/exsolve": { - "version": "1.0.7", - "resolved": "https://registry.npmjs.org/exsolve/-/exsolve-1.0.7.tgz", - "integrity": "sha512-VO5fQUzZtI6C+vx4w/4BWJpg3s/5l+6pRQEHzFRM8WFi4XffSP1Z+4qi7GbjWbvRQEbdIco5mIMq+zX4rPuLrw==", - "license": "MIT" - }, "node_modules/extend": { "version": "3.0.2", "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz", @@ -9744,9 +10120,9 @@ "license": "BSD-3-Clause" }, "node_modules/fastq": { - "version": "1.19.1", - "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.19.1.tgz", - "integrity": "sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ==", + "version": "1.20.1", + "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.20.1.tgz", + "integrity": "sha512-GGToxJ/w1x32s/D2EKND7kTil4n8OVk/9mycTc4VDza13lOvpUZTGX3mFSCtV9ksdGBVzvsyAVLM6mHFThxXxw==", "license": "ISC", "dependencies": { "reusify": "^1.0.4" @@ -9834,10 +10210,11 @@ } }, "node_modules/file-loader/node_modules/ajv": { - "version": "6.12.6", - "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz", - "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==", + "version": "6.14.0", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.14.0.tgz", + "integrity": "sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw==", "license": "MIT", + "peer": true, "dependencies": { "fast-deep-equal": "^3.1.1", "fast-json-stable-stringify": "^2.0.0", @@ -9895,17 +10272,17 @@ } }, "node_modules/finalhandler": { - "version": "1.3.1", - "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.1.tgz", - "integrity": "sha512-6BN9trH7bp3qvnrRyzsBz+g3lZxTNZTbVO2EV1CS0WIcDbawYVdYvGflME/9QP0h0pYlCDBCTjYa9nZzMDpyxQ==", + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.2.tgz", + "integrity": "sha512-aA4RyPcd3badbdABGDuTXCMTtOneUCAYH/gxoYRTZlIJdF0YPWuGqiAsIrhNnnqdXGswYk6dGujem4w80UJFhg==", "license": "MIT", "dependencies": { "debug": "2.6.9", "encodeurl": "~2.0.0", "escape-html": "~1.0.3", - "on-finished": "2.4.1", + "on-finished": "~2.4.1", "parseurl": "~1.3.3", - "statuses": "2.0.1", + "statuses": "~2.0.2", "unpipe": "~1.0.0" }, "engines": { @@ -10037,9 +10414,9 @@ } }, "node_modules/fs-extra": { - "version": "11.3.1", - "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.3.1.tgz", - "integrity": "sha512-eXvGGwZ5CL17ZSwHWd3bbgk7UUpF6IFHtP57NYYakPvHOs8GDgDe5KJI36jIJzDkJ6eJjuzRA8eBQb6SkKue0g==", + "version": "11.3.4", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.3.4.tgz", + "integrity": "sha512-CTXd6rk/M3/ULNQj8FBqBWHYBVYybQ3VPBw0xGKFe3tuH7ytT6ACnvzpIQ3UZtB8yvUKC2cXn1a+x+5EVQLovA==", "license": "MIT", "dependencies": { "graceful-fs": "^4.2.0", @@ -10197,9 +10574,9 @@ } }, "node_modules/glob-to-regex.js": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/glob-to-regex.js/-/glob-to-regex.js-1.0.1.tgz", - "integrity": "sha512-CG/iEvgQqfzoVsMUbxSJcwbG2JwyZ3naEqPkeltwl0BSS8Bp83k3xlGms+0QdWFUAwV+uvo80wNswKF6FWEkKg==", + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/glob-to-regex.js/-/glob-to-regex.js-1.2.0.tgz", + "integrity": "sha512-QMwlOQKU/IzqMUOAZWubUOT8Qft+Y0KQWnX9nK3ch0CJg0tTp4TvGZsTfudYKv2NzoQSyPcnA6TYeIQ3jGichQ==", "license": "Apache-2.0", "engines": { "node": ">=10.0" @@ -10233,18 +10610,6 @@ "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/globals": { - "version": "15.15.0", - "resolved": "https://registry.npmjs.org/globals/-/globals-15.15.0.tgz", - "integrity": "sha512-7ACyT3wmyp3I61S4fG682L0VA2RGD9otkqGJIwNUMF1SWUombIIk+af1unuDYgMm082aHYwD+mzJvv9Iu8dsgg==", - "license": "MIT", - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, "node_modules/globby": { "version": "11.1.0", "resolved": "https://registry.npmjs.org/globby/-/globby-11.1.0.tgz", @@ -10423,44 +10788,91 @@ "integrity": "sha512-8Rf9Y83NBReMnx0gFzA8JImQACstCYWUplepDa9xprwwtmgEZUF0h/i5xSA625zB/I37EtrswSST6OXxwaaIJQ==", "license": "ISC" }, - "node_modules/has-yarn": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/has-yarn/-/has-yarn-3.0.0.tgz", - "integrity": "sha512-IrsVwUHhEULx3R8f/aA8AHuEzAorplsab/v8HBzEiIukwq5i/EC+xmOW+HfP1OaDP+2JkgT1yILHN2O3UFIbcA==", + "node_modules/has-yarn": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-yarn/-/has-yarn-3.0.0.tgz", + "integrity": "sha512-IrsVwUHhEULx3R8f/aA8AHuEzAorplsab/v8HBzEiIukwq5i/EC+xmOW+HfP1OaDP+2JkgT1yILHN2O3UFIbcA==", + "license": "MIT", + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/hasown": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz", + "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==", + "license": "MIT", + "dependencies": { + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/hast-util-from-parse5": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/hast-util-from-parse5/-/hast-util-from-parse5-6.0.1.tgz", + "integrity": "sha512-jeJUWiN5pSxW12Rh01smtVkZgZr33wBokLzKLwinYOUfSzm1Nl/c3GUGebDyOKjdsRgMvoVbV0VpAcpjF4NrJA==", + "license": "MIT", + "dependencies": { + "@types/parse5": "^5.0.0", + "hastscript": "^6.0.0", + "property-information": "^5.0.0", + "vfile": "^4.0.0", + "vfile-location": "^3.2.0", + "web-namespaces": "^1.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/hast-util-from-parse5/node_modules/@types/unist": { + "version": "2.0.11", + "resolved": "https://registry.npmjs.org/@types/unist/-/unist-2.0.11.tgz", + "integrity": "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA==", + "license": "MIT" + }, + "node_modules/hast-util-from-parse5/node_modules/unist-util-stringify-position": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-2.0.3.tgz", + "integrity": "sha512-3faScn5I+hy9VleOq/qNbAd6pAx7iH5jYBMS9I1HgQVijz/4mv5Bvw5iw1sC/90CODiKo81G/ps8AJrISn687g==", "license": "MIT", - "engines": { - "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + "dependencies": { + "@types/unist": "^2.0.2" }, "funding": { - "url": "https://github.com/sponsors/sindresorhus" + "type": "opencollective", + "url": "https://opencollective.com/unified" } }, - "node_modules/hasown": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz", - "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==", + "node_modules/hast-util-from-parse5/node_modules/vfile": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/vfile/-/vfile-4.2.1.tgz", + "integrity": "sha512-O6AE4OskCG5S1emQ/4gl8zK586RqA3srz3nfK/Viy0UPToBc5Trp9BVFb1u0CjsKrAWwnpr4ifM/KBXPWwJbCA==", "license": "MIT", "dependencies": { - "function-bind": "^1.1.2" + "@types/unist": "^2.0.0", + "is-buffer": "^2.0.0", + "unist-util-stringify-position": "^2.0.0", + "vfile-message": "^2.0.0" }, - "engines": { - "node": ">= 0.4" + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" } }, - "node_modules/hast-util-from-parse5": { - "version": "8.0.3", - "resolved": "https://registry.npmjs.org/hast-util-from-parse5/-/hast-util-from-parse5-8.0.3.tgz", - "integrity": "sha512-3kxEVkEKt0zvcZ3hCRYI8rqrgwtlIOFMWkbclACvjlDw8Li9S2hk/d51OI0nr/gIpdMHNepwgOKqZ/sy0Clpyg==", + "node_modules/hast-util-from-parse5/node_modules/vfile-message": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/vfile-message/-/vfile-message-2.0.4.tgz", + "integrity": "sha512-DjssxRGkMvifUOJre00juHoP9DPWuzjxKuMDrhNbk2TdaYYBNMStsNhEOt3idrtI12VQYM/1+iM0KOzXi4pxwQ==", "license": "MIT", "dependencies": { - "@types/hast": "^3.0.0", - "@types/unist": "^3.0.0", - "devlop": "^1.0.0", - "hastscript": "^9.0.0", - "property-information": "^7.0.0", - "vfile": "^6.0.0", - "vfile-location": "^5.0.0", - "web-namespaces": "^2.0.0" + "@types/unist": "^2.0.0", + "unist-util-stringify-position": "^2.0.0" }, "funding": { "type": "opencollective", @@ -10488,13 +10900,10 @@ } }, "node_modules/hast-util-parse-selector": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/hast-util-parse-selector/-/hast-util-parse-selector-4.0.0.tgz", - "integrity": "sha512-wkQCkSYoOGCRKERFWcxMVMOcYE2K1AaNLU8DXS9arxnLOUEWbOXKXiJUNzEpqZ3JOKpnha3jkFrumEjVliDe7A==", + "version": "2.2.5", + "resolved": "https://registry.npmjs.org/hast-util-parse-selector/-/hast-util-parse-selector-2.2.5.tgz", + "integrity": "sha512-7j6mrk/qqkSehsM92wQjdIgWM2/BW61u/53G6xmC8i1OmEdKLHbk419QKQUjz6LglWsfqoiHmyMRkP1BGjecNQ==", "license": "MIT", - "dependencies": { - "@types/hast": "^3.0.0" - }, "funding": { "type": "opencollective", "url": "https://opencollective.com/unified" @@ -10525,91 +10934,152 @@ "url": "https://opencollective.com/unified" } }, - "node_modules/hast-util-select": { - "version": "4.0.2", - "resolved": "https://registry.npmjs.org/hast-util-select/-/hast-util-select-4.0.2.tgz", - "integrity": "sha512-8EEG2//bN5rrzboPWD2HdS3ugLijNioS1pqOTIolXNf67xxShYw4SQEmVXd3imiBG+U2bC2nVTySr/iRAA7Cjg==", + "node_modules/hast-util-raw/node_modules/comma-separated-tokens": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/comma-separated-tokens/-/comma-separated-tokens-2.0.3.tgz", + "integrity": "sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/hast-util-raw/node_modules/hast-util-from-parse5": { + "version": "8.0.3", + "resolved": "https://registry.npmjs.org/hast-util-from-parse5/-/hast-util-from-parse5-8.0.3.tgz", + "integrity": "sha512-3kxEVkEKt0zvcZ3hCRYI8rqrgwtlIOFMWkbclACvjlDw8Li9S2hk/d51OI0nr/gIpdMHNepwgOKqZ/sy0Clpyg==", "license": "MIT", "dependencies": { - "bcp-47-match": "^1.0.0", - "comma-separated-tokens": "^1.0.0", - "css-selector-parser": "^1.0.0", - "direction": "^1.0.0", - "hast-util-has-property": "^1.0.0", - "hast-util-is-element": "^1.0.0", - "hast-util-to-string": "^1.0.0", - "hast-util-whitespace": "^1.0.0", - "not": "^0.1.0", - "nth-check": "^2.0.0", - "property-information": "^5.0.0", - "space-separated-tokens": "^1.0.0", - "unist-util-visit": "^2.0.0", - "zwitch": "^1.0.0" + "@types/hast": "^3.0.0", + "@types/unist": "^3.0.0", + "devlop": "^1.0.0", + "hastscript": "^9.0.0", + "property-information": "^7.0.0", + "vfile": "^6.0.0", + "vfile-location": "^5.0.0", + "web-namespaces": "^2.0.0" }, "funding": { "type": "opencollective", "url": "https://opencollective.com/unified" } }, - "node_modules/hast-util-select/node_modules/@types/unist": { - "version": "2.0.11", - "resolved": "https://registry.npmjs.org/@types/unist/-/unist-2.0.11.tgz", - "integrity": "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA==", - "license": "MIT" + "node_modules/hast-util-raw/node_modules/hast-util-parse-selector": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/hast-util-parse-selector/-/hast-util-parse-selector-4.0.0.tgz", + "integrity": "sha512-wkQCkSYoOGCRKERFWcxMVMOcYE2K1AaNLU8DXS9arxnLOUEWbOXKXiJUNzEpqZ3JOKpnha3jkFrumEjVliDe7A==", + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } }, - "node_modules/hast-util-select/node_modules/comma-separated-tokens": { - "version": "1.0.8", - "resolved": "https://registry.npmjs.org/comma-separated-tokens/-/comma-separated-tokens-1.0.8.tgz", - "integrity": "sha512-GHuDRO12Sypu2cV70d1dkA2EUmXHgntrzbpvOB+Qy+49ypNfGgFQIC2fhhXbnyrJRynDCAARsT7Ou0M6hirpfw==", + "node_modules/hast-util-raw/node_modules/hastscript": { + "version": "9.0.1", + "resolved": "https://registry.npmjs.org/hastscript/-/hastscript-9.0.1.tgz", + "integrity": "sha512-g7df9rMFX/SPi34tyGCyUBREQoKkapwdY/T04Qn9TDWfHhAYt4/I0gMVirzK5wEzeUqIjEB+LXC/ypb7Aqno5w==", + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0", + "comma-separated-tokens": "^2.0.0", + "hast-util-parse-selector": "^4.0.0", + "property-information": "^7.0.0", + "space-separated-tokens": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/hast-util-raw/node_modules/property-information": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/property-information/-/property-information-7.1.0.tgz", + "integrity": "sha512-TwEZ+X+yCJmYfL7TPUOcvBZ4QfoT5YenQiJuX//0th53DE6w0xxLEtfK3iyryQFddXuvkIk51EEgrJQ0WJkOmQ==", "license": "MIT", "funding": { "type": "github", "url": "https://github.com/sponsors/wooorm" } }, - "node_modules/hast-util-select/node_modules/hast-util-whitespace": { - "version": "1.0.4", - "resolved": "https://registry.npmjs.org/hast-util-whitespace/-/hast-util-whitespace-1.0.4.tgz", - "integrity": "sha512-I5GTdSfhYfAPNztx2xJRQpG8cuDSNt599/7YUn7Gx/WxNMsG+a835k97TDkFgk123cwjfwINaZknkKkphx/f2A==", + "node_modules/hast-util-raw/node_modules/space-separated-tokens": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/space-separated-tokens/-/space-separated-tokens-2.0.2.tgz", + "integrity": "sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q==", "license": "MIT", "funding": { - "type": "opencollective", - "url": "https://opencollective.com/unified" + "type": "github", + "url": "https://github.com/sponsors/wooorm" } }, - "node_modules/hast-util-select/node_modules/property-information": { - "version": "5.6.0", - "resolved": "https://registry.npmjs.org/property-information/-/property-information-5.6.0.tgz", - "integrity": "sha512-YUHSPk+A30YPv+0Qf8i9Mbfe/C0hdPXk1s1jPVToV8pk8BQtpw10ct89Eo7OWkutrwqvT0eicAxlOg3dOAu8JA==", + "node_modules/hast-util-raw/node_modules/vfile-location": { + "version": "5.0.3", + "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-5.0.3.tgz", + "integrity": "sha512-5yXvWDEgqeiYiBe1lbxYF7UMAIm/IcopxMHrMQDq3nvKcjPKIhZklUKL+AE7J7uApI4kwe2snsK+eI6UTj9EHg==", "license": "MIT", "dependencies": { - "xtend": "^4.0.0" + "@types/unist": "^3.0.0", + "vfile": "^6.0.0" }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/hast-util-raw/node_modules/web-namespaces": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/web-namespaces/-/web-namespaces-2.0.1.tgz", + "integrity": "sha512-bKr1DkiNa2krS7qxNtdrtHAmzuYGFQLiQ13TsorsdT6ULTkPLKuu5+GsFpDlg6JFjUTwX2DyhMPG2be8uPrqsQ==", + "license": "MIT", "funding": { "type": "github", "url": "https://github.com/sponsors/wooorm" } }, - "node_modules/hast-util-select/node_modules/space-separated-tokens": { - "version": "1.1.5", - "resolved": "https://registry.npmjs.org/space-separated-tokens/-/space-separated-tokens-1.1.5.tgz", - "integrity": "sha512-q/JSVd1Lptzhf5bkYm4ob4iWPjx0KiRe3sRFBNrVqbJkFaBm5vbbowy1mymoPNLRa52+oadOhJ+K49wsSeSjTA==", + "node_modules/hast-util-raw/node_modules/zwitch": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/zwitch/-/zwitch-2.0.4.tgz", + "integrity": "sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A==", "license": "MIT", "funding": { "type": "github", "url": "https://github.com/sponsors/wooorm" } }, - "node_modules/hast-util-select/node_modules/unist-util-is": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-4.1.0.tgz", - "integrity": "sha512-ZOQSsnce92GrxSqlnEEseX0gi7GH9zTJZ0p9dtu87WRb/37mMPO2Ilx1s/t9vBHrFhbgweUwb+t7cIn5dxPhZg==", + "node_modules/hast-util-select": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/hast-util-select/-/hast-util-select-4.0.2.tgz", + "integrity": "sha512-8EEG2//bN5rrzboPWD2HdS3ugLijNioS1pqOTIolXNf67xxShYw4SQEmVXd3imiBG+U2bC2nVTySr/iRAA7Cjg==", "license": "MIT", + "dependencies": { + "bcp-47-match": "^1.0.0", + "comma-separated-tokens": "^1.0.0", + "css-selector-parser": "^1.0.0", + "direction": "^1.0.0", + "hast-util-has-property": "^1.0.0", + "hast-util-is-element": "^1.0.0", + "hast-util-to-string": "^1.0.0", + "hast-util-whitespace": "^1.0.0", + "not": "^0.1.0", + "nth-check": "^2.0.0", + "property-information": "^5.0.0", + "space-separated-tokens": "^1.0.0", + "unist-util-visit": "^2.0.0", + "zwitch": "^1.0.0" + }, "funding": { "type": "opencollective", "url": "https://opencollective.com/unified" } }, + "node_modules/hast-util-select/node_modules/@types/unist": { + "version": "2.0.11", + "resolved": "https://registry.npmjs.org/@types/unist/-/unist-2.0.11.tgz", + "integrity": "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA==", + "license": "MIT" + }, "node_modules/hast-util-select/node_modules/unist-util-visit": { "version": "2.0.3", "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-2.0.3.tgz", @@ -10639,16 +11109,6 @@ "url": "https://opencollective.com/unified" } }, - "node_modules/hast-util-select/node_modules/zwitch": { - "version": "1.0.5", - "resolved": "https://registry.npmjs.org/zwitch/-/zwitch-1.0.5.tgz", - "integrity": "sha512-V50KMwwzqJV0NpZIZFwfOD5/lyny3WlSzRiXgA0G7VUnRlqttta1L6UQIHzd6EuBY/cHGfwTIck7w1yH6Q5zUw==", - "license": "MIT", - "funding": { - "type": "github", - "url": "https://github.com/sponsors/wooorm" - } - }, "node_modules/hast-util-to-estree": { "version": "3.1.3", "resolved": "https://registry.npmjs.org/hast-util-to-estree/-/hast-util-to-estree-3.1.3.tgz", @@ -10673,8 +11133,61 @@ "zwitch": "^2.0.0" }, "funding": { - "type": "opencollective", - "url": "https://opencollective.com/unified" + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/hast-util-to-estree/node_modules/comma-separated-tokens": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/comma-separated-tokens/-/comma-separated-tokens-2.0.3.tgz", + "integrity": "sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/hast-util-to-estree/node_modules/hast-util-whitespace": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/hast-util-whitespace/-/hast-util-whitespace-3.0.0.tgz", + "integrity": "sha512-88JUN06ipLwsnv+dVn+OIYOvAuvBMy/Qoi6O7mQHxdPXpjy+Cd6xRkWwux7DKO+4sYILtLBRIKgsdpS2gQc7qw==", + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/hast-util-to-estree/node_modules/property-information": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/property-information/-/property-information-7.1.0.tgz", + "integrity": "sha512-TwEZ+X+yCJmYfL7TPUOcvBZ4QfoT5YenQiJuX//0th53DE6w0xxLEtfK3iyryQFddXuvkIk51EEgrJQ0WJkOmQ==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/hast-util-to-estree/node_modules/space-separated-tokens": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/space-separated-tokens/-/space-separated-tokens-2.0.2.tgz", + "integrity": "sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/hast-util-to-estree/node_modules/zwitch": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/zwitch/-/zwitch-2.0.4.tgz", + "integrity": "sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" } }, "node_modules/hast-util-to-jsx-runtime": { @@ -10704,16 +11217,59 @@ "url": "https://opencollective.com/unified" } }, + "node_modules/hast-util-to-jsx-runtime/node_modules/comma-separated-tokens": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/comma-separated-tokens/-/comma-separated-tokens-2.0.3.tgz", + "integrity": "sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/hast-util-to-jsx-runtime/node_modules/hast-util-whitespace": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/hast-util-whitespace/-/hast-util-whitespace-3.0.0.tgz", + "integrity": "sha512-88JUN06ipLwsnv+dVn+OIYOvAuvBMy/Qoi6O7mQHxdPXpjy+Cd6xRkWwux7DKO+4sYILtLBRIKgsdpS2gQc7qw==", + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/hast-util-to-jsx-runtime/node_modules/property-information": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/property-information/-/property-information-7.1.0.tgz", + "integrity": "sha512-TwEZ+X+yCJmYfL7TPUOcvBZ4QfoT5YenQiJuX//0th53DE6w0xxLEtfK3iyryQFddXuvkIk51EEgrJQ0WJkOmQ==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/hast-util-to-jsx-runtime/node_modules/space-separated-tokens": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/space-separated-tokens/-/space-separated-tokens-2.0.2.tgz", + "integrity": "sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, "node_modules/hast-util-to-parse5": { - "version": "8.0.0", - "resolved": "https://registry.npmjs.org/hast-util-to-parse5/-/hast-util-to-parse5-8.0.0.tgz", - "integrity": "sha512-3KKrV5ZVI8if87DVSi1vDeByYrkGzg4mEfeu4alwgmmIeARiBLKCZS2uw5Gb6nU9x9Yufyj3iudm6i7nl52PFw==", + "version": "8.0.1", + "resolved": "https://registry.npmjs.org/hast-util-to-parse5/-/hast-util-to-parse5-8.0.1.tgz", + "integrity": "sha512-MlWT6Pjt4CG9lFCjiz4BH7l9wmrMkfkJYCxFwKQic8+RTZgWPuWxwAfjJElsXkex7DJjfSJsQIt931ilUgmwdA==", "license": "MIT", "dependencies": { "@types/hast": "^3.0.0", "comma-separated-tokens": "^2.0.0", "devlop": "^1.0.0", - "property-information": "^6.0.0", + "property-information": "^7.0.0", "space-separated-tokens": "^2.0.0", "web-namespaces": "^2.0.0", "zwitch": "^2.0.0" @@ -10723,10 +11279,50 @@ "url": "https://opencollective.com/unified" } }, + "node_modules/hast-util-to-parse5/node_modules/comma-separated-tokens": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/comma-separated-tokens/-/comma-separated-tokens-2.0.3.tgz", + "integrity": "sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, "node_modules/hast-util-to-parse5/node_modules/property-information": { - "version": "6.5.0", - "resolved": "https://registry.npmjs.org/property-information/-/property-information-6.5.0.tgz", - "integrity": "sha512-PgTgs/BlvHxOu8QuEN7wi5A0OmXaBcHpmCSTehcs6Uuu9IkDIEo13Hy7n898RHfrQ49vKCoGeWZSaAK01nwVig==", + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/property-information/-/property-information-7.1.0.tgz", + "integrity": "sha512-TwEZ+X+yCJmYfL7TPUOcvBZ4QfoT5YenQiJuX//0th53DE6w0xxLEtfK3iyryQFddXuvkIk51EEgrJQ0WJkOmQ==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/hast-util-to-parse5/node_modules/space-separated-tokens": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/space-separated-tokens/-/space-separated-tokens-2.0.2.tgz", + "integrity": "sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/hast-util-to-parse5/node_modules/web-namespaces": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/web-namespaces/-/web-namespaces-2.0.1.tgz", + "integrity": "sha512-bKr1DkiNa2krS7qxNtdrtHAmzuYGFQLiQ13TsorsdT6ULTkPLKuu5+GsFpDlg6JFjUTwX2DyhMPG2be8uPrqsQ==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/hast-util-to-parse5/node_modules/zwitch": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/zwitch/-/zwitch-2.0.4.tgz", + "integrity": "sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A==", "license": "MIT", "funding": { "type": "github", @@ -10759,35 +11355,47 @@ } }, "node_modules/hast-util-whitespace": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/hast-util-whitespace/-/hast-util-whitespace-3.0.0.tgz", - "integrity": "sha512-88JUN06ipLwsnv+dVn+OIYOvAuvBMy/Qoi6O7mQHxdPXpjy+Cd6xRkWwux7DKO+4sYILtLBRIKgsdpS2gQc7qw==", + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/hast-util-whitespace/-/hast-util-whitespace-1.0.4.tgz", + "integrity": "sha512-I5GTdSfhYfAPNztx2xJRQpG8cuDSNt599/7YUn7Gx/WxNMsG+a835k97TDkFgk123cwjfwINaZknkKkphx/f2A==", "license": "MIT", - "dependencies": { - "@types/hast": "^3.0.0" - }, "funding": { "type": "opencollective", "url": "https://opencollective.com/unified" } }, "node_modules/hastscript": { - "version": "9.0.1", - "resolved": "https://registry.npmjs.org/hastscript/-/hastscript-9.0.1.tgz", - "integrity": "sha512-g7df9rMFX/SPi34tyGCyUBREQoKkapwdY/T04Qn9TDWfHhAYt4/I0gMVirzK5wEzeUqIjEB+LXC/ypb7Aqno5w==", + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/hastscript/-/hastscript-6.0.0.tgz", + "integrity": "sha512-nDM6bvd7lIqDUiYEiu5Sl/+6ReP0BMk/2f4U/Rooccxkj0P5nm+acM5PrGJ/t5I8qPGiqZSE6hVAwZEdZIvP4w==", "license": "MIT", "dependencies": { - "@types/hast": "^3.0.0", - "comma-separated-tokens": "^2.0.0", - "hast-util-parse-selector": "^4.0.0", - "property-information": "^7.0.0", - "space-separated-tokens": "^2.0.0" + "@types/hast": "^2.0.0", + "comma-separated-tokens": "^1.0.0", + "hast-util-parse-selector": "^2.0.0", + "property-information": "^5.0.0", + "space-separated-tokens": "^1.0.0" }, "funding": { "type": "opencollective", "url": "https://opencollective.com/unified" } }, + "node_modules/hastscript/node_modules/@types/hast": { + "version": "2.3.10", + "resolved": "https://registry.npmjs.org/@types/hast/-/hast-2.3.10.tgz", + "integrity": "sha512-McWspRw8xx8J9HurkVBfYj0xKoE25tOFlHGdx4MJ5xORQrMGZNqJhVQWaIbm6Oyla5kYOXtDiopzKRJzEOkwJw==", + "license": "MIT", + "dependencies": { + "@types/unist": "^2" + } + }, + "node_modules/hastscript/node_modules/@types/unist": { + "version": "2.0.11", + "resolved": "https://registry.npmjs.org/@types/unist/-/unist-2.0.11.tgz", + "integrity": "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA==", + "license": "MIT" + }, "node_modules/he": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/he/-/he-1.2.0.tgz", @@ -10823,16 +11431,6 @@ "hulk": "bin/hulk" } }, - "node_modules/hogan.js/node_modules/mkdirp": { - "version": "0.3.0", - "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.3.0.tgz", - "integrity": "sha512-OHsdUcVAQ6pOtg5JYWpCBo9W/GySVuwvP9hueRMW7UqshC0tbfzLv8wjySTPm3tfUZ/21CE9E1pJagOA91Pxew==", - "deprecated": "Legacy versions of mkdirp are no longer supported. Please update to mkdirp 1.x. (Note that the API surface has changed to use Promises in 1.x.)", - "license": "MIT/X11", - "engines": { - "node": "*" - } - }, "node_modules/hoist-non-react-statics": { "version": "3.3.2", "resolved": "https://registry.npmjs.org/hoist-non-react-statics/-/hoist-non-react-statics-3.3.2.tgz", @@ -10949,9 +11547,9 @@ } }, "node_modules/html-webpack-plugin": { - "version": "5.6.4", - "resolved": "https://registry.npmjs.org/html-webpack-plugin/-/html-webpack-plugin-5.6.4.tgz", - "integrity": "sha512-V/PZeWsqhfpE27nKeX9EO2sbR+D17A+tLf6qU+ht66jdUsN0QLKJN27Z+1+gHrVMKgndBahes0PU6rRihDgHTw==", + "version": "5.6.6", + "resolved": "https://registry.npmjs.org/html-webpack-plugin/-/html-webpack-plugin-5.6.6.tgz", + "integrity": "sha512-bLjW01UTrvoWTJQL5LsMRo1SypHW80FTm12OJRSnr3v6YHNhfe+1r0MYUZJMACxnCHURVnBWRwAsWs2yPU9Ezw==", "license": "MIT", "dependencies": { "@types/html-minifier-terser": "^6.0.0", @@ -11042,19 +11640,23 @@ "license": "MIT" }, "node_modules/http-errors": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz", - "integrity": "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==", + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.1.tgz", + "integrity": "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==", "license": "MIT", "dependencies": { - "depd": "2.0.0", - "inherits": "2.0.4", - "setprototypeof": "1.2.0", - "statuses": "2.0.1", - "toidentifier": "1.0.1" + "depd": "~2.0.0", + "inherits": "~2.0.4", + "setprototypeof": "~1.2.0", + "statuses": "~2.0.2", + "toidentifier": "~1.0.1" }, "engines": { "node": ">= 0.8" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" } }, "node_modules/http-parser-js": { @@ -11145,12 +11747,12 @@ } }, "node_modules/iconv-lite": { - "version": "0.4.24", - "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz", - "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==", + "version": "0.6.3", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz", + "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==", "license": "MIT", "dependencies": { - "safer-buffer": ">= 2.1.2 < 3" + "safer-buffer": ">= 2.1.2 < 3.0.0" }, "engines": { "node": ">=0.10.0" @@ -11287,9 +11889,9 @@ } }, "node_modules/ipaddr.js": { - "version": "2.2.0", - "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-2.2.0.tgz", - "integrity": "sha512-Ag3wB2o37wslZS19hZqorUnrnzSkpOVy+IiiDEiTqNubEYpYuHWIf6K4psgN2ZWKExS4xhVCrRVfb/wfW8fWJA==", + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-2.3.0.tgz", + "integrity": "sha512-Zv/pA+ciVFbCSBBjGfaKUya/CcGmUHzTydLMaTwrUUEM2DIEO3iZvueGxmacvmN50fGpGVKeTXpb2LcYQxeVdg==", "license": "MIT", "engines": { "node": ">= 10" @@ -11511,9 +12113,9 @@ } }, "node_modules/is-network-error": { - "version": "1.3.0", - "resolved": "https://registry.npmjs.org/is-network-error/-/is-network-error-1.3.0.tgz", - "integrity": "sha512-6oIwpsgRfnDiyEDLMay/GqCl3HoAtH5+RUKW29gYkL0QA+ipzpDLA16yQs7/RHCSu+BwgbJaOUqa4A99qNVQVw==", + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/is-network-error/-/is-network-error-1.3.1.tgz", + "integrity": "sha512-6QCxa49rQbmUWLfk0nuGqzql9U8uaV2H6279bRErPBHe/109hCzsLUBUHfbEtvLIHBd6hyXbgedBSHevm43Edw==", "license": "MIT", "engines": { "node": ">=16" @@ -11523,9 +12125,9 @@ } }, "node_modules/is-npm": { - "version": "6.0.0", - "resolved": "https://registry.npmjs.org/is-npm/-/is-npm-6.0.0.tgz", - "integrity": "sha512-JEjxbSmtPSt1c8XTkVrlujcXdKV1/tvuQ7GwKcAlyiVLeYFQ2VHat8xfrDJsIkhCdF/tZ7CiIR3sy141c6+gPQ==", + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/is-npm/-/is-npm-6.1.0.tgz", + "integrity": "sha512-O2z4/kNgyjhQwVR1Wpkbfc19JIhggF97NZNCpWTnjH7kVcZMUrnut9XSN7txI7VdyIYk5ZatOq3zvSuWpU8hoA==", "license": "MIT", "engines": { "node": "^12.20.0 || ^14.13.1 || >=16.0.0" @@ -11765,12 +12367,6 @@ "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==", "license": "MIT" }, - "node_modules/json-schema": { - "version": "0.4.0", - "resolved": "https://registry.npmjs.org/json-schema/-/json-schema-0.4.0.tgz", - "integrity": "sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA==", - "license": "(AFL-2.1 OR BSD-3-Clause)" - }, "node_modules/json-schema-traverse": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", @@ -11802,9 +12398,9 @@ } }, "node_modules/katex": { - "version": "0.16.22", - "resolved": "https://registry.npmjs.org/katex/-/katex-0.16.22.tgz", - "integrity": "sha512-XCHRdUw4lf3SKBaJe4EvgqIuWwkPSo9XoeO8GjQW94Bp7TWv9hNhzZjZ+OH9yf1UmLygb7DIT5GSFQiyt16zYg==", + "version": "0.16.35", + "resolved": "https://registry.npmjs.org/katex/-/katex-0.16.35.tgz", + "integrity": "sha512-S0+riEvy1CK4VKse1ivMff8gmabe/prY7sKB3njjhyoLLsNFDQYtKNgXrbWUggGDCJBz7Fctl5i8fLCESHXzSg==", "funding": [ "https://opencollective.com/katex", "https://github.com/sponsors/katex" @@ -11858,26 +12454,21 @@ "node": ">=6" } }, - "node_modules/kolorist": { - "version": "1.8.0", - "resolved": "https://registry.npmjs.org/kolorist/-/kolorist-1.8.0.tgz", - "integrity": "sha512-Y+60/zizpJ3HRH8DCss+q95yr6145JXZo46OTpFvDZWLfRCE4qChOyk1b26nMaNpfHHgxagk9dXT5OP0Tfe+dQ==", - "license": "MIT" - }, "node_modules/langium": { - "version": "3.3.1", - "resolved": "https://registry.npmjs.org/langium/-/langium-3.3.1.tgz", - "integrity": "sha512-QJv/h939gDpvT+9SiLVlY7tZC3xB2qK57v0J04Sh9wpMb6MP1q8gB21L3WIo8T5P1MSMg3Ep14L7KkDCFG3y4w==", + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/langium/-/langium-4.2.1.tgz", + "integrity": "sha512-zu9QWmjpzJcomzdJQAHgDVhLGq5bLosVak1KVa40NzQHXfqr4eAHupvnPOVXEoLkg6Ocefvf/93d//SB7du4YQ==", "license": "MIT", "dependencies": { - "chevrotain": "~11.0.3", - "chevrotain-allstar": "~0.3.0", + "chevrotain": "~11.1.1", + "chevrotain-allstar": "~0.3.1", "vscode-languageserver": "~9.0.1", "vscode-languageserver-textdocument": "~1.0.11", - "vscode-uri": "~3.0.8" + "vscode-uri": "~3.1.0" }, "engines": { - "node": ">=16.0.0" + "node": ">=20.10.0", + "npm": ">=10.2.3" } }, "node_modules/latest-version": { @@ -11896,9 +12487,9 @@ } }, "node_modules/launch-editor": { - "version": "2.11.1", - "resolved": "https://registry.npmjs.org/launch-editor/-/launch-editor-2.11.1.tgz", - "integrity": "sha512-SEET7oNfgSaB6Ym0jufAdCeo3meJVeCaaDyzRygy0xsp2BFKCprcfHljTq4QkzTLUxEKkFK6OK4811YM2oSrRg==", + "version": "2.13.1", + "resolved": "https://registry.npmjs.org/launch-editor/-/launch-editor-2.13.1.tgz", + "integrity": "sha512-lPSddlAAluRKJ7/cjRFoXUFzaX7q/YKI7yPHuEvSJVqoXvFnJov1/Ud87Aa4zULIbA9Nja4mSPK8l0z/7eV2wA==", "license": "MIT", "dependencies": { "picocolors": "^1.1.1", @@ -11921,9 +12512,9 @@ } }, "node_modules/lightningcss": { - "version": "1.30.2", - "resolved": "https://registry.npmjs.org/lightningcss/-/lightningcss-1.30.2.tgz", - "integrity": "sha512-utfs7Pr5uJyyvDETitgsaqSyjCb2qNRAtuqUeWIAKztsOYdcACf2KtARYXg2pSvhkt+9NfoaNY7fxjl6nuMjIQ==", + "version": "1.31.1", + "resolved": "https://registry.npmjs.org/lightningcss/-/lightningcss-1.31.1.tgz", + "integrity": "sha512-l51N2r93WmGUye3WuFoN5k10zyvrVs0qfKBhyC5ogUQ6Ew6JUSswh78mbSO+IU3nTWsyOArqPCcShdQSadghBQ==", "dev": true, "license": "MPL-2.0", "dependencies": { @@ -11937,23 +12528,23 @@ "url": "https://opencollective.com/parcel" }, "optionalDependencies": { - "lightningcss-android-arm64": "1.30.2", - "lightningcss-darwin-arm64": "1.30.2", - "lightningcss-darwin-x64": "1.30.2", - "lightningcss-freebsd-x64": "1.30.2", - "lightningcss-linux-arm-gnueabihf": "1.30.2", - "lightningcss-linux-arm64-gnu": "1.30.2", - "lightningcss-linux-arm64-musl": "1.30.2", - "lightningcss-linux-x64-gnu": "1.30.2", - "lightningcss-linux-x64-musl": "1.30.2", - "lightningcss-win32-arm64-msvc": "1.30.2", - "lightningcss-win32-x64-msvc": "1.30.2" + "lightningcss-android-arm64": "1.31.1", + "lightningcss-darwin-arm64": "1.31.1", + "lightningcss-darwin-x64": "1.31.1", + "lightningcss-freebsd-x64": "1.31.1", + "lightningcss-linux-arm-gnueabihf": "1.31.1", + "lightningcss-linux-arm64-gnu": "1.31.1", + "lightningcss-linux-arm64-musl": "1.31.1", + "lightningcss-linux-x64-gnu": "1.31.1", + "lightningcss-linux-x64-musl": "1.31.1", + "lightningcss-win32-arm64-msvc": "1.31.1", + "lightningcss-win32-x64-msvc": "1.31.1" } }, "node_modules/lightningcss-android-arm64": { - "version": "1.30.2", - "resolved": "https://registry.npmjs.org/lightningcss-android-arm64/-/lightningcss-android-arm64-1.30.2.tgz", - "integrity": "sha512-BH9sEdOCahSgmkVhBLeU7Hc9DWeZ1Eb6wNS6Da8igvUwAe0sqROHddIlvU06q3WyXVEOYDZ6ykBZQnjTbmo4+A==", + "version": "1.31.1", + "resolved": "https://registry.npmjs.org/lightningcss-android-arm64/-/lightningcss-android-arm64-1.31.1.tgz", + "integrity": "sha512-HXJF3x8w9nQ4jbXRiNppBCqeZPIAfUo8zE/kOEGbW5NZvGc/K7nMxbhIr+YlFlHW5mpbg/YFPdbnCh1wAXCKFg==", "cpu": [ "arm64" ], @@ -11972,9 +12563,9 @@ } }, "node_modules/lightningcss-darwin-arm64": { - "version": "1.30.2", - "resolved": "https://registry.npmjs.org/lightningcss-darwin-arm64/-/lightningcss-darwin-arm64-1.30.2.tgz", - "integrity": "sha512-ylTcDJBN3Hp21TdhRT5zBOIi73P6/W0qwvlFEk22fkdXchtNTOU4Qc37SkzV+EKYxLouZ6M4LG9NfZ1qkhhBWA==", + "version": "1.31.1", + "resolved": "https://registry.npmjs.org/lightningcss-darwin-arm64/-/lightningcss-darwin-arm64-1.31.1.tgz", + "integrity": "sha512-02uTEqf3vIfNMq3h/z2cJfcOXnQ0GRwQrkmPafhueLb2h7mqEidiCzkE4gBMEH65abHRiQvhdcQ+aP0D0g67sg==", "cpu": [ "arm64" ], @@ -11993,9 +12584,9 @@ } }, "node_modules/lightningcss-darwin-x64": { - "version": "1.30.2", - "resolved": "https://registry.npmjs.org/lightningcss-darwin-x64/-/lightningcss-darwin-x64-1.30.2.tgz", - "integrity": "sha512-oBZgKchomuDYxr7ilwLcyms6BCyLn0z8J0+ZZmfpjwg9fRVZIR5/GMXd7r9RH94iDhld3UmSjBM6nXWM2TfZTQ==", + "version": "1.31.1", + "resolved": "https://registry.npmjs.org/lightningcss-darwin-x64/-/lightningcss-darwin-x64-1.31.1.tgz", + "integrity": "sha512-1ObhyoCY+tGxtsz1lSx5NXCj3nirk0Y0kB/g8B8DT+sSx4G9djitg9ejFnjb3gJNWo7qXH4DIy2SUHvpoFwfTA==", "cpu": [ "x64" ], @@ -12014,9 +12605,9 @@ } }, "node_modules/lightningcss-freebsd-x64": { - "version": "1.30.2", - "resolved": "https://registry.npmjs.org/lightningcss-freebsd-x64/-/lightningcss-freebsd-x64-1.30.2.tgz", - "integrity": "sha512-c2bH6xTrf4BDpK8MoGG4Bd6zAMZDAXS569UxCAGcA7IKbHNMlhGQ89eRmvpIUGfKWNVdbhSbkQaWhEoMGmGslA==", + "version": "1.31.1", + "resolved": "https://registry.npmjs.org/lightningcss-freebsd-x64/-/lightningcss-freebsd-x64-1.31.1.tgz", + "integrity": "sha512-1RINmQKAItO6ISxYgPwszQE1BrsVU5aB45ho6O42mu96UiZBxEXsuQ7cJW4zs4CEodPUioj/QrXW1r9pLUM74A==", "cpu": [ "x64" ], @@ -12035,9 +12626,9 @@ } }, "node_modules/lightningcss-linux-arm-gnueabihf": { - "version": "1.30.2", - "resolved": "https://registry.npmjs.org/lightningcss-linux-arm-gnueabihf/-/lightningcss-linux-arm-gnueabihf-1.30.2.tgz", - "integrity": "sha512-eVdpxh4wYcm0PofJIZVuYuLiqBIakQ9uFZmipf6LF/HRj5Bgm0eb3qL/mr1smyXIS1twwOxNWndd8z0E374hiA==", + "version": "1.31.1", + "resolved": "https://registry.npmjs.org/lightningcss-linux-arm-gnueabihf/-/lightningcss-linux-arm-gnueabihf-1.31.1.tgz", + "integrity": "sha512-OOCm2//MZJ87CdDK62rZIu+aw9gBv4azMJuA8/KB74wmfS3lnC4yoPHm0uXZ/dvNNHmnZnB8XLAZzObeG0nS1g==", "cpu": [ "arm" ], @@ -12056,9 +12647,9 @@ } }, "node_modules/lightningcss-linux-arm64-gnu": { - "version": "1.30.2", - "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-gnu/-/lightningcss-linux-arm64-gnu-1.30.2.tgz", - "integrity": "sha512-UK65WJAbwIJbiBFXpxrbTNArtfuznvxAJw4Q2ZGlU8kPeDIWEX1dg3rn2veBVUylA2Ezg89ktszWbaQnxD/e3A==", + "version": "1.31.1", + "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-gnu/-/lightningcss-linux-arm64-gnu-1.31.1.tgz", + "integrity": "sha512-WKyLWztD71rTnou4xAD5kQT+982wvca7E6QoLpoawZ1gP9JM0GJj4Tp5jMUh9B3AitHbRZ2/H3W5xQmdEOUlLg==", "cpu": [ "arm64" ], @@ -12077,9 +12668,9 @@ } }, "node_modules/lightningcss-linux-arm64-musl": { - "version": "1.30.2", - "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-musl/-/lightningcss-linux-arm64-musl-1.30.2.tgz", - "integrity": "sha512-5Vh9dGeblpTxWHpOx8iauV02popZDsCYMPIgiuw97OJ5uaDsL86cnqSFs5LZkG3ghHoX5isLgWzMs+eD1YzrnA==", + "version": "1.31.1", + "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-musl/-/lightningcss-linux-arm64-musl-1.31.1.tgz", + "integrity": "sha512-mVZ7Pg2zIbe3XlNbZJdjs86YViQFoJSpc41CbVmKBPiGmC4YrfeOyz65ms2qpAobVd7WQsbW4PdsSJEMymyIMg==", "cpu": [ "arm64" ], @@ -12098,9 +12689,9 @@ } }, "node_modules/lightningcss-linux-x64-gnu": { - "version": "1.30.2", - "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-gnu/-/lightningcss-linux-x64-gnu-1.30.2.tgz", - "integrity": "sha512-Cfd46gdmj1vQ+lR6VRTTadNHu6ALuw2pKR9lYq4FnhvgBc4zWY1EtZcAc6EffShbb1MFrIPfLDXD6Xprbnni4w==", + "version": "1.31.1", + "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-gnu/-/lightningcss-linux-x64-gnu-1.31.1.tgz", + "integrity": "sha512-xGlFWRMl+0KvUhgySdIaReQdB4FNudfUTARn7q0hh/V67PVGCs3ADFjw+6++kG1RNd0zdGRlEKa+T13/tQjPMA==", "cpu": [ "x64" ], @@ -12119,9 +12710,9 @@ } }, "node_modules/lightningcss-linux-x64-musl": { - "version": "1.30.2", - "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-musl/-/lightningcss-linux-x64-musl-1.30.2.tgz", - "integrity": "sha512-XJaLUUFXb6/QG2lGIW6aIk6jKdtjtcffUT0NKvIqhSBY3hh9Ch+1LCeH80dR9q9LBjG3ewbDjnumefsLsP6aiA==", + "version": "1.31.1", + "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-musl/-/lightningcss-linux-x64-musl-1.31.1.tgz", + "integrity": "sha512-eowF8PrKHw9LpoZii5tdZwnBcYDxRw2rRCyvAXLi34iyeYfqCQNA9rmUM0ce62NlPhCvof1+9ivRaTY6pSKDaA==", "cpu": [ "x64" ], @@ -12140,9 +12731,9 @@ } }, "node_modules/lightningcss-win32-arm64-msvc": { - "version": "1.30.2", - "resolved": "https://registry.npmjs.org/lightningcss-win32-arm64-msvc/-/lightningcss-win32-arm64-msvc-1.30.2.tgz", - "integrity": "sha512-FZn+vaj7zLv//D/192WFFVA0RgHawIcHqLX9xuWiQt7P0PtdFEVaxgF9rjM/IRYHQXNnk61/H/gb2Ei+kUQ4xQ==", + "version": "1.31.1", + "resolved": "https://registry.npmjs.org/lightningcss-win32-arm64-msvc/-/lightningcss-win32-arm64-msvc-1.31.1.tgz", + "integrity": "sha512-aJReEbSEQzx1uBlQizAOBSjcmr9dCdL3XuC/6HLXAxmtErsj2ICo5yYggg1qOODQMtnjNQv2UHb9NpOuFtYe4w==", "cpu": [ "arm64" ], @@ -12161,9 +12752,9 @@ } }, "node_modules/lightningcss-win32-x64-msvc": { - "version": "1.30.2", - "resolved": "https://registry.npmjs.org/lightningcss-win32-x64-msvc/-/lightningcss-win32-x64-msvc-1.30.2.tgz", - "integrity": "sha512-5g1yc73p+iAkid5phb4oVFMB45417DkRevRbt/El/gKXJk4jid+vPFF/AXbxn05Aky8PapwzZrdJShv5C0avjw==", + "version": "1.31.1", + "resolved": "https://registry.npmjs.org/lightningcss-win32-x64-msvc/-/lightningcss-win32-x64-msvc-1.31.1.tgz", + "integrity": "sha512-I9aiFrbd7oYHwlnQDqr1Roz+fTz61oDDJX7n9tYF9FJymH1cIN1DtKw3iYt6b8WZgEjoNwVSncwF4wx/ZedMhw==", "cpu": [ "x64" ], @@ -12226,23 +12817,6 @@ "node": ">=8.9.0" } }, - "node_modules/local-pkg": { - "version": "1.1.2", - "resolved": "https://registry.npmjs.org/local-pkg/-/local-pkg-1.1.2.tgz", - "integrity": "sha512-arhlxbFRmoQHl33a0Zkle/YWlmNwoyt6QNZEIJcqNbdrsix5Lvc4HyyI3EnwxTYlZYc32EbYrQ8SzEZ7dqgg9A==", - "license": "MIT", - "dependencies": { - "mlly": "^1.7.4", - "pkg-types": "^2.3.0", - "quansync": "^0.2.11" - }, - "engines": { - "node": ">=14" - }, - "funding": { - "url": "https://github.com/sponsors/antfu" - } - }, "node_modules/locate-path": { "version": "7.2.0", "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-7.2.0.tgz", @@ -12265,9 +12839,9 @@ "license": "MIT" }, "node_modules/lodash-es": { - "version": "4.17.21", - "resolved": "https://registry.npmjs.org/lodash-es/-/lodash-es-4.17.21.tgz", - "integrity": "sha512-mKnC+QJ9pWVzv+C4/U3rRsHapFfHvQFoFB92e52xeyGMcX6/OlIl78je1u8vePzYZSkkogMPJ2yjxxsb89cxyw==", + "version": "4.17.23", + "resolved": "https://registry.npmjs.org/lodash-es/-/lodash-es-4.17.23.tgz", + "integrity": "sha512-kVI48u3PZr38HdYz98UmfPnXl2DXrpdctLrFLCd3kOx1xUkOmpFPx7gCWWM5MPkL/fD8zb+Ph0QzjGFs4+hHWg==", "license": "MIT" }, "node_modules/lodash.debounce": { @@ -12460,10 +13034,23 @@ "url": "https://github.com/sponsors/sindresorhus" } }, + "node_modules/mdast-util-find-and-replace/node_modules/unist-util-is": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-6.0.1.tgz", + "integrity": "sha512-LsiILbtBETkDz8I9p1dQ0uyRUWuaQzd/cuEeS1hoRSyW5E5XGmTzlwY1OrNzzakGowI9Dr/I8HVaw4hTtnxy8g==", + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, "node_modules/mdast-util-from-markdown": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/mdast-util-from-markdown/-/mdast-util-from-markdown-2.0.2.tgz", - "integrity": "sha512-uZhTV/8NBuw0WHkPTrCqDOl0zVe1BIng5ZtHoDk49ME1qqcjYmmLmOf0gELgcRMxN4w2iuIeVso5/6QymSrgmA==", + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/mdast-util-from-markdown/-/mdast-util-from-markdown-2.0.3.tgz", + "integrity": "sha512-W4mAWTvSlKvf8L6J+VN9yLSqQ9AOAAvHuoDAmPkz4dHf553m5gVj2ejadHJhoJmcmxEnOv6Pa8XJhpxE93kb8Q==", "license": "MIT", "dependencies": { "@types/mdast": "^4.0.0", @@ -12758,6 +13345,19 @@ "url": "https://opencollective.com/unified" } }, + "node_modules/mdast-util-phrasing/node_modules/unist-util-is": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-6.0.1.tgz", + "integrity": "sha512-LsiILbtBETkDz8I9p1dQ0uyRUWuaQzd/cuEeS1hoRSyW5E5XGmTzlwY1OrNzzakGowI9Dr/I8HVaw4hTtnxy8g==", + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, "node_modules/mdast-util-to-hast": { "version": "13.2.1", "resolved": "https://registry.npmjs.org/mdast-util-to-hast/-/mdast-util-to-hast-13.2.1.tgz", @@ -12800,6 +13400,16 @@ "url": "https://opencollective.com/unified" } }, + "node_modules/mdast-util-to-markdown/node_modules/zwitch": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/zwitch/-/zwitch-2.0.4.tgz", + "integrity": "sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, "node_modules/mdast-util-to-string": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/mdast-util-to-string/-/mdast-util-to-string-4.0.0.tgz", @@ -12829,11 +13439,19 @@ } }, "node_modules/memfs": { - "version": "4.47.0", - "resolved": "https://registry.npmjs.org/memfs/-/memfs-4.47.0.tgz", - "integrity": "sha512-Xey8IZA57tfotV/TN4d6BmccQuhFP+CqRiI7TTNdipZdZBzF2WnzUcH//Cudw6X4zJiUbo/LTuU/HPA/iC/pNg==", + "version": "4.56.11", + "resolved": "https://registry.npmjs.org/memfs/-/memfs-4.56.11.tgz", + "integrity": "sha512-/GodtwVeKVIHZKLUSr2ZdOxKBC5hHki4JNCU22DoCGPEHr5o2PD5U721zvESKyWwCfTfavFl9WZYgA13OAYK0g==", "license": "Apache-2.0", "dependencies": { + "@jsonjoy.com/fs-core": "4.56.11", + "@jsonjoy.com/fs-fsa": "4.56.11", + "@jsonjoy.com/fs-node": "4.56.11", + "@jsonjoy.com/fs-node-builtins": "4.56.11", + "@jsonjoy.com/fs-node-to-fsa": "4.56.11", + "@jsonjoy.com/fs-node-utils": "4.56.11", + "@jsonjoy.com/fs-print": "4.56.11", + "@jsonjoy.com/fs-snapshot": "4.56.11", "@jsonjoy.com/json-pack": "^1.11.0", "@jsonjoy.com/util": "^1.9.0", "glob-to-regex.js": "^1.0.1", @@ -12844,6 +13462,9 @@ "funding": { "type": "github", "url": "https://github.com/sponsors/streamich" + }, + "peerDependencies": { + "tslib": "2" } }, "node_modules/merge-descriptors": { @@ -12871,46 +13492,33 @@ } }, "node_modules/mermaid": { - "version": "11.10.1", - "resolved": "https://registry.npmjs.org/mermaid/-/mermaid-11.10.1.tgz", - "integrity": "sha512-0PdeADVWURz7VMAX0+MiMcgfxFKY4aweSGsjgFihe3XlMKNqmai/cugMrqTd3WNHM93V+K+AZL6Wu6tB5HmxRw==", + "version": "11.12.3", + "resolved": "https://registry.npmjs.org/mermaid/-/mermaid-11.12.3.tgz", + "integrity": "sha512-wN5ZSgJQIC+CHJut9xaKWsknLxaFBwCPwPkGTSUYrTiHORWvpT8RxGk849HPnpUAQ+/9BPRqYb80jTpearrHzQ==", "license": "MIT", "dependencies": { - "@braintree/sanitize-url": "^7.0.4", - "@iconify/utils": "^2.1.33", - "@mermaid-js/parser": "^0.6.2", + "@braintree/sanitize-url": "^7.1.1", + "@iconify/utils": "^3.0.1", + "@mermaid-js/parser": "^1.0.0", "@types/d3": "^7.4.3", "cytoscape": "^3.29.3", "cytoscape-cose-bilkent": "^4.1.0", "cytoscape-fcose": "^2.2.0", "d3": "^7.9.0", "d3-sankey": "^0.12.3", - "dagre-d3-es": "7.0.11", - "dayjs": "^1.11.13", + "dagre-d3-es": "7.0.13", + "dayjs": "^1.11.18", "dompurify": "^3.2.5", "katex": "^0.16.22", "khroma": "^2.1.0", - "lodash-es": "^4.17.21", - "marked": "^16.0.0", + "lodash-es": "^4.17.23", + "marked": "^16.2.1", "roughjs": "^4.6.6", "stylis": "^4.3.6", "ts-dedent": "^2.2.0", "uuid": "^11.1.0" } }, - "node_modules/mermaid/node_modules/uuid": { - "version": "11.1.0", - "resolved": "https://registry.npmjs.org/uuid/-/uuid-11.1.0.tgz", - "integrity": "sha512-0/A9rDy9P7cJ+8w1c9WD9V//9Wj15Ce2MPz8Ri6032usz+NfePxx5AcN3bN+r6ZL6jEo066/yNYB3tn4pQEx+A==", - "funding": [ - "https://github.com/sponsors/broofa", - "https://github.com/sponsors/ctavan" - ], - "license": "MIT", - "bin": { - "uuid": "dist/esm/bin/uuid" - } - }, "node_modules/methods": { "version": "1.1.2", "resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz", @@ -14772,9 +15380,9 @@ } }, "node_modules/mini-css-extract-plugin": { - "version": "2.9.4", - "resolved": "https://registry.npmjs.org/mini-css-extract-plugin/-/mini-css-extract-plugin-2.9.4.tgz", - "integrity": "sha512-ZWYT7ln73Hptxqxk2DxPU9MmapXRhxkJD6tkSR04dnQxm8BGu2hzgKLugK5yySD97u/8yy7Ma7E76k9ZdvtjkQ==", + "version": "2.10.0", + "resolved": "https://registry.npmjs.org/mini-css-extract-plugin/-/mini-css-extract-plugin-2.10.0.tgz", + "integrity": "sha512-540P2c5dYnJlyJxTaSloliZexv8rji6rY8FhQN+WF/82iHQfA23j/xtJx97L+mXOML27EqksSek/g4eK7jaL3g==", "license": "MIT", "dependencies": { "schema-utils": "^4.0.0", @@ -14798,9 +15406,9 @@ "license": "ISC" }, "node_modules/minimatch": { - "version": "3.1.2", - "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", - "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", + "version": "3.1.5", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz", + "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==", "license": "ISC", "dependencies": { "brace-expansion": "^1.1.7" @@ -14818,33 +15426,26 @@ "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/mlly": { - "version": "1.8.0", - "resolved": "https://registry.npmjs.org/mlly/-/mlly-1.8.0.tgz", - "integrity": "sha512-l8D9ODSRWLe2KHJSifWGwBqpTZXIXTeo8mlKjY+E2HAakaTeNpqAyBZ8GSqLzHgw4XmHmC8whvpjJNMbFZN7/g==", - "license": "MIT", - "dependencies": { - "acorn": "^8.15.0", - "pathe": "^2.0.3", - "pkg-types": "^1.3.1", - "ufo": "^1.6.1" + "node_modules/mkdirp": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.3.0.tgz", + "integrity": "sha512-OHsdUcVAQ6pOtg5JYWpCBo9W/GySVuwvP9hueRMW7UqshC0tbfzLv8wjySTPm3tfUZ/21CE9E1pJagOA91Pxew==", + "deprecated": "Legacy versions of mkdirp are no longer supported. Please update to mkdirp 1.x. (Note that the API surface has changed to use Promises in 1.x.)", + "license": "MIT/X11", + "engines": { + "node": "*" } }, - "node_modules/mlly/node_modules/confbox": { - "version": "0.1.8", - "resolved": "https://registry.npmjs.org/confbox/-/confbox-0.1.8.tgz", - "integrity": "sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w==", - "license": "MIT" - }, - "node_modules/mlly/node_modules/pkg-types": { - "version": "1.3.1", - "resolved": "https://registry.npmjs.org/pkg-types/-/pkg-types-1.3.1.tgz", - "integrity": "sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ==", + "node_modules/mlly": { + "version": "1.8.1", + "resolved": "https://registry.npmjs.org/mlly/-/mlly-1.8.1.tgz", + "integrity": "sha512-SnL6sNutTwRWWR/vcmCYHSADjiEesp5TGQQ0pXyLhW5IoeibRlF/CbSLailbB3CNqJUk9cVJ9dUDnbD7GrcHBQ==", "license": "MIT", "dependencies": { - "confbox": "^0.1.8", - "mlly": "^1.7.4", - "pathe": "^2.0.1" + "acorn": "^8.16.0", + "pathe": "^2.0.3", + "pkg-types": "^1.3.1", + "ufo": "^1.6.3" } }, "node_modules/mrmime": { @@ -14933,19 +15534,10 @@ "node": ">=18" } }, - "node_modules/node-forge": { - "version": "1.3.3", - "resolved": "https://registry.npmjs.org/node-forge/-/node-forge-1.3.3.tgz", - "integrity": "sha512-rLvcdSyRCyouf6jcOIPe/BgwG/d7hKjzMKOas33/pHEr6gbq18IK9zV7DiPvzsz0oBJPme6qr6H6kGZuI9/DZg==", - "license": "(BSD-3-Clause OR GPL-2.0)", - "engines": { - "node": ">= 6.13.0" - } - }, "node_modules/node-releases": { - "version": "2.0.27", - "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.27.tgz", - "integrity": "sha512-nmh3lCkYZ3grZvqcCH+fjmQ7X+H0OeZgP40OierEaAptX4XofMh5kwNbWh7lBduUzCcV/8kZ+NDLCwm2iorIlA==", + "version": "2.0.36", + "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.36.tgz", + "integrity": "sha512-TdC8FSgHz8Mwtw9g5L4gR/Sh9XhSP/0DEkQxfEFXOpiul5IiHgHan2VhYYb6agDSfp4KuvltmGApc8HMgUrIkA==", "license": "MIT" }, "node_modules/nopt": { @@ -14973,9 +15565,9 @@ } }, "node_modules/normalize-url": { - "version": "8.0.2", - "resolved": "https://registry.npmjs.org/normalize-url/-/normalize-url-8.0.2.tgz", - "integrity": "sha512-Ee/R3SyN4BuynXcnTaekmaVdbDAEiNrHqjQIA37mHU8G9pf7aaAD4ZX3XjBLo6rsdcxA/gtkcNYZLt30ACgynw==", + "version": "8.1.1", + "resolved": "https://registry.npmjs.org/normalize-url/-/normalize-url-8.1.1.tgz", + "integrity": "sha512-JYc0DPlpGWB40kH5g07gGTrYuMqV653k3uBKY6uITPWds3M0ov3GaWGp9lbE3Bzngx8+XkfzgvASb9vk9JDFXQ==", "license": "MIT", "engines": { "node": ">=14.16" @@ -15040,10 +15632,11 @@ } }, "node_modules/null-loader/node_modules/ajv": { - "version": "6.12.6", - "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz", - "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==", + "version": "6.14.0", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.14.0.tgz", + "integrity": "sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw==", "license": "MIT", + "peer": true, "dependencies": { "fast-deep-equal": "^3.1.1", "fast-json-stable-stringify": "^2.0.0", @@ -15333,9 +15926,9 @@ } }, "node_modules/package-manager-detector": { - "version": "1.3.0", - "resolved": "https://registry.npmjs.org/package-manager-detector/-/package-manager-detector-1.3.0.tgz", - "integrity": "sha512-ZsEbbZORsyHuO00lY1kV3/t72yp6Ysay6Pd17ZAlNGuGwmWDLCJxFpRs0IzfXfj1o4icJOkUEioexFHzyPurSQ==", + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/package-manager-detector/-/package-manager-detector-1.6.0.tgz", + "integrity": "sha512-61A5ThoTiDG/C8s8UMZwSorAGwMJ0ERVGj2OjoW5pAalsNOg15+iQiPzrLJ4jhZ1HJzmC2PIHT2oEiH3R5fzNA==", "license": "MIT" }, "node_modules/param-case": { @@ -15559,14 +16152,31 @@ } }, "node_modules/pkg-types": { - "version": "2.3.0", - "resolved": "https://registry.npmjs.org/pkg-types/-/pkg-types-2.3.0.tgz", - "integrity": "sha512-SIqCzDRg0s9npO5XQ3tNZioRY1uK06lA41ynBC1YmFTmnY6FjUjVt6s4LoADmwoig1qqD0oK8h1p/8mlMx8Oig==", + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/pkg-types/-/pkg-types-1.3.1.tgz", + "integrity": "sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ==", "license": "MIT", "dependencies": { - "confbox": "^0.2.2", - "exsolve": "^1.0.7", - "pathe": "^2.0.3" + "confbox": "^0.1.8", + "mlly": "^1.7.4", + "pathe": "^2.0.1" + } + }, + "node_modules/pkijs": { + "version": "3.3.3", + "resolved": "https://registry.npmjs.org/pkijs/-/pkijs-3.3.3.tgz", + "integrity": "sha512-+KD8hJtqQMYoTuL1bbGOqxb4z+nZkTAwVdNtWwe8Tc2xNbEmdJYIYoc6Qt0uF55e6YW6KuTHw1DjQ18gMhzepw==", + "license": "BSD-3-Clause", + "dependencies": { + "@noble/hashes": "1.4.0", + "asn1js": "^3.0.6", + "bytestreamjs": "^2.0.1", + "pvtsutils": "^1.3.6", + "pvutils": "^1.1.3", + "tslib": "^2.8.1" + }, + "engines": { + "node": ">=16.0.0" } }, "node_modules/points-on-curve": { @@ -15586,9 +16196,9 @@ } }, "node_modules/postcss": { - "version": "8.5.6", - "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz", - "integrity": "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==", + "version": "8.5.8", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.8.tgz", + "integrity": "sha512-OW/rX8O/jXnm82Ey1k44pObPtdblfiuWnrd8X7GJ7emImCOstunGbXUpp7HdBrFQX6rJzn3sPT397Wp5aCwCHg==", "funding": [ { "type": "opencollective", @@ -15604,6 +16214,7 @@ } ], "license": "MIT", + "peer": true, "dependencies": { "nanoid": "^3.3.11", "picocolors": "^1.1.1", @@ -15639,9 +16250,9 @@ } }, "node_modules/postcss-attribute-case-insensitive/node_modules/postcss-selector-parser": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.0.tgz", - "integrity": "sha512-8sLjZwK0R+JlxlYcTuVnyT2v+htpdrjDOKuMcOVdYjt52Lh8hWRYpxBPoKx/Zg+bcjc3wx6fmQevMmUztS/ccA==", + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.1.tgz", + "integrity": "sha512-orRsuYpJVw8LdAwqqLykBj9ecS5/cRHlI5+nvTo8LcCKmzDmqVORXtOIYEEQuL9D4BxtA1lm5isAqzQZCoQ6Eg==", "license": "MIT", "dependencies": { "cssesc": "^3.0.0", @@ -15883,9 +16494,9 @@ } }, "node_modules/postcss-custom-selectors/node_modules/postcss-selector-parser": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.0.tgz", - "integrity": "sha512-8sLjZwK0R+JlxlYcTuVnyT2v+htpdrjDOKuMcOVdYjt52Lh8hWRYpxBPoKx/Zg+bcjc3wx6fmQevMmUztS/ccA==", + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.1.tgz", + "integrity": "sha512-orRsuYpJVw8LdAwqqLykBj9ecS5/cRHlI5+nvTo8LcCKmzDmqVORXtOIYEEQuL9D4BxtA1lm5isAqzQZCoQ6Eg==", "license": "MIT", "dependencies": { "cssesc": "^3.0.0", @@ -15921,9 +16532,9 @@ } }, "node_modules/postcss-dir-pseudo-class/node_modules/postcss-selector-parser": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.0.tgz", - "integrity": "sha512-8sLjZwK0R+JlxlYcTuVnyT2v+htpdrjDOKuMcOVdYjt52Lh8hWRYpxBPoKx/Zg+bcjc3wx6fmQevMmUztS/ccA==", + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.1.tgz", + "integrity": "sha512-orRsuYpJVw8LdAwqqLykBj9ecS5/cRHlI5+nvTo8LcCKmzDmqVORXtOIYEEQuL9D4BxtA1lm5isAqzQZCoQ6Eg==", "license": "MIT", "dependencies": { "cssesc": "^3.0.0", @@ -16049,9 +16660,9 @@ } }, "node_modules/postcss-focus-visible/node_modules/postcss-selector-parser": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.0.tgz", - "integrity": "sha512-8sLjZwK0R+JlxlYcTuVnyT2v+htpdrjDOKuMcOVdYjt52Lh8hWRYpxBPoKx/Zg+bcjc3wx6fmQevMmUztS/ccA==", + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.1.tgz", + "integrity": "sha512-orRsuYpJVw8LdAwqqLykBj9ecS5/cRHlI5+nvTo8LcCKmzDmqVORXtOIYEEQuL9D4BxtA1lm5isAqzQZCoQ6Eg==", "license": "MIT", "dependencies": { "cssesc": "^3.0.0", @@ -16087,9 +16698,9 @@ } }, "node_modules/postcss-focus-within/node_modules/postcss-selector-parser": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.0.tgz", - "integrity": "sha512-8sLjZwK0R+JlxlYcTuVnyT2v+htpdrjDOKuMcOVdYjt52Lh8hWRYpxBPoKx/Zg+bcjc3wx6fmQevMmUztS/ccA==", + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.1.tgz", + "integrity": "sha512-orRsuYpJVw8LdAwqqLykBj9ecS5/cRHlI5+nvTo8LcCKmzDmqVORXtOIYEEQuL9D4BxtA1lm5isAqzQZCoQ6Eg==", "license": "MIT", "dependencies": { "cssesc": "^3.0.0", @@ -16376,9 +16987,9 @@ } }, "node_modules/postcss-modules-local-by-default/node_modules/postcss-selector-parser": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.0.tgz", - "integrity": "sha512-8sLjZwK0R+JlxlYcTuVnyT2v+htpdrjDOKuMcOVdYjt52Lh8hWRYpxBPoKx/Zg+bcjc3wx6fmQevMmUztS/ccA==", + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.1.tgz", + "integrity": "sha512-orRsuYpJVw8LdAwqqLykBj9ecS5/cRHlI5+nvTo8LcCKmzDmqVORXtOIYEEQuL9D4BxtA1lm5isAqzQZCoQ6Eg==", "license": "MIT", "dependencies": { "cssesc": "^3.0.0", @@ -16404,9 +17015,9 @@ } }, "node_modules/postcss-modules-scope/node_modules/postcss-selector-parser": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.0.tgz", - "integrity": "sha512-8sLjZwK0R+JlxlYcTuVnyT2v+htpdrjDOKuMcOVdYjt52Lh8hWRYpxBPoKx/Zg+bcjc3wx6fmQevMmUztS/ccA==", + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.1.tgz", + "integrity": "sha512-orRsuYpJVw8LdAwqqLykBj9ecS5/cRHlI5+nvTo8LcCKmzDmqVORXtOIYEEQuL9D4BxtA1lm5isAqzQZCoQ6Eg==", "license": "MIT", "dependencies": { "cssesc": "^3.0.0", @@ -16503,10 +17114,11 @@ } }, "node_modules/postcss-nesting/node_modules/postcss-selector-parser": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.0.tgz", - "integrity": "sha512-8sLjZwK0R+JlxlYcTuVnyT2v+htpdrjDOKuMcOVdYjt52Lh8hWRYpxBPoKx/Zg+bcjc3wx6fmQevMmUztS/ccA==", + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.1.tgz", + "integrity": "sha512-orRsuYpJVw8LdAwqqLykBj9ecS5/cRHlI5+nvTo8LcCKmzDmqVORXtOIYEEQuL9D4BxtA1lm5isAqzQZCoQ6Eg==", "license": "MIT", + "peer": true, "dependencies": { "cssesc": "^3.0.0", "util-deprecate": "^1.0.2" @@ -16746,9 +17358,9 @@ } }, "node_modules/postcss-preset-env": { - "version": "10.4.0", - "resolved": "https://registry.npmjs.org/postcss-preset-env/-/postcss-preset-env-10.4.0.tgz", - "integrity": "sha512-2kqpOthQ6JhxqQq1FSAAZGe9COQv75Aw8WbsOvQVNJ2nSevc9Yx/IKZGuZ7XJ+iOTtVon7LfO7ELRzg8AZ+sdw==", + "version": "10.6.1", + "resolved": "https://registry.npmjs.org/postcss-preset-env/-/postcss-preset-env-10.6.1.tgz", + "integrity": "sha512-yrk74d9EvY+W7+lO9Aj1QmjWY9q5NsKjK2V9drkOPZB/X6KZ0B3igKsHUYakb7oYVhnioWypQX3xGuePf89f3g==", "funding": [ { "type": "github", @@ -16786,23 +17398,27 @@ "@csstools/postcss-media-minmax": "^2.0.9", "@csstools/postcss-media-queries-aspect-ratio-number-values": "^3.0.5", "@csstools/postcss-nested-calc": "^4.0.0", - "@csstools/postcss-normalize-display-values": "^4.0.0", + "@csstools/postcss-normalize-display-values": "^4.0.1", "@csstools/postcss-oklab-function": "^4.0.12", + "@csstools/postcss-position-area-property": "^1.0.0", "@csstools/postcss-progressive-custom-properties": "^4.2.1", + "@csstools/postcss-property-rule-prelude-list": "^1.0.0", "@csstools/postcss-random-function": "^2.0.1", "@csstools/postcss-relative-color-syntax": "^3.0.12", "@csstools/postcss-scope-pseudo-class": "^4.0.1", "@csstools/postcss-sign-functions": "^1.1.4", "@csstools/postcss-stepped-value-functions": "^4.0.9", + "@csstools/postcss-syntax-descriptor-syntax-production": "^1.0.1", + "@csstools/postcss-system-ui-font-family": "^1.0.0", "@csstools/postcss-text-decoration-shorthand": "^4.0.3", "@csstools/postcss-trigonometric-functions": "^4.0.9", "@csstools/postcss-unset-value": "^4.0.0", - "autoprefixer": "^10.4.21", - "browserslist": "^4.26.0", + "autoprefixer": "^10.4.23", + "browserslist": "^4.28.1", "css-blank-pseudo": "^7.0.1", "css-has-pseudo": "^7.0.3", "css-prefers-color-scheme": "^10.0.0", - "cssdb": "^8.4.2", + "cssdb": "^8.6.0", "postcss-attribute-case-insensitive": "^7.0.1", "postcss-clamp": "^4.1.0", "postcss-color-functional-notation": "^7.0.12", @@ -16862,9 +17478,9 @@ } }, "node_modules/postcss-pseudo-class-any-link/node_modules/postcss-selector-parser": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.0.tgz", - "integrity": "sha512-8sLjZwK0R+JlxlYcTuVnyT2v+htpdrjDOKuMcOVdYjt52Lh8hWRYpxBPoKx/Zg+bcjc3wx6fmQevMmUztS/ccA==", + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.1.tgz", + "integrity": "sha512-orRsuYpJVw8LdAwqqLykBj9ecS5/cRHlI5+nvTo8LcCKmzDmqVORXtOIYEEQuL9D4BxtA1lm5isAqzQZCoQ6Eg==", "license": "MIT", "dependencies": { "cssesc": "^3.0.0", @@ -16955,9 +17571,9 @@ } }, "node_modules/postcss-selector-not/node_modules/postcss-selector-parser": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.0.tgz", - "integrity": "sha512-8sLjZwK0R+JlxlYcTuVnyT2v+htpdrjDOKuMcOVdYjt52Lh8hWRYpxBPoKx/Zg+bcjc3wx6fmQevMmUztS/ccA==", + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.1.tgz", + "integrity": "sha512-orRsuYpJVw8LdAwqqLykBj9ecS5/cRHlI5+nvTo8LcCKmzDmqVORXtOIYEEQuL9D4BxtA1lm5isAqzQZCoQ6Eg==", "license": "MIT", "dependencies": { "cssesc": "^3.0.0", @@ -17116,10 +17732,13 @@ } }, "node_modules/property-information": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/property-information/-/property-information-7.1.0.tgz", - "integrity": "sha512-TwEZ+X+yCJmYfL7TPUOcvBZ4QfoT5YenQiJuX//0th53DE6w0xxLEtfK3iyryQFddXuvkIk51EEgrJQ0WJkOmQ==", + "version": "5.6.0", + "resolved": "https://registry.npmjs.org/property-information/-/property-information-5.6.0.tgz", + "integrity": "sha512-YUHSPk+A30YPv+0Qf8i9Mbfe/C0hdPXk1s1jPVToV8pk8BQtpw10ct89Eo7OWkutrwqvT0eicAxlOg3dOAu8JA==", "license": "MIT", + "dependencies": { + "xtend": "^4.0.0" + }, "funding": { "type": "github", "url": "https://github.com/sponsors/wooorm" @@ -17163,9 +17782,9 @@ } }, "node_modules/pupa": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/pupa/-/pupa-3.1.0.tgz", - "integrity": "sha512-FLpr4flz5xZTSJxSeaheeMKN/EDzMdK7b8PTOC6a5PYFKTucWbdqjgqaEyH0shFiSJrVB1+Qqi4Tk19ccU6Aug==", + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/pupa/-/pupa-3.3.0.tgz", + "integrity": "sha512-LjgDO2zPtoXP2wJpDjZrGdojii1uqO0cnwKoIoUzkfS98HDmbeiGmYiXo3lXeFlq2xvne1QFQhwYXSUCLKtEuA==", "license": "MIT", "dependencies": { "escape-goat": "^4.0.0" @@ -17177,13 +17796,31 @@ "url": "https://github.com/sponsors/sindresorhus" } }, + "node_modules/pvtsutils": { + "version": "1.3.6", + "resolved": "https://registry.npmjs.org/pvtsutils/-/pvtsutils-1.3.6.tgz", + "integrity": "sha512-PLgQXQ6H2FWCaeRak8vvk1GW462lMxB5s3Jm673N82zI4vqtVUPuZdffdZbPDFRoU8kAhItWFtPCWiPpp4/EDg==", + "license": "MIT", + "dependencies": { + "tslib": "^2.8.1" + } + }, + "node_modules/pvutils": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/pvutils/-/pvutils-1.1.5.tgz", + "integrity": "sha512-KTqnxsgGiQ6ZAzZCVlJH5eOjSnvlyEgx1m8bkRJfOhmGRqfo5KLvmAlACQkrjEtOQ4B7wF9TdSLIs9O90MX9xA==", + "license": "MIT", + "engines": { + "node": ">=16.0.0" + } + }, "node_modules/qs": { - "version": "6.13.0", - "resolved": "https://registry.npmjs.org/qs/-/qs-6.13.0.tgz", - "integrity": "sha512-+38qI9SOr8tfZ4QmJNplMUxqjbe7LKvvZgWdExBOmd+egZTtjLB67Gu0HRX3u/XOq7UU2Nx6nsjvS16Z9uwfpg==", + "version": "6.14.2", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.14.2.tgz", + "integrity": "sha512-V/yCWTTF7VJ9hIh18Ugr2zhJMP01MY7c5kh4J870L7imm6/DIzBsNLTXzMwUA3yZ5b/KBqLx8Kp3uRvd7xSe3Q==", "license": "BSD-3-Clause", "dependencies": { - "side-channel": "^1.0.6" + "side-channel": "^1.1.0" }, "engines": { "node": ">=0.6" @@ -17192,22 +17829,6 @@ "url": "https://github.com/sponsors/ljharb" } }, - "node_modules/quansync": { - "version": "0.2.11", - "resolved": "https://registry.npmjs.org/quansync/-/quansync-0.2.11.tgz", - "integrity": "sha512-AifT7QEbW9Nri4tAwR5M/uzpBuqfZf+zwaEM/QkzEjj7NBuFD2rBuy0K3dE+8wltbezDV7JMA0WfnCPYRSYbXA==", - "funding": [ - { - "type": "individual", - "url": "https://github.com/sponsors/antfu" - }, - { - "type": "individual", - "url": "https://github.com/sponsors/sxzz" - } - ], - "license": "MIT" - }, "node_modules/queue-microtask": { "version": "1.2.3", "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz", @@ -17240,15 +17861,6 @@ "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/randombytes": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz", - "integrity": "sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==", - "license": "MIT", - "dependencies": { - "safe-buffer": "^5.1.0" - } - }, "node_modules/range-parser": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.0.tgz", @@ -17259,15 +17871,15 @@ } }, "node_modules/raw-body": { - "version": "2.5.2", - "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.2.tgz", - "integrity": "sha512-8zGqypfENjCIqGhgXToC8aB2r7YrBX+AQAfIPs/Mlk+BtPTztOvTS01NRW/3Eh60J+a48lt8qsCzirQ6loCVfA==", + "version": "2.5.3", + "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.3.tgz", + "integrity": "sha512-s4VSOf6yN0rvbRZGxs8Om5CWj6seneMwK3oDb4lWDH0UPhWcxwOWw5+qk24bxq87szX1ydrwylIOp2uG1ojUpA==", "license": "MIT", "dependencies": { - "bytes": "3.1.2", - "http-errors": "2.0.0", - "iconv-lite": "0.4.24", - "unpipe": "1.0.0" + "bytes": "~3.1.2", + "http-errors": "~2.0.1", + "iconv-lite": "~0.4.24", + "unpipe": "~1.0.0" }, "engines": { "node": ">= 0.8" @@ -17282,6 +17894,18 @@ "node": ">= 0.8" } }, + "node_modules/raw-body/node_modules/iconv-lite": { + "version": "0.4.24", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz", + "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==", + "license": "MIT", + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3" + }, + "engines": { + "node": ">=0.10.0" + } + }, "node_modules/rc": { "version": "1.2.8", "resolved": "https://registry.npmjs.org/rc/-/rc-1.2.8.tgz", @@ -17317,6 +17941,7 @@ "resolved": "https://registry.npmjs.org/react/-/react-19.2.4.tgz", "integrity": "sha512-9nfp2hYpCwOjAN+8TZFGhtWEwgvWHXqESH8qT89AT/lWklpLON22Lc8pEtnpsZz7VmawabSU0gCjnj8aC0euHQ==", "license": "MIT", + "peer": true, "engines": { "node": ">=0.10.0" } @@ -17326,6 +17951,7 @@ "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.2.4.tgz", "integrity": "sha512-AXJdLo8kgMbimY95O2aKQqsz2iWi9jMgKJhRBAxECE4IFxfcazB2LmzloIoibJI3C12IlY20+KFaLv+71bUJeQ==", "license": "MIT", + "peer": true, "dependencies": { "scheduler": "^0.27.0" }, @@ -17381,6 +18007,7 @@ "resolved": "https://registry.npmjs.org/@docusaurus/react-loadable/-/react-loadable-6.0.0.tgz", "integrity": "sha512-YMMxTUQV/QFSnbgrP3tjDzLHRg7vsbMn8e9HAa8o/1iXoiomo48b7sk/kkmWEuWNDPJVlKSJRB6Y2fHqdJk+SQ==", "license": "MIT", + "peer": true, "dependencies": { "@types/react": "*" }, @@ -17409,6 +18036,7 @@ "resolved": "https://registry.npmjs.org/react-router/-/react-router-5.3.4.tgz", "integrity": "sha512-Ys9K+ppnJah3QuaRiLxk+jDWOR1MekYQrlytiXxC1RyfbdsZkS5pvKAzCCr031xHixZwpnsYNT5xysdFHQaYsA==", "license": "MIT", + "peer": true, "dependencies": { "@babel/runtime": "^7.12.13", "history": "^4.9.0", @@ -17548,6 +18176,12 @@ "url": "https://opencollective.com/unified" } }, + "node_modules/reflect-metadata": { + "version": "0.2.2", + "resolved": "https://registry.npmjs.org/reflect-metadata/-/reflect-metadata-0.2.2.tgz", + "integrity": "sha512-urBwgfrvVP/eAyXx4hluJivBKzuEbSQs9rKWCrCkbSxNv8mxPcUZKeuoF3Uy4mJl3Lwprp6yy5/39VWigZ4K6Q==", + "license": "Apache-2.0" + }, "node_modules/regenerate": { "version": "1.4.2", "resolved": "https://registry.npmjs.org/regenerate/-/regenerate-1.4.2.tgz", @@ -17584,12 +18218,12 @@ } }, "node_modules/registry-auth-token": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/registry-auth-token/-/registry-auth-token-5.1.0.tgz", - "integrity": "sha512-GdekYuwLXLxMuFTwAPg5UKGLW/UXzQrZvH/Zj791BQif5T05T0RsaLfHc9q3ZOKi7n+BoprPD9mJ0O0k4xzUlw==", + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/registry-auth-token/-/registry-auth-token-5.1.1.tgz", + "integrity": "sha512-P7B4+jq8DeD2nMsAcdfaqHbssgHtZ7Z5+++a5ask90fvmJ8p5je4mOa+wzu+DB4vQ5tdJV/xywY+UnVFeQLV5Q==", "license": "MIT", "dependencies": { - "@pnpm/npm-conf": "^2.1.0" + "@pnpm/npm-conf": "^3.0.2" }, "engines": { "node": ">=14" @@ -17616,193 +18250,37 @@ "integrity": "sha512-RvwtGe3d7LvWiDQXeQw8p5asZUmfU1G/l6WbUXeHta7Y2PEIvBTwH6E2EfmYUK8pxcxEdEmaomqyp0vZZ7C+3Q==", "license": "MIT" }, - "node_modules/regjsparser": { - "version": "0.13.0", - "resolved": "https://registry.npmjs.org/regjsparser/-/regjsparser-0.13.0.tgz", - "integrity": "sha512-NZQZdC5wOE/H3UT28fVGL+ikOZcEzfMGk/c3iN9UGxzWHMa1op7274oyiUVrAG4B2EuFhus8SvkaYnhvW92p9Q==", - "license": "BSD-2-Clause", - "dependencies": { - "jsesc": "~3.1.0" - }, - "bin": { - "regjsparser": "bin/parser" - } - }, - "node_modules/rehype-parse": { - "version": "7.0.1", - "resolved": "https://registry.npmjs.org/rehype-parse/-/rehype-parse-7.0.1.tgz", - "integrity": "sha512-fOiR9a9xH+Le19i4fGzIEowAbwG7idy2Jzs4mOrFWBSJ0sNUgy0ev871dwWnbOo371SjgjG4pwzrbgSVrKxecw==", - "license": "MIT", - "dependencies": { - "hast-util-from-parse5": "^6.0.0", - "parse5": "^6.0.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/unified" - } - }, - "node_modules/rehype-parse/node_modules/@types/hast": { - "version": "2.3.10", - "resolved": "https://registry.npmjs.org/@types/hast/-/hast-2.3.10.tgz", - "integrity": "sha512-McWspRw8xx8J9HurkVBfYj0xKoE25tOFlHGdx4MJ5xORQrMGZNqJhVQWaIbm6Oyla5kYOXtDiopzKRJzEOkwJw==", - "license": "MIT", - "dependencies": { - "@types/unist": "^2" - } - }, - "node_modules/rehype-parse/node_modules/@types/unist": { - "version": "2.0.11", - "resolved": "https://registry.npmjs.org/@types/unist/-/unist-2.0.11.tgz", - "integrity": "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA==", - "license": "MIT" - }, - "node_modules/rehype-parse/node_modules/comma-separated-tokens": { - "version": "1.0.8", - "resolved": "https://registry.npmjs.org/comma-separated-tokens/-/comma-separated-tokens-1.0.8.tgz", - "integrity": "sha512-GHuDRO12Sypu2cV70d1dkA2EUmXHgntrzbpvOB+Qy+49ypNfGgFQIC2fhhXbnyrJRynDCAARsT7Ou0M6hirpfw==", - "license": "MIT", - "funding": { - "type": "github", - "url": "https://github.com/sponsors/wooorm" - } - }, - "node_modules/rehype-parse/node_modules/hast-util-from-parse5": { - "version": "6.0.1", - "resolved": "https://registry.npmjs.org/hast-util-from-parse5/-/hast-util-from-parse5-6.0.1.tgz", - "integrity": "sha512-jeJUWiN5pSxW12Rh01smtVkZgZr33wBokLzKLwinYOUfSzm1Nl/c3GUGebDyOKjdsRgMvoVbV0VpAcpjF4NrJA==", - "license": "MIT", - "dependencies": { - "@types/parse5": "^5.0.0", - "hastscript": "^6.0.0", - "property-information": "^5.0.0", - "vfile": "^4.0.0", - "vfile-location": "^3.2.0", - "web-namespaces": "^1.0.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/unified" - } - }, - "node_modules/rehype-parse/node_modules/hast-util-parse-selector": { - "version": "2.2.5", - "resolved": "https://registry.npmjs.org/hast-util-parse-selector/-/hast-util-parse-selector-2.2.5.tgz", - "integrity": "sha512-7j6mrk/qqkSehsM92wQjdIgWM2/BW61u/53G6xmC8i1OmEdKLHbk419QKQUjz6LglWsfqoiHmyMRkP1BGjecNQ==", - "license": "MIT", - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/unified" - } - }, - "node_modules/rehype-parse/node_modules/hastscript": { - "version": "6.0.0", - "resolved": "https://registry.npmjs.org/hastscript/-/hastscript-6.0.0.tgz", - "integrity": "sha512-nDM6bvd7lIqDUiYEiu5Sl/+6ReP0BMk/2f4U/Rooccxkj0P5nm+acM5PrGJ/t5I8qPGiqZSE6hVAwZEdZIvP4w==", - "license": "MIT", - "dependencies": { - "@types/hast": "^2.0.0", - "comma-separated-tokens": "^1.0.0", - "hast-util-parse-selector": "^2.0.0", - "property-information": "^5.0.0", - "space-separated-tokens": "^1.0.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/unified" - } - }, - "node_modules/rehype-parse/node_modules/parse5": { - "version": "6.0.1", - "resolved": "https://registry.npmjs.org/parse5/-/parse5-6.0.1.tgz", - "integrity": "sha512-Ofn/CTFzRGTTxwpNEs9PP93gXShHcTq255nzRYSKe8AkVpZY7e1fpmTfOyoIvjP5HG7Z2ZM7VS9PPhQGW2pOpw==", - "license": "MIT" - }, - "node_modules/rehype-parse/node_modules/property-information": { - "version": "5.6.0", - "resolved": "https://registry.npmjs.org/property-information/-/property-information-5.6.0.tgz", - "integrity": "sha512-YUHSPk+A30YPv+0Qf8i9Mbfe/C0hdPXk1s1jPVToV8pk8BQtpw10ct89Eo7OWkutrwqvT0eicAxlOg3dOAu8JA==", - "license": "MIT", - "dependencies": { - "xtend": "^4.0.0" - }, - "funding": { - "type": "github", - "url": "https://github.com/sponsors/wooorm" - } - }, - "node_modules/rehype-parse/node_modules/space-separated-tokens": { - "version": "1.1.5", - "resolved": "https://registry.npmjs.org/space-separated-tokens/-/space-separated-tokens-1.1.5.tgz", - "integrity": "sha512-q/JSVd1Lptzhf5bkYm4ob4iWPjx0KiRe3sRFBNrVqbJkFaBm5vbbowy1mymoPNLRa52+oadOhJ+K49wsSeSjTA==", - "license": "MIT", - "funding": { - "type": "github", - "url": "https://github.com/sponsors/wooorm" - } - }, - "node_modules/rehype-parse/node_modules/unist-util-stringify-position": { - "version": "2.0.3", - "resolved": "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-2.0.3.tgz", - "integrity": "sha512-3faScn5I+hy9VleOq/qNbAd6pAx7iH5jYBMS9I1HgQVijz/4mv5Bvw5iw1sC/90CODiKo81G/ps8AJrISn687g==", - "license": "MIT", - "dependencies": { - "@types/unist": "^2.0.2" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/unified" - } - }, - "node_modules/rehype-parse/node_modules/vfile": { - "version": "4.2.1", - "resolved": "https://registry.npmjs.org/vfile/-/vfile-4.2.1.tgz", - "integrity": "sha512-O6AE4OskCG5S1emQ/4gl8zK586RqA3srz3nfK/Viy0UPToBc5Trp9BVFb1u0CjsKrAWwnpr4ifM/KBXPWwJbCA==", - "license": "MIT", - "dependencies": { - "@types/unist": "^2.0.0", - "is-buffer": "^2.0.0", - "unist-util-stringify-position": "^2.0.0", - "vfile-message": "^2.0.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/unified" - } - }, - "node_modules/rehype-parse/node_modules/vfile-location": { - "version": "3.2.0", - "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-3.2.0.tgz", - "integrity": "sha512-aLEIZKv/oxuCDZ8lkJGhuhztf/BW4M+iHdCwglA/eWc+vtuRFJj8EtgceYFX4LRjOhCAAiNHsKGssC6onJ+jbA==", - "license": "MIT", - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/unified" + "node_modules/regjsparser": { + "version": "0.13.0", + "resolved": "https://registry.npmjs.org/regjsparser/-/regjsparser-0.13.0.tgz", + "integrity": "sha512-NZQZdC5wOE/H3UT28fVGL+ikOZcEzfMGk/c3iN9UGxzWHMa1op7274oyiUVrAG4B2EuFhus8SvkaYnhvW92p9Q==", + "license": "BSD-2-Clause", + "dependencies": { + "jsesc": "~3.1.0" + }, + "bin": { + "regjsparser": "bin/parser" } }, - "node_modules/rehype-parse/node_modules/vfile-message": { - "version": "2.0.4", - "resolved": "https://registry.npmjs.org/vfile-message/-/vfile-message-2.0.4.tgz", - "integrity": "sha512-DjssxRGkMvifUOJre00juHoP9DPWuzjxKuMDrhNbk2TdaYYBNMStsNhEOt3idrtI12VQYM/1+iM0KOzXi4pxwQ==", + "node_modules/rehype-parse": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/rehype-parse/-/rehype-parse-7.0.1.tgz", + "integrity": "sha512-fOiR9a9xH+Le19i4fGzIEowAbwG7idy2Jzs4mOrFWBSJ0sNUgy0ev871dwWnbOo371SjgjG4pwzrbgSVrKxecw==", "license": "MIT", "dependencies": { - "@types/unist": "^2.0.0", - "unist-util-stringify-position": "^2.0.0" + "hast-util-from-parse5": "^6.0.0", + "parse5": "^6.0.0" }, "funding": { "type": "opencollective", "url": "https://opencollective.com/unified" } }, - "node_modules/rehype-parse/node_modules/web-namespaces": { - "version": "1.1.4", - "resolved": "https://registry.npmjs.org/web-namespaces/-/web-namespaces-1.1.4.tgz", - "integrity": "sha512-wYxSGajtmoP4WxfejAPIr4l0fVh+jeMXZb08wNc0tMg6xsfZXj3cECqIK0G7ZAqUq0PP8WlMDtaOGVBTAWztNw==", - "license": "MIT", - "funding": { - "type": "github", - "url": "https://github.com/sponsors/wooorm" - } + "node_modules/rehype-parse/node_modules/parse5": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/parse5/-/parse5-6.0.1.tgz", + "integrity": "sha512-Ofn/CTFzRGTTxwpNEs9PP93gXShHcTq255nzRYSKe8AkVpZY7e1fpmTfOyoIvjP5HG7Z2ZM7VS9PPhQGW2pOpw==", + "license": "MIT" }, "node_modules/rehype-raw": { "version": "7.0.0", @@ -18282,10 +18760,13 @@ "license": "MIT" }, "node_modules/sax": { - "version": "1.4.3", - "resolved": "https://registry.npmjs.org/sax/-/sax-1.4.3.tgz", - "integrity": "sha512-yqYn1JhPczigF94DMS+shiDMjDowYO6y9+wB/4WgO0Y19jWYk0lQ4tuG5KI7kj4FTp1wxPj5IFfcrz/s1c3jjQ==", - "license": "BlueOak-1.0.0" + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/sax/-/sax-1.5.0.tgz", + "integrity": "sha512-21IYA3Q5cQf089Z6tgaUTr7lDAyzoTPx5HRtbhsME8Udispad8dC/+sziTNugOEx54ilvatQ9YCzl4KQLPcRHA==", + "license": "BlueOak-1.0.0", + "engines": { + "node": ">=11.0.0" + } }, "node_modules/scheduler": { "version": "0.27.0", @@ -18345,22 +18826,22 @@ "license": "MIT" }, "node_modules/selfsigned": { - "version": "2.4.1", - "resolved": "https://registry.npmjs.org/selfsigned/-/selfsigned-2.4.1.tgz", - "integrity": "sha512-th5B4L2U+eGLq1TVh7zNRGBapioSORUeymIydxgFpwww9d2qyKvtuPU2jJuHvYAwwqi2Y596QBL3eEqcPEYL8Q==", + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/selfsigned/-/selfsigned-5.5.0.tgz", + "integrity": "sha512-ftnu3TW4+3eBfLRFnDEkzGxSF/10BJBkaLJuBHZX0kiPS7bRdlpZGu6YGt4KngMkdTwJE6MbjavFpqHvqVt+Ew==", "license": "MIT", "dependencies": { - "@types/node-forge": "^1.3.0", - "node-forge": "^1" + "@peculiar/x509": "^1.14.2", + "pkijs": "^3.3.3" }, "engines": { - "node": ">=10" + "node": ">=18" } }, "node_modules/semver": { - "version": "7.7.2", - "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.2.tgz", - "integrity": "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==", + "version": "7.7.4", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz", + "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==", "license": "ISC", "bin": { "semver": "bin/semver.js" @@ -18385,24 +18866,24 @@ } }, "node_modules/send": { - "version": "0.19.0", - "resolved": "https://registry.npmjs.org/send/-/send-0.19.0.tgz", - "integrity": "sha512-dW41u5VfLXu8SJh5bwRmyYUbAoSB3c9uQh6L8h/KtsFREPWpbX1lrljJo186Jc4nmci/sGUZ9a0a0J2zgfq2hw==", + "version": "0.19.2", + "resolved": "https://registry.npmjs.org/send/-/send-0.19.2.tgz", + "integrity": "sha512-VMbMxbDeehAxpOtWJXlcUS5E8iXh6QmN+BkRX1GARS3wRaXEEgzCcB10gTQazO42tpNIya8xIyNx8fll1OFPrg==", "license": "MIT", "dependencies": { "debug": "2.6.9", "depd": "2.0.0", "destroy": "1.2.0", - "encodeurl": "~1.0.2", + "encodeurl": "~2.0.0", "escape-html": "~1.0.3", "etag": "~1.8.1", - "fresh": "0.5.2", - "http-errors": "2.0.0", + "fresh": "~0.5.2", + "http-errors": "~2.0.1", "mime": "1.6.0", "ms": "2.1.3", - "on-finished": "2.4.1", + "on-finished": "~2.4.1", "range-parser": "~1.2.1", - "statuses": "2.0.1" + "statuses": "~2.0.2" }, "engines": { "node": ">= 0.8.0" @@ -18423,15 +18904,6 @@ "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==", "license": "MIT" }, - "node_modules/send/node_modules/encodeurl": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz", - "integrity": "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==", - "license": "MIT", - "engines": { - "node": ">= 0.8" - } - }, "node_modules/send/node_modules/range-parser": { "version": "1.2.1", "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz", @@ -18442,24 +18914,24 @@ } }, "node_modules/serialize-javascript": { - "version": "6.0.2", - "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.2.tgz", - "integrity": "sha512-Saa1xPByTTq2gdeFZYLLo+RFE35NHZkAbqZeWNd3BpzppeVisAqpDjcp8dyf6uIvEqJRd46jemmyA4iFIeVk8g==", + "version": "7.0.4", + "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-7.0.4.tgz", + "integrity": "sha512-DuGdB+Po43Q5Jxwpzt1lhyFSYKryqoNjQSA9M92tyw0lyHIOur+XCalOUe0KTJpyqzT8+fQ5A0Jf7vCx/NKmIg==", "license": "BSD-3-Clause", - "dependencies": { - "randombytes": "^2.1.0" + "engines": { + "node": ">=20.0.0" } }, "node_modules/serve-handler": { - "version": "6.1.6", - "resolved": "https://registry.npmjs.org/serve-handler/-/serve-handler-6.1.6.tgz", - "integrity": "sha512-x5RL9Y2p5+Sh3D38Fh9i/iQ5ZK+e4xuXRd/pGbM4D13tgo/MGwbttUk8emytcr1YYzBYs+apnUngBDFYfpjPuQ==", + "version": "6.1.7", + "resolved": "https://registry.npmjs.org/serve-handler/-/serve-handler-6.1.7.tgz", + "integrity": "sha512-CinAq1xWb0vR3twAv9evEU8cNWkXCb9kd5ePAHUKJBkOsUpR1wt/CvGdeca7vqumL1U5cSaeVQ6zZMxiJ3yWsg==", "license": "MIT", "dependencies": { "bytes": "3.0.0", "content-disposition": "0.5.2", "mime-types": "2.1.18", - "minimatch": "3.1.2", + "minimatch": "3.1.5", "path-is-inside": "1.0.2", "path-to-regexp": "3.3.0", "range-parser": "1.2.0" @@ -18472,21 +18944,25 @@ "license": "MIT" }, "node_modules/serve-index": { - "version": "1.9.1", - "resolved": "https://registry.npmjs.org/serve-index/-/serve-index-1.9.1.tgz", - "integrity": "sha512-pXHfKNP4qujrtteMrSBb0rc8HJ9Ms/GrXwcUtUtD5s4ewDJI8bT3Cz2zTVRMKtri49pLx2e0Ya8ziP5Ya2pZZw==", + "version": "1.9.2", + "resolved": "https://registry.npmjs.org/serve-index/-/serve-index-1.9.2.tgz", + "integrity": "sha512-KDj11HScOaLmrPxl70KYNW1PksP4Nb/CLL2yvC+Qd2kHMPEEpfc4Re2e4FOay+bC/+XQl/7zAcWON3JVo5v3KQ==", "license": "MIT", "dependencies": { - "accepts": "~1.3.4", + "accepts": "~1.3.8", "batch": "0.6.1", "debug": "2.6.9", "escape-html": "~1.0.3", - "http-errors": "~1.6.2", - "mime-types": "~2.1.17", - "parseurl": "~1.3.2" + "http-errors": "~1.8.0", + "mime-types": "~2.1.35", + "parseurl": "~1.3.3" }, "engines": { "node": ">= 0.8.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" } }, "node_modules/serve-index/node_modules/debug": { @@ -18508,25 +18984,41 @@ } }, "node_modules/serve-index/node_modules/http-errors": { - "version": "1.6.3", - "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-1.6.3.tgz", - "integrity": "sha512-lks+lVC8dgGyh97jxvxeYTWQFvh4uw4yC12gVl63Cg30sjPX4wuGcdkICVXDAESr6OJGjqGA8Iz5mkeN6zlD7A==", + "version": "1.8.1", + "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-1.8.1.tgz", + "integrity": "sha512-Kpk9Sm7NmI+RHhnj6OIWDI1d6fIoFAtFt9RLaTMRlg/8w49juAStsrBgp0Dp4OdxdVbRIeKhtCUvoi/RuAhO4g==", "license": "MIT", "dependencies": { "depd": "~1.1.2", - "inherits": "2.0.3", - "setprototypeof": "1.1.0", - "statuses": ">= 1.4.0 < 2" + "inherits": "2.0.4", + "setprototypeof": "1.2.0", + "statuses": ">= 1.5.0 < 2", + "toidentifier": "1.0.1" }, "engines": { "node": ">= 0.6" } }, - "node_modules/serve-index/node_modules/inherits": { - "version": "2.0.3", - "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz", - "integrity": "sha512-x00IRNXNy63jwGkJmzPigoySHbaqpNuzKbBOmzK+g2OdZpQ9w+sxCN+VSB3ja7IAge2OP2qpfxTjeNcyjmW1uw==", - "license": "ISC" + "node_modules/serve-index/node_modules/mime-db": { + "version": "1.52.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz", + "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/serve-index/node_modules/mime-types": { + "version": "2.1.35", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz", + "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==", + "license": "MIT", + "dependencies": { + "mime-db": "1.52.0" + }, + "engines": { + "node": ">= 0.6" + } }, "node_modules/serve-index/node_modules/ms": { "version": "2.0.0", @@ -18534,12 +19026,6 @@ "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==", "license": "MIT" }, - "node_modules/serve-index/node_modules/setprototypeof": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.1.0.tgz", - "integrity": "sha512-BvE/TwpZX4FXExxOxZyRGQQv651MSwmWKZGqvmPcRIjDqWub67kTKuIMx43cZZrS/cBBzwBcNDWoFxt2XEFIpQ==", - "license": "ISC" - }, "node_modules/serve-index/node_modules/statuses": { "version": "1.5.0", "resolved": "https://registry.npmjs.org/statuses/-/statuses-1.5.0.tgz", @@ -18550,15 +19036,15 @@ } }, "node_modules/serve-static": { - "version": "1.16.2", - "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.16.2.tgz", - "integrity": "sha512-VqpjJZKadQB/PEbEwvFdO43Ax5dFBZ2UECszz8bQ7pi7wt//PWe1P6MN7eCnjsatYtBT6EuiClbjSWP2WrIoTw==", + "version": "1.16.3", + "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.16.3.tgz", + "integrity": "sha512-x0RTqQel6g5SY7Lg6ZreMmsOzncHFU7nhnRWkKgWuMTu5NN0DR5oruckMqRvacAN9d5w6ARnRBXl9xhDCgfMeA==", "license": "MIT", "dependencies": { "encodeurl": "~2.0.0", "escape-html": "~1.0.3", "parseurl": "~1.3.3", - "send": "0.19.0" + "send": "~0.19.1" }, "engines": { "node": ">= 0.8.0" @@ -18737,9 +19223,9 @@ "license": "MIT" }, "node_modules/sitemap": { - "version": "7.1.2", - "resolved": "https://registry.npmjs.org/sitemap/-/sitemap-7.1.2.tgz", - "integrity": "sha512-ARCqzHJ0p4gWt+j7NlU5eDlIO9+Rkr/JhPFZKKQ1l5GCus7rJH4UdrlVAh0xC/gDS/Qir2UMxqYNHtsKr2rpCw==", + "version": "7.1.3", + "resolved": "https://registry.npmjs.org/sitemap/-/sitemap-7.1.3.tgz", + "integrity": "sha512-tAjEd+wt/YwnEbfNB2ht51ybBJxbEWwe5ki/Z//Wh0rpBFTCUSj46GnxUKEWzhfuJTsee8x3lybHxFgUMig2hw==", "license": "MIT", "dependencies": { "@types/node": "^17.0.5", @@ -18803,6 +19289,15 @@ "websocket-driver": "^0.7.4" } }, + "node_modules/sockjs/node_modules/uuid": { + "version": "8.3.2", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz", + "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==", + "license": "MIT", + "bin": { + "uuid": "dist/bin/uuid" + } + }, "node_modules/sort-css-media-queries": { "version": "2.2.0", "resolved": "https://registry.npmjs.org/sort-css-media-queries/-/sort-css-media-queries-2.2.0.tgz", @@ -18850,9 +19345,9 @@ } }, "node_modules/space-separated-tokens": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/space-separated-tokens/-/space-separated-tokens-2.0.2.tgz", - "integrity": "sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q==", + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/space-separated-tokens/-/space-separated-tokens-1.1.5.tgz", + "integrity": "sha512-q/JSVd1Lptzhf5bkYm4ob4iWPjx0KiRe3sRFBNrVqbJkFaBm5vbbowy1mymoPNLRa52+oadOhJ+K49wsSeSjTA==", "license": "MIT", "funding": { "type": "github", @@ -18908,9 +19403,9 @@ } }, "node_modules/statuses": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz", - "integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==", + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.2.tgz", + "integrity": "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==", "license": "MIT", "engines": { "node": ">= 0.8" @@ -18949,9 +19444,9 @@ } }, "node_modules/string-width/node_modules/ansi-regex": { - "version": "6.2.0", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.2.0.tgz", - "integrity": "sha512-TKY5pyBkHyADOPYlRT9Lx6F544mPl0vS5Ew7BJ45hA08Q+t3GjbueLliBWN3sMICk6+y7HdyxSzC4bWS8baBdg==", + "version": "6.2.2", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.2.2.tgz", + "integrity": "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==", "license": "MIT", "engines": { "node": ">=12" @@ -18961,12 +19456,12 @@ } }, "node_modules/string-width/node_modules/strip-ansi": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz", - "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==", + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.2.0.tgz", + "integrity": "sha512-yDPMNjp4WyfYBkHnjIRLfca1i6KMyGCtsVgoKe/z1+6vukgaENdgGBZt+ZmKPc4gavvEZ5OgHfHdrazhgNyG7w==", "license": "MIT", "dependencies": { - "ansi-regex": "^6.0.1" + "ansi-regex": "^6.2.2" }, "engines": { "node": ">=12" @@ -19116,18 +19611,18 @@ "license": "MIT" }, "node_modules/svgo": { - "version": "3.3.2", - "resolved": "https://registry.npmjs.org/svgo/-/svgo-3.3.2.tgz", - "integrity": "sha512-OoohrmuUlBs8B8o6MB2Aevn+pRIH9zDALSR+6hhqVfa6fRwG/Qw9VUMSMW9VNg2CFc/MTIfabtdOVl9ODIJjpw==", + "version": "3.3.3", + "resolved": "https://registry.npmjs.org/svgo/-/svgo-3.3.3.tgz", + "integrity": "sha512-+wn7I4p7YgJhHs38k2TNjy1vCfPIfLIJWR5MnCStsN8WuuTcBnRKcMHQLMM2ijxGZmDoZwNv8ipl5aTTen62ng==", "license": "MIT", "dependencies": { - "@trysound/sax": "0.2.0", "commander": "^7.2.0", "css-select": "^5.1.0", "css-tree": "^2.3.1", "css-what": "^6.1.0", "csso": "^5.0.5", - "picocolors": "^1.0.0" + "picocolors": "^1.0.0", + "sax": "^1.5.0" }, "bin": { "svgo": "bin/svgo" @@ -19149,23 +19644,10 @@ "node": ">= 10" } }, - "node_modules/swr": { - "version": "2.3.6", - "resolved": "https://registry.npmjs.org/swr/-/swr-2.3.6.tgz", - "integrity": "sha512-wfHRmHWk/isGNMwlLGlZX5Gzz/uTgo0o2IRuTMcf4CPuPFJZlq0rDaKUx+ozB5nBOReNV1kiOyzMfj+MBMikLw==", - "license": "MIT", - "dependencies": { - "dequal": "^2.0.3", - "use-sync-external-store": "^1.4.0" - }, - "peerDependencies": { - "react": "^16.11.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" - } - }, "node_modules/tailwindcss": { - "version": "4.1.18", - "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-4.1.18.tgz", - "integrity": "sha512-4+Z+0yiYyEtUVCScyfHCxOYP06L5Ne+JiHhY2IjR2KWMIWhJOYZKLSGZaP5HkZ8+bY0cxfzwDE5uOmzFXyIwxw==", + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-4.2.1.tgz", + "integrity": "sha512-/tBrSQ36vCleJkAOsy9kbNTgaxvGbyOamC30PRePTQe/o1MFwEKHQk4Cn7BNGaPtjp+PuUrByJehM1hgxfq4sw==", "dev": true, "license": "MIT" }, @@ -19183,13 +19665,13 @@ } }, "node_modules/terser": { - "version": "5.43.1", - "resolved": "https://registry.npmjs.org/terser/-/terser-5.43.1.tgz", - "integrity": "sha512-+6erLbBm0+LROX2sPXlUYx/ux5PyE9K/a92Wrt6oA+WDAoFTdpHE5tCYCI5PNzq2y8df4rA+QgHLJuR4jNymsg==", + "version": "5.46.0", + "resolved": "https://registry.npmjs.org/terser/-/terser-5.46.0.tgz", + "integrity": "sha512-jTwoImyr/QbOWFFso3YoU3ik0jBBDJ6JTOQiy/J2YxVJdZCc+5u7skhNwiOR3FQIygFqVUPHl7qbbxtjW2K3Qg==", "license": "BSD-2-Clause", "dependencies": { "@jridgewell/source-map": "^0.3.3", - "acorn": "^8.14.0", + "acorn": "^8.15.0", "commander": "^2.20.0", "source-map-support": "~0.5.20" }, @@ -19201,15 +19683,14 @@ } }, "node_modules/terser-webpack-plugin": { - "version": "5.3.16", - "resolved": "https://registry.npmjs.org/terser-webpack-plugin/-/terser-webpack-plugin-5.3.16.tgz", - "integrity": "sha512-h9oBFCWrq78NyWWVcSwZarJkZ01c2AyGrzs1crmHZO3QUg9D61Wu4NPjBy69n7JqylFF5y+CsUZYmYEIZ3mR+Q==", + "version": "5.3.17", + "resolved": "https://registry.npmjs.org/terser-webpack-plugin/-/terser-webpack-plugin-5.3.17.tgz", + "integrity": "sha512-YR7PtUp6GMU91BgSJmlaX/rS2lGDbAF7D+Wtq7hRO+MiljNmodYvqslzCFiYVAgW+Qoaaia/QUIP4lGXufjdZw==", "license": "MIT", "dependencies": { "@jridgewell/trace-mapping": "^0.3.25", "jest-worker": "^27.4.5", "schema-utils": "^4.3.0", - "serialize-javascript": "^6.0.2", "terser": "^5.31.1" }, "engines": { @@ -19285,18 +19766,6 @@ "tslib": "^2" } }, - "node_modules/throttleit": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/throttleit/-/throttleit-2.1.0.tgz", - "integrity": "sha512-nt6AMGKW1p/70DF/hGBdJB57B8Tspmbp5gfJ8ilhLnt7kkr2ye7hzD6NVG8GGErk2HWF34igrL2CXmNIkzKqKw==", - "license": "MIT", - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, "node_modules/thunky": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/thunky/-/thunky-1.1.0.tgz", @@ -19316,10 +19785,13 @@ "license": "MIT" }, "node_modules/tinyexec": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-1.0.1.tgz", - "integrity": "sha512-5uC6DDlmeqiOwCPmK9jMSdOuZTh8bU39Ys6yidB+UTt5hfZUPGAypSgFRiEp+jbi9qH40BLDvy85jIU88wKSqw==", - "license": "MIT" + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-1.0.2.tgz", + "integrity": "sha512-W/KYk+NFhkmsYpuHq5JykngiOCnxeVL8v8dFnqxSD8qEEdRfXk1SDM6JzNqcERbcGYj9tMrDQBYV9cjgnunFIg==", + "license": "MIT", + "engines": { + "node": ">=18" + } }, "node_modules/tinypool": { "version": "1.1.1", @@ -19481,6 +19953,25 @@ "version": "2.8.1", "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz", "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==", + "license": "0BSD", + "peer": true + }, + "node_modules/tsyringe": { + "version": "4.10.0", + "resolved": "https://registry.npmjs.org/tsyringe/-/tsyringe-4.10.0.tgz", + "integrity": "sha512-axr3IdNuVIxnaK5XGEUFTu3YmAQ6lllgrvqfEoR16g/HGnYY/6We4oWENtAnzK6/LpJ2ur9PAb80RBt7/U4ugw==", + "license": "MIT", + "dependencies": { + "tslib": "^1.9.3" + }, + "engines": { + "node": ">= 6.0.0" + } + }, + "node_modules/tsyringe/node_modules/tslib": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz", + "integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==", "license": "0BSD" }, "node_modules/type-fest": { @@ -19544,6 +20035,7 @@ "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==", "devOptional": true, "license": "Apache-2.0", + "peer": true, "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" @@ -19553,15 +20045,15 @@ } }, "node_modules/ufo": { - "version": "1.6.1", - "resolved": "https://registry.npmjs.org/ufo/-/ufo-1.6.1.tgz", - "integrity": "sha512-9a4/uxlTWJ4+a5i0ooc1rU7C7YOw3wT+UGqdeNNHWnOF9qcMBgLRS+4IYUqbczewFx4mLEig6gawh7X6mFlEkA==", + "version": "1.6.3", + "resolved": "https://registry.npmjs.org/ufo/-/ufo-1.6.3.tgz", + "integrity": "sha512-yDJTmhydvl5lJzBmy/hyOAA0d+aqCBuwl818haVdYCRrWV84o7YyeVm4QlVHStqNrrJSTb6jKuFAVqAFsr+K3Q==", "license": "MIT" }, "node_modules/undici-types": { - "version": "7.10.0", - "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.10.0.tgz", - "integrity": "sha512-t5Fy/nfn+14LuOc2KNYg75vZqClpAiqscVvMygNnlsHBFpSXdJaYtXMcdNLpl/Qvc3P2cB3s6lOV51nqsFq4ag==", + "version": "7.18.2", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.18.2.tgz", + "integrity": "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w==", "license": "MIT" }, "node_modules/unicode-canonical-property-names-ecmascript": { @@ -19660,7 +20152,7 @@ "url": "https://opencollective.com/unified" } }, - "node_modules/unist-util-find-after/node_modules/unist-util-is": { + "node_modules/unist-util-is": { "version": "4.1.0", "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-4.1.0.tgz", "integrity": "sha512-ZOQSsnce92GrxSqlnEEseX0gi7GH9zTJZ0p9dtu87WRb/37mMPO2Ilx1s/t9vBHrFhbgweUwb+t7cIn5dxPhZg==", @@ -19670,19 +20162,6 @@ "url": "https://opencollective.com/unified" } }, - "node_modules/unist-util-is": { - "version": "6.0.1", - "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-6.0.1.tgz", - "integrity": "sha512-LsiILbtBETkDz8I9p1dQ0uyRUWuaQzd/cuEeS1hoRSyW5E5XGmTzlwY1OrNzzakGowI9Dr/I8HVaw4hTtnxy8g==", - "license": "MIT", - "dependencies": { - "@types/unist": "^3.0.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/unified" - } - }, "node_modules/unist-util-position": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-5.0.0.tgz", @@ -19723,9 +20202,9 @@ } }, "node_modules/unist-util-visit": { - "version": "5.0.0", - "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-5.0.0.tgz", - "integrity": "sha512-MR04uvD+07cwl/yhVuVWAtw+3GOR/knlL55Nd/wAdblk27GCVt3lqpTivy/tkJcZoNPzTwS1Y+KMojlLDhoTzg==", + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-5.1.0.tgz", + "integrity": "sha512-m+vIdyeCOpdr/QeQCu2EzxX/ohgS8KbnPDgFni4dQsfSCtpz8UqDyY5GjRru8PDKuYn7Fq19j1CQ+nJSsGKOzg==", "license": "MIT", "dependencies": { "@types/unist": "^3.0.0", @@ -19751,6 +20230,32 @@ "url": "https://opencollective.com/unified" } }, + "node_modules/unist-util-visit-parents/node_modules/unist-util-is": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-6.0.1.tgz", + "integrity": "sha512-LsiILbtBETkDz8I9p1dQ0uyRUWuaQzd/cuEeS1hoRSyW5E5XGmTzlwY1OrNzzakGowI9Dr/I8HVaw4hTtnxy8g==", + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/unist-util-visit/node_modules/unist-util-is": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-6.0.1.tgz", + "integrity": "sha512-LsiILbtBETkDz8I9p1dQ0uyRUWuaQzd/cuEeS1hoRSyW5E5XGmTzlwY1OrNzzakGowI9Dr/I8HVaw4hTtnxy8g==", + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, "node_modules/universalify": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz", @@ -19770,9 +20275,9 @@ } }, "node_modules/update-browserslist-db": { - "version": "1.2.2", - "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.2.tgz", - "integrity": "sha512-E85pfNzMQ9jpKkA7+TJAi4TJN+tBCuWh5rUcS/sv6cFi+1q9LYDwDI5dpUL0u/73EElyQ8d3TEaeW4sPedBqYA==", + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz", + "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==", "funding": [ { "type": "opencollective", @@ -19862,9 +20367,9 @@ } }, "node_modules/update-notifier/node_modules/chalk": { - "version": "5.6.0", - "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.6.0.tgz", - "integrity": "sha512-46QrSQFyVSEyYAgQ22hQ+zDa60YHA4fBstHmtSApj1Y5vKtG27fWowW03jCk5KcbXEWPZUIR894aARCA/G1kfQ==", + "version": "5.6.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.6.2.tgz", + "integrity": "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA==", "license": "MIT", "engines": { "node": "^12.17.0 || ^14.13 || >=16.0.0" @@ -19910,10 +20415,11 @@ } }, "node_modules/url-loader/node_modules/ajv": { - "version": "6.12.6", - "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz", - "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==", + "version": "6.14.0", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.14.0.tgz", + "integrity": "sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw==", "license": "MIT", + "peer": true, "dependencies": { "fast-deep-equal": "^3.1.1", "fast-json-stable-stringify": "^2.0.0", @@ -19979,15 +20485,6 @@ "url": "https://opencollective.com/webpack" } }, - "node_modules/use-sync-external-store": { - "version": "1.6.0", - "resolved": "https://registry.npmjs.org/use-sync-external-store/-/use-sync-external-store-1.6.0.tgz", - "integrity": "sha512-Pp6GSwGP/NrPIrxVFAIkOQeyw8lFenOHijQWkUTrDvrF4ALqylP2C/KCkeS9dpUM3KvYRQhna5vt7IL95+ZQ9w==", - "license": "MIT", - "peerDependencies": { - "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" - } - }, "node_modules/util-deprecate": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", @@ -20019,12 +20516,16 @@ } }, "node_modules/uuid": { - "version": "8.3.2", - "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz", - "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==", + "version": "11.1.0", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-11.1.0.tgz", + "integrity": "sha512-0/A9rDy9P7cJ+8w1c9WD9V//9Wj15Ce2MPz8Ri6032usz+NfePxx5AcN3bN+r6ZL6jEo066/yNYB3tn4pQEx+A==", + "funding": [ + "https://github.com/sponsors/broofa", + "https://github.com/sponsors/ctavan" + ], "license": "MIT", "bin": { - "uuid": "dist/bin/uuid" + "uuid": "dist/esm/bin/uuid" } }, "node_modules/value-equal": { @@ -20057,14 +20558,10 @@ } }, "node_modules/vfile-location": { - "version": "5.0.3", - "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-5.0.3.tgz", - "integrity": "sha512-5yXvWDEgqeiYiBe1lbxYF7UMAIm/IcopxMHrMQDq3nvKcjPKIhZklUKL+AE7J7uApI4kwe2snsK+eI6UTj9EHg==", + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-3.2.0.tgz", + "integrity": "sha512-aLEIZKv/oxuCDZ8lkJGhuhztf/BW4M+iHdCwglA/eWc+vtuRFJj8EtgceYFX4LRjOhCAAiNHsKGssC6onJ+jbA==", "license": "MIT", - "dependencies": { - "@types/unist": "^3.0.0", - "vfile": "^6.0.0" - }, "funding": { "type": "opencollective", "url": "https://opencollective.com/unified" @@ -20128,9 +20625,9 @@ "license": "MIT" }, "node_modules/vscode-uri": { - "version": "3.0.8", - "resolved": "https://registry.npmjs.org/vscode-uri/-/vscode-uri-3.0.8.tgz", - "integrity": "sha512-AyFQ0EVmsOZOlAnxoFOGOq1SQDWAB7C6aqMGS23svWAllfOaxbuFvcT8D1i8z3Gyn8fraVeZNNmN6e9bxxXkKw==", + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/vscode-uri/-/vscode-uri-3.1.0.tgz", + "integrity": "sha512-/BpdSx+yCQGnCvecbyXdxHDkuk55/G3xwnC0GqY4gmQ3j+A+g8kzzgB4Nk/SINjqn6+waqw3EgbVF2QKExkRxQ==", "license": "MIT" }, "node_modules/watchpack": { @@ -20156,9 +20653,9 @@ } }, "node_modules/web-namespaces": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/web-namespaces/-/web-namespaces-2.0.1.tgz", - "integrity": "sha512-bKr1DkiNa2krS7qxNtdrtHAmzuYGFQLiQ13TsorsdT6ULTkPLKuu5+GsFpDlg6JFjUTwX2DyhMPG2be8uPrqsQ==", + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/web-namespaces/-/web-namespaces-1.1.4.tgz", + "integrity": "sha512-wYxSGajtmoP4WxfejAPIr4l0fVh+jeMXZb08wNc0tMg6xsfZXj3cECqIK0G7ZAqUq0PP8WlMDtaOGVBTAWztNw==", "license": "MIT", "funding": { "type": "github", @@ -20166,10 +20663,11 @@ } }, "node_modules/webpack": { - "version": "5.105.0", - "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.105.0.tgz", - "integrity": "sha512-gX/dMkRQc7QOMzgTe6KsYFM7DxeIONQSui1s0n/0xht36HvrgbxtM1xBlgx596NbpHuQU8P7QpKwrZYwUX48nw==", + "version": "5.105.4", + "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.105.4.tgz", + "integrity": "sha512-jTywjboN9aHxFlToqb0K0Zs9SbBoW4zRUlGzI2tYNxVYcEi/IPpn+Xi4ye5jTLvX2YeLuic/IvxNot+Q1jMoOw==", "license": "MIT", + "peer": true, "dependencies": { "@types/eslint-scope": "^3.7.7", "@types/estree": "^1.0.8", @@ -20177,11 +20675,11 @@ "@webassemblyjs/ast": "^1.14.1", "@webassemblyjs/wasm-edit": "^1.14.1", "@webassemblyjs/wasm-parser": "^1.14.1", - "acorn": "^8.15.0", + "acorn": "^8.16.0", "acorn-import-phases": "^1.0.3", "browserslist": "^4.28.1", "chrome-trace-event": "^1.0.2", - "enhanced-resolve": "^5.19.0", + "enhanced-resolve": "^5.20.0", "es-module-lexer": "^2.0.0", "eslint-scope": "5.1.1", "events": "^3.2.0", @@ -20193,9 +20691,9 @@ "neo-async": "^2.6.2", "schema-utils": "^4.3.3", "tapable": "^2.3.0", - "terser-webpack-plugin": "^5.3.16", + "terser-webpack-plugin": "^5.3.17", "watchpack": "^2.5.1", - "webpack-sources": "^3.3.3" + "webpack-sources": "^3.3.4" }, "bin": { "webpack": "bin/webpack.js" @@ -20287,15 +20785,19 @@ } }, "node_modules/webpack-dev-middleware/node_modules/mime-types": { - "version": "3.0.1", - "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-3.0.1.tgz", - "integrity": "sha512-xRc4oEhT6eaBpU1XF7AjpOFD+xQmXNB5OVKwp4tqCuBpHLS/ZbBDrc07mYTDqVMg6PfxUjjNp85O6Cd2Z/5HWA==", + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-3.0.2.tgz", + "integrity": "sha512-Lbgzdk0h4juoQ9fCKXW4by0UJqj+nOOrI9MJ1sSj4nI8aI2eo1qmvQEie4VD1glsS250n15LsWsYtCugiStS5A==", "license": "MIT", "dependencies": { "mime-db": "^1.54.0" }, "engines": { - "node": ">= 0.6" + "node": ">=18" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" } }, "node_modules/webpack-dev-middleware/node_modules/range-parser": { @@ -20308,14 +20810,14 @@ } }, "node_modules/webpack-dev-server": { - "version": "5.2.2", - "resolved": "https://registry.npmjs.org/webpack-dev-server/-/webpack-dev-server-5.2.2.tgz", - "integrity": "sha512-QcQ72gh8a+7JO63TAx/6XZf/CWhgMzu5m0QirvPfGvptOusAxG12w2+aua1Jkjr7hzaWDnJ2n6JFeexMHI+Zjg==", + "version": "5.2.3", + "resolved": "https://registry.npmjs.org/webpack-dev-server/-/webpack-dev-server-5.2.3.tgz", + "integrity": "sha512-9Gyu2F7+bg4Vv+pjbovuYDhHX+mqdqITykfzdM9UyKqKHlsE5aAjRhR+oOEfXW5vBeu8tarzlJFIZva4ZjAdrQ==", "license": "MIT", "dependencies": { "@types/bonjour": "^3.5.13", "@types/connect-history-api-fallback": "^1.5.4", - "@types/express": "^4.17.21", + "@types/express": "^4.17.25", "@types/express-serve-static-core": "^4.17.21", "@types/serve-index": "^1.9.4", "@types/serve-static": "^1.15.5", @@ -20325,9 +20827,9 @@ "bonjour-service": "^1.2.1", "chokidar": "^3.6.0", "colorette": "^2.0.10", - "compression": "^1.7.4", + "compression": "^1.8.1", "connect-history-api-fallback": "^2.0.0", - "express": "^4.21.2", + "express": "^4.22.1", "graceful-fs": "^4.2.6", "http-proxy-middleware": "^2.0.9", "ipaddr.js": "^2.1.0", @@ -20335,7 +20837,7 @@ "open": "^10.0.3", "p-retry": "^6.2.0", "schema-utils": "^4.2.0", - "selfsigned": "^2.4.1", + "selfsigned": "^5.5.0", "serve-index": "^1.9.1", "sockjs": "^0.3.24", "spdy": "^4.0.2", @@ -20395,9 +20897,9 @@ } }, "node_modules/webpack-dev-server/node_modules/ws": { - "version": "8.18.3", - "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz", - "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==", + "version": "8.19.0", + "resolved": "https://registry.npmjs.org/ws/-/ws-8.19.0.tgz", + "integrity": "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==", "license": "MIT", "engines": { "node": ">=10.0.0" @@ -20430,9 +20932,9 @@ } }, "node_modules/webpack-sources": { - "version": "3.3.3", - "resolved": "https://registry.npmjs.org/webpack-sources/-/webpack-sources-3.3.3.tgz", - "integrity": "sha512-yd1RBzSGanHkitROoPFd6qsrxt+oFhg/129YzheDGqeustzX0vTZJZsSsQjVQC4yzBQ56K55XU8gaNCtIzOnTg==", + "version": "3.3.4", + "resolved": "https://registry.npmjs.org/webpack-sources/-/webpack-sources-3.3.4.tgz", + "integrity": "sha512-7tP1PdV4vF+lYPnkMR0jMY5/la2ub5Fc/8VQrrU+lXkiM6C4TjVfGw7iKfyhnTQOsD+6Q/iKw0eFciziRgD58Q==", "license": "MIT", "engines": { "node": ">=10.13.0" @@ -20637,9 +21139,9 @@ } }, "node_modules/wrap-ansi/node_modules/ansi-regex": { - "version": "6.2.0", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.2.0.tgz", - "integrity": "sha512-TKY5pyBkHyADOPYlRT9Lx6F544mPl0vS5Ew7BJ45hA08Q+t3GjbueLliBWN3sMICk6+y7HdyxSzC4bWS8baBdg==", + "version": "6.2.2", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.2.2.tgz", + "integrity": "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==", "license": "MIT", "engines": { "node": ">=12" @@ -20649,9 +21151,9 @@ } }, "node_modules/wrap-ansi/node_modules/ansi-styles": { - "version": "6.2.1", - "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.1.tgz", - "integrity": "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==", + "version": "6.2.3", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.3.tgz", + "integrity": "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==", "license": "MIT", "engines": { "node": ">=12" @@ -20661,12 +21163,12 @@ } }, "node_modules/wrap-ansi/node_modules/strip-ansi": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz", - "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==", + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.2.0.tgz", + "integrity": "sha512-yDPMNjp4WyfYBkHnjIRLfca1i6KMyGCtsVgoKe/z1+6vukgaENdgGBZt+ZmKPc4gavvEZ5OgHfHdrazhgNyG7w==", "license": "MIT", "dependencies": { - "ansi-regex": "^6.0.1" + "ansi-regex": "^6.2.2" }, "engines": { "node": ">=12" @@ -20724,9 +21226,9 @@ } }, "node_modules/wsl-utils/node_modules/is-wsl": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/is-wsl/-/is-wsl-3.1.0.tgz", - "integrity": "sha512-UcVfVfaK4Sc4m7X3dUSoHoozQGBEFeDC+zVo06t98xe8CzHSZZBekNXH+tu0NalHolcJ/QAGqS46Hef7QXBIMw==", + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/is-wsl/-/is-wsl-3.1.1.tgz", + "integrity": "sha512-e6rvdUCiQCAuumZslxRJWR/Doq4VpPR82kqclvcS0efgt430SlGIk05vdCN58+VrzgtIcfNODjozVielycD4Sw==", "license": "MIT", "dependencies": { "is-inside-container": "^1.0.0" @@ -20789,19 +21291,10 @@ "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/zod": { - "version": "4.1.12", - "resolved": "https://registry.npmjs.org/zod/-/zod-4.1.12.tgz", - "integrity": "sha512-JInaHOamG8pt5+Ey8kGmdcAcg3OL9reK8ltczgHTAwNhMys/6ThXHityHxVV2p3fkw/c+MAvBHFVYHFZDmjMCQ==", - "license": "MIT", - "funding": { - "url": "https://github.com/sponsors/colinhacks" - } - }, "node_modules/zwitch": { - "version": "2.0.4", - "resolved": "https://registry.npmjs.org/zwitch/-/zwitch-2.0.4.tgz", - "integrity": "sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A==", + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/zwitch/-/zwitch-1.0.5.tgz", + "integrity": "sha512-V50KMwwzqJV0NpZIZFwfOD5/lyny3WlSzRiXgA0G7VUnRlqttta1L6UQIHzd6EuBY/cHGfwTIck7w1yH6Q5zUw==", "license": "MIT", "funding": { "type": "github", diff --git a/package.json b/package.json index a8c450f..1f45209 100644 --- a/package.json +++ b/package.json @@ -13,6 +13,7 @@ "write-translations": "docusaurus write-translations", "write-heading-ids": "docusaurus write-heading-ids", "typecheck": "tsc", + "sync:contracts": "node scripts/sync-contracts-docs.js", "version:remove": "node scripts/remove-version.js", "version:reset": "node scripts/reset-versions.js", "version:release": "node scripts/release-version.js" @@ -20,8 +21,8 @@ "dependencies": { "@docusaurus/core": "3.9.2", "@docusaurus/preset-classic": "3.9.2", - "@docusaurus/theme-mermaid": "^3.9.2", - "@docusaurus/theme-search-algolia": "^3.9.2", + "@docusaurus/theme-mermaid": "3.9.2", + "@docusaurus/theme-search-algolia": "3.9.2", "@mdx-js/react": "^3.1.1", "@tippyjs/react": "^4.2.6", "clsx": "^2.0.0", @@ -55,5 +56,8 @@ }, "engines": { "node": ">=18.0" + }, + "overrides": { + "serialize-javascript": "^7.0.3" } -} \ No newline at end of file +} diff --git a/scripts/sync-contracts-docs.js b/scripts/sync-contracts-docs.js new file mode 100644 index 0000000..f198440 --- /dev/null +++ b/scripts/sync-contracts-docs.js @@ -0,0 +1,348 @@ +/** + * Syncs smart-contract documentation from vendors/yellow/docs + * into docs/contracts/ with Docusaurus-compatible frontmatter + * and category metadata. + * + * Usage: node scripts/sync-contracts-docs.js + * + * Safe to re-run — it wipes docs/contracts/ and rebuilds from source. + */ +const fs = require('fs'); +const path = require('path'); + +const ROOT = path.resolve(__dirname, '..'); +const SRC = path.join(ROOT, 'vendors', 'yellow', 'docs'); +const DEST = path.join(ROOT, 'docs', 'contracts'); + +// --------------------------------------------------------------------------- +// Helpers +// --------------------------------------------------------------------------- + +function ensureDir(dir) { + fs.mkdirSync(dir, { recursive: true }); +} + +function cleanDir(dir) { + if (fs.existsSync(dir)) { + fs.rmSync(dir, { recursive: true, force: true }); + } + ensureDir(dir); +} + +/** + * Escape {word} patterns in prose lines so MDX doesn't interpret them as JSX. + * Preserves code blocks (``` fenced) and inline code (`...`). + */ +function escapeCurlyBracesOutsideCode(text) { + const lines = text.split('\n'); + let inCodeBlock = false; + return lines.map(line => { + if (line.trimStart().startsWith('```')) { + inCodeBlock = !inCodeBlock; + return line; + } + if (inCodeBlock) return line; + // Escape {word} outside of inline code spans + return line.replace(/(`[^`]*`)|(\{[^}]+\})/g, (match, code, braces) => { + if (code) return code; // preserve inline code + return '\\' + braces.slice(0, -1) + '\\}'; + }); + }).join('\n'); +} + +/** + * Strip existing frontmatter (--- delimited) or auto-generated comments, + * then prepend Docusaurus frontmatter. + */ +function copyWithFrontmatter(srcFile, destFile, { title, description, sidebarPosition }) { + let content = fs.readFileSync(srcFile, 'utf-8'); + + // Strip existing frontmatter + if (content.startsWith('---')) { + const endIdx = content.indexOf('---', 3); + if (endIdx !== -1) { + content = content.slice(endIdx + 3).replace(/^\n/, ''); + } + } + + // Strip auto-generated comments + content = content.replace(/^\n*/m, ''); + + // Escape curly braces in prose so MDX doesn't treat them as JSX expressions. + // Only escape {word} patterns outside of code blocks/fences. + content = escapeCurlyBracesOutsideCode(content); + + const frontmatter = [ + '---', + `title: "${title}"`, + `description: "${description}"`, + `sidebar_position: ${sidebarPosition}`, + `displayed_sidebar: contractsSidebar`, + '---', + '', + '', + ].join('\n'); + + ensureDir(path.dirname(destFile)); + fs.writeFileSync(destFile, frontmatter + content); +} + +/** + * Write a Docusaurus _category_.json file. + */ +function writeCategory(dir, { label, position, link }) { + ensureDir(dir); + const data = { + label, + position, + link: link || { type: 'generated-index' }, + collapsible: false, + collapsed: false, + }; + fs.writeFileSync(path.join(dir, '_category_.json'), JSON.stringify(data, null, 2) + '\n'); +} + +// --------------------------------------------------------------------------- +// Document mapping +// --------------------------------------------------------------------------- + +const DOCS = { + // Top-level pages + index: { + src: 'what-is-yellow.md', + title: 'Smart Contracts', + description: 'Overview of Yellow Network smart contracts, governance, and on-chain infrastructure.', + sidebarPosition: 1, + }, + addresses: { + src: 'operations/addresses.md', + title: 'Deployed Addresses', + description: 'Mainnet and testnet contract addresses for Yellow Network.', + sidebarPosition: 2, + }, + faq: { + src: 'FAQ.md', + title: 'FAQ', + description: 'Frequently asked questions about Yellow Network smart contracts.', + sidebarPosition: 7, + }, + + // Protocol + 'protocol/overview': { + src: 'protocol/overview.md', + title: 'Protocol Overview', + description: 'Architecture, contracts, and how they fit together.', + sidebarPosition: 1, + }, + 'protocol/governance': { + src: 'protocol/governance.md', + title: 'Governance', + description: 'On-chain parameter administration via YellowGovernor.', + sidebarPosition: 2, + }, + 'protocol/staking': { + src: 'protocol/staking.md', + title: 'Collateral & Staking', + description: 'Lock/unlock state machine for NodeRegistry and AppRegistry.', + sidebarPosition: 3, + }, + 'protocol/slashing': { + src: 'protocol/slashing.md', + title: 'Slashing', + description: 'Adjudicator slashing and cooldown mechanism.', + sidebarPosition: 4, + }, + 'protocol/treasury': { + src: 'protocol/treasury.md', + title: 'Treasury', + description: 'Foundation asset management.', + sidebarPosition: 5, + }, + + // Contract API Reference + 'api-reference/yellow-token': { + src: 'contracts/Token.sol/contract.YellowToken.md', + title: 'YellowToken', + description: 'ERC-20 token with fixed 10B supply.', + sidebarPosition: 1, + }, + 'api-reference/locker': { + src: 'contracts/Locker.sol/abstract.Locker.md', + title: 'Locker', + description: 'Abstract lock/unlock/withdraw state machine.', + sidebarPosition: 2, + }, + 'api-reference/node-registry': { + src: 'contracts/NodeRegistry.sol/contract.NodeRegistry.md', + title: 'NodeRegistry', + description: 'Node operator registry with voting power.', + sidebarPosition: 3, + }, + 'api-reference/app-registry': { + src: 'contracts/AppRegistry.sol/contract.AppRegistry.md', + title: 'AppRegistry', + description: 'App builder registry with slashing.', + sidebarPosition: 4, + }, + 'api-reference/yellow-governor': { + src: 'contracts/Governor.sol/contract.YellowGovernor.md', + title: 'YellowGovernor', + description: 'OpenZeppelin Governor for protocol parameters.', + sidebarPosition: 5, + }, + 'api-reference/treasury': { + src: 'contracts/Treasury.sol/contract.Treasury.md', + title: 'Treasury', + description: 'Secure vault for Foundation assets.', + sidebarPosition: 6, + }, + 'api-reference/faucet': { + src: 'contracts/Faucet.sol/contract.Faucet.md', + title: 'Faucet', + description: 'Testnet token faucet.', + sidebarPosition: 7, + }, + 'api-reference/interfaces/ilock': { + src: 'contracts/interfaces/ILock.sol/interface.ILock.md', + title: 'ILock', + description: 'Lock/unlock/withdraw interface.', + sidebarPosition: 1, + }, + 'api-reference/interfaces/islash': { + src: 'contracts/interfaces/ISlash.sol/interface.ISlash.md', + title: 'ISlash', + description: 'Slashing interface.', + sidebarPosition: 2, + }, + + // SDK + 'sdk/getting-started': { + src: 'sdk/getting-started.md', + title: 'Getting Started', + description: 'Install, import, and use the contracts SDK.', + sidebarPosition: 1, + }, + 'sdk/api-reference': { + src: 'sdk/api-reference.md', + title: 'SDK API Reference', + description: 'All exports: ABIs, addresses, and types.', + sidebarPosition: 2, + }, + 'sdk/examples': { + src: 'sdk/examples.md', + title: 'Examples', + description: 'Code samples for viem, ethers.js, and wagmi.', + sidebarPosition: 3, + }, + + // Integration + 'integration/deployment': { + src: 'integration/deployment.md', + title: 'Deployment', + description: 'Deploying contracts and configuration.', + sidebarPosition: 1, + }, + 'integration/events': { + src: 'integration/events.md', + title: 'Events', + description: 'Contract events for real-time subscriptions.', + sidebarPosition: 2, + }, + 'integration/ui-spec': { + src: 'integration/ui-spec.md', + title: 'UI Specification', + description: 'Frontend implementation guide.', + sidebarPosition: 3, + }, +}; + +// Category metadata +const CATEGORIES = [ + { dir: 'protocol', label: 'Protocol', position: 3 }, + { dir: 'api-reference', label: 'Contract API Reference', position: 4 }, + { dir: 'api-reference/interfaces', label: 'Interfaces', position: 8 }, + { dir: 'sdk', label: 'SDK', position: 5 }, + { dir: 'integration', label: 'Integration', position: 6 }, +]; + +// --------------------------------------------------------------------------- +// Main +// --------------------------------------------------------------------------- + +function main() { + // Validate source + if (!fs.existsSync(SRC)) { + console.error(`Error: vendor docs not found at ${SRC}`); + console.error('Run: git submodule update --init --recursive'); + process.exit(1); + } + + console.log('Syncing smart-contract docs from vendors/yellow/docs...\n'); + + // Clean and recreate destination + cleanDir(DEST); + + // Write category files + for (const cat of CATEGORIES) { + writeCategory(path.join(DEST, cat.dir), { + label: cat.label, + position: cat.position, + }); + } + + // Copy and transform each document + let count = 0; + const missing = []; + + for (const [destSlug, meta] of Object.entries(DOCS)) { + const srcFile = path.join(SRC, meta.src); + const destFile = path.join(DEST, destSlug + '.md'); + + if (!fs.existsSync(srcFile)) { + missing.push(meta.src); + continue; + } + + copyWithFrontmatter(srcFile, destFile, meta); + count++; + console.log(` copied ${meta.src} -> contracts/${destSlug}.md`); + } + + if (missing.length > 0) { + console.warn(`\nWarning: ${missing.length} source file(s) not found:`); + for (const m of missing) { + console.warn(` missing ${m}`); + } + } + + console.log(`\nSynced ${count} docs into docs/contracts/`); + console.log('\nStructure:'); + + // Print tree + function printTree(dir, prefix) { + const entries = fs.readdirSync(dir, { withFileTypes: true }).sort((a, b) => { + // Directories first + if (a.isDirectory() && !b.isDirectory()) return -1; + if (!a.isDirectory() && b.isDirectory()) return 1; + return a.name.localeCompare(b.name); + }); + + entries.forEach((entry, i) => { + const isLast = i === entries.length - 1; + const connector = isLast ? '└── ' : '├── '; + const full = path.join(dir, entry.name); + + if (entry.name === '_category_.json') return; // skip noise + + console.log(`${prefix}${connector}${entry.name}`); + if (entry.isDirectory()) { + printTree(full, prefix + (isLast ? ' ' : '│ ')); + } + }); + } + + console.log('docs/contracts/'); + printTree(DEST, ''); +} + +main(); diff --git a/sidebars.ts b/sidebars.ts index d2f71a6..a044597 100644 --- a/sidebars.ts +++ b/sidebars.ts @@ -114,6 +114,14 @@ const sidebars: SidebarsConfig = { }, ], + // Contracts section sidebar + contractsSidebar: [ + { + type: 'autogenerated', + dirName: 'contracts', + }, + ], + // Default sidebar for standalone pages defaultSidebar: [ ], diff --git a/src/constants/tooltipDefinitions.ts b/src/constants/tooltipDefinitions.ts index 5a212cc..17c6beb 100644 --- a/src/constants/tooltipDefinitions.ts +++ b/src/constants/tooltipDefinitions.ts @@ -1,10 +1,10 @@ export const tooltipDefinitions = { - nitroliteProtocol: - "The on-chain smart contract protocol for state channels.", + virtualAppProtocol: + "The App Layer (VirtualApp) protocol — state channels with on-chain custody and off-chain RPC for building YApps.", channel: "A secure communication pathway between participants that locks funds in an on-chain smart contract while enabling off-chain state updates.", clearnode: - "A node operated by independent operators using open-source software developed by Layer3 Fintech Ltd. It provides a unified ledger (through Nitro RPC), coordinates state channels (through Nitrolite), and enables chain abstraction for developers and users.", + "A node operated by independent operators using open-source software developed by Layer3 Fintech Ltd. It provides a unified ledger (through the Nitro RPC protocol), coordinates state channels (through VirtualApp), and enables chain abstraction for developers and users.", nitroRpc: "The off-chain communication protocol.", channelState: "A snapshot of the channel at any point in time, including fund allocations and application-specific data.", @@ -19,7 +19,7 @@ export const tooltipDefinitions = { appSessionId: "A unique identifier for an app session, formatted as a 0x-prefixed hex string (32 bytes).", custodyContract: - "The primary Nitrolite contract that locks and unlocks funds, manages channel lifecycle (create/close/challenge), tracks channel state, and coordinates with adjudicators to validate transitions.", + "The primary VirtualApp contract that locks and unlocks funds, manages channel lifecycle (create/close/challenge), tracks channel state, and coordinates with adjudicators to validate transitions.", unifiedBalance: "An abstraction that aggregates users' funds across multiple blockchain networks, managed by a clearnode.", sessionKey: diff --git a/src/pages/whitepaper.md b/src/pages/whitepaper.md index 580cb9f..f5eb288 100644 --- a/src/pages/whitepaper.md +++ b/src/pages/whitepaper.md @@ -88,7 +88,7 @@ Yellow is an open-source software framework developed through multi-entity colla | Helios Technologies SAS (France) | Core Technology Development | | Openware SAS (France) | Core Technology Development | -The core state channel technology builds on academic research from statechannels.org and the Nitrolite framework, developed in collaboration with Consensys and other open-source contributors. Approximately 60 core developers contribute across the open-source codebase, with over 100 third-party applications launched on the network in 2025. +The core state channel technology builds on academic research from statechannels.org and the VirtualApp framework, developed in collaboration with Consensys and other open-source contributors. Approximately 60 core developers contribute across the open-source codebase, with over 100 third-party applications launched on the network in 2025. ### Token Utility @@ -161,7 +161,7 @@ Protocol-level service parameters (security thresholds, fee levels, supported ch ### Architecture -The Yellow Network operates as a three-layer architecture built on top of public blockchains. The underlying technology builds on open-source state channel research (statechannels.org) and collaborative development, including the Nitrolite framework developed with Consensys. +The Yellow Network operates as a three-layer architecture built on top of public blockchains. The underlying technology builds on open-source state channel research (statechannels.org) and collaborative development, including the VirtualApp framework developed with Consensys. **Layer 1 — Base Blockchain (EVM Settlement)** diff --git a/vendors/yellow b/vendors/yellow new file mode 160000 index 0000000..8abb527 --- /dev/null +++ b/vendors/yellow @@ -0,0 +1 @@ +Subproject commit 8abb527264e478902212f455e1693cde57757ef9