@nktkas/hyperliquid 0.13.0

package/CONTRIBUTING.md

@@ -0,0 +1,59 @@
+# Contributing to @nktkas/hyperliquid
+
+First off, thanks for considering contributing to the Hyperliquid TypeScript SDK!
+
+## How Can You Contribute?
+
+### Report Issues
+
+If you find bugs or have suggestions for improvements, please open an issue on GitHub. Provide as much detail as
+possible to help us understand and address the problem.
+
+### Submit Pull Requests
+
+- **Fork the Repository**: Click the "Fork" button at the top-right corner of the repository page.
+- **Clone Your Fork**: Clone your forked repository to your local machine.
+
+```bash
+git clone https://github.com/your-username/hyperliquid.git
+```
+
+- **Create a Branch**: Create a new branch for your feature or bug fix.
+
+```bash
+git checkout -b feature/your-feature-name
+```
+
+- **Make Your Changes**: Implement your feature or fix the bug.
+- **Commit Your Changes**:
+
+```bash
+git commit -am "Add new feature or fix"
+```
+
+- **Push to Your Fork**:
+
+```bash
+git push origin feature/your-feature-name
+```
+
+- **Create a Pull Request**: Go to the original repository and click on "New Pull Request". Select your branch and
+  submit the pull request.
+
+### Coding Guidelines
+
+- **TypeScript**: Ensure your code passes TypeScript compilation without errors.
+- **Style**: Follow existing code style and conventions.
+- **Dependencies**: Avoid adding unnecessary dependencies.
+- **Docs**: Update or add JSDoc comments where appropriate.
+
+### Testing
+
+Before submitting your pull request:
+
+- Run existing tests to ensure nothing breaks.
+- If you add new features, consider adding tests for them.
+
+### License
+
+By contributing, you agree that your contributions will be licensed under the MIT License.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-2025 nktkas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,363 @@
+# Hyperliquid API TypeScript SDK
+
+[![JSR](https://jsr.io/badges/@nktkas/hyperliquid)](https://jsr.io/@nktkas/hyperliquid)
+[![JSR Score](https://jsr.io/badges/@nktkas/hyperliquid/score)](https://jsr.io/@nktkas/hyperliquid)
+
+Unofficial [Hyperliquid API](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api) SDK for all major JS
+runtimes, written in TypeScript and provided with tests.
+
+## Features
+
+- 🖋️ **Typed**: Source code is 100% TypeScript.
+- 🧪 **Tested**: Good code coverage and type validation.
+- 📦 **Minimal dependencies**: Few small dependencies, standard JS is favored.
+- 🌐 **Cross-Environment Support**: Compatible with all major JS runtimes, including Node.js, Deno, Bun, and browser
+  environments.
+- 🔧 **Extensible**: Easily integrates with [viem](https://github.com/wevm/viem) and
+  [ethers](https://github.com/ethers-io/ethers.js).
+- 📚 **Documented**: Comprehensive documentation and usage examples, provided directly in JSDoc annotations within the
+  source code.
+
+## Installation
+
+```bash
+# npm
+npx jsr add @nktkas/hyperliquid
+
+# yarn 
+yarn dlx jsr add @nktkas/hyperliquid
+
+# pnpm
+pnpm dlx jsr add @nktkas/hyperliquid
+
+# bun
+bunx jsr add @nktkas/hyperliquid
+
+# deno
+deno add jsr:@nktkas/hyperliquid
+
+# web (import directly)
+import * as hl from "https://esm.sh/jsr/@nktkas/hyperliquid"
+```
+
+## Usage
+
+### Initialize Transport
+
+First, choose and configure your transport layer (more details in the [API Reference](#transports)):
+
+```typescript
+import * as hl from "@nktkas/hyperliquid";
+
+// HTTP Transport
+const httpTransport = new hl.HttpTransport({ // All options are optional
+    url: "https://api.hyperliquid.xyz", // API base URL for /info, /exchange, /explorer
+    timeout: 10_000, // Request timeout in ms
+});
+
+// OR WebSocket Transport
+const wsTransport = new hl.WebSocketTransport({ // All options are optional
+    url: "wss://api.hyperliquid.xyz/ws", // WebSocket URL
+    timeout: 10_000, // Request timeout in ms
+});
+```
+
+### Initialize Client
+
+Next, initialize the client with the transport layer (more details in the [API Reference](#clients)):
+
+#### Create PublicClient
+
+```typescript
+import * as hl from "@nktkas/hyperliquid";
+
+const transport = new hl.HttpTransport(); // or WebSocketTransport
+const client = new hl.PublicClient({ transport });
+```
+
+#### Create WalletClient
+
+```typescript
+import * as hl from "@nktkas/hyperliquid";
+import { createWalletClient, custom } from "viem";
+import { arbitrum } from "viem/chains";
+import { privateKeyToAccount } from "viem/accounts";
+import { ethers } from "ethers";
+
+const transport = new hl.HttpTransport(); // or WebSocketTransport
+
+// 1. Using Viem with private key
+const viemAccount = privateKeyToAccount("0x...");
+const viemClient = new hl.WalletClient({ wallet: viemAccount, transport });
+
+// 2. Using Ethers (or Ethers V5) with private key
+const ethersWallet = new ethers.Wallet("0x...");
+const ethersClient = new hl.WalletClient({ wallet: ethersWallet, transport });
+
+// 3. Using external wallet (e.g. MetaMask) via Viem
+const [account] = await window.ethereum.request({ method: "eth_requestAccounts" });
+const externalWallet = createWalletClient({
+    account,
+    chain: arbitrum,
+    transport: custom(window.ethereum),
+});
+const metamaskClient = new hl.WalletClient({ wallet: externalWallet, transport });
+```
+
+## API Reference
+
+### Clients
+
+A **Client** provides access to the Hyperliquid API endpoints.
+
+There are three types of **Clients** in the sdk:
+
+#### Public Client
+
+A Public Client which provides access to
+[Info API](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/info-endpoint) and Explorer API, such as
+`l2Book` and `clearinghouseState`.
+
+The Public Client class sets up with a given [Transport](#transports).
+
+```typescript
+interface PublicClientParameters<T extends IRequestTransport = IRequestTransport> {
+    transport: T; // HttpTransport or WebSocketTransport
+}
+
+class PublicClient<T extends IRESTTransport> {
+    constructor(args: PublicClientParameters<T>);
+
+    // Market
+    allMids(): Promise<AllMids>;
+    candleSnapshot(args: CandleSnapshotParameters): Promise<CandleSnapshot[]>;
+    fundingHistory(args: FundingHistoryParameters): Promise<FundingHistory[]>;
+    l2Book(args: L2BookParameters): Promise<L2Book>;
+    meta(): Promise<Meta>;
+    metaAndAssetCtxs(): Promise<MetaAndAssetCtxs>;
+    predictedFundings(): Promise<PredictedFunding[]>;
+    spotDeployState(args: SpotDeployStateParameters): Promise<SpotDeployState>;
+    spotMeta(): Promise<SpotMeta>;
+    spotMetaAndAssetCtxs(): Promise<SpotMetaAndAssetCtxs>;
+    tokenDetails(args: TokenDetailsParameters): Promise<TokenDetails>;
+
+    // Account
+    clearinghouseState(args: ClearinghouseStateParameters): Promise<ClearinghouseState>;
+    extraAgents(args: ExtraAgentsParameters): Promise<ExtraAgent[]>;
+    maxBuilderFee(args: MaxBuilderFeeParameters): Promise<number>;
+    referral(args: ReferralParameters): Promise<Referral>;
+    spotClearinghouseState(args: SpotClearinghouseStateParameters): Promise<SpotClearinghouseState>;
+    subAccounts(args: SubAccountsParameters): Promise<SubAccount[]>;
+    userFees(args: UserFeesParameters): Promise<UserFees>;
+    userFunding(args: UserFundingParameters): Promise<UserFunding[]>;
+    userNonFundingLedgerUpdates(args: UserNonFundingLedgerUpdatesParameters): Promise<UserNonFundingLedgerUpdates[]>;
+    userRateLimit(args: UserRateLimitParameters): Promise<UserRateLimit>;
+
+    // Order
+    frontendOpenOrders(args: FrontendOpenOrdersParameters): Promise<FrontendOpenOrder[]>;
+    historicalOrders(args: HistoricalOrdersParameters): Promise<OrderStatus[]>;
+    openOrders(args: OpenOrdersParameters): Promise<OpenOrder[]>;
+    orderStatus(args: OrderStatusParameters): Promise<OrderStatusResponse>;
+    twapHistory(args: TwapHistoryParameters): Promise<TwapHistory>;
+    userFills(args: UserFillsParameters): Promise<UserFill[]>;
+    userFillsByTime(args: UserFillsByTimeParameters): Promise<UserFill[]>;
+    userTwapSliceFills(args: UserTwapSliceFillsParameters): Promise<UserTwapSliceFill[]>;
+
+    // Vault
+    userVaultEquities(args: UserVaultEquitiesParameters): Promise<UserVaultEquity[]>;
+    vaultDetails(args: VaultDetailsParameters): Promise<VaultDetails | null>;
+    vaultSummaries(): Promise<VaultSummary[]>;
+
+    // Blockchain
+    blockDetails(args: BlockDetailsParameters): Promise<BlockDetailsResponse>;
+    txDetails(args: TxDetailsParameters): Promise<TxDetailsResponse>;
+}
+```
+
+#### Wallet Client
+
+A Wallet Client which provides access to
+[Exchange API](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint), such as `order`
+and `withdraw3`.
+
+The Wallet Client class sets up with a given [Transport](#transports) and a wallet instance, which can be a
+[Viem Wallet](https://viem.sh/docs/clients/wallet) or an
+[Ethers Wallet](https://docs.ethers.org/v6/api/providers/#Signer).
+
+```typescript
+interface WalletClientParameters<
+    T extends ISubscriptionTransport,
+    W extends AbstractViemWalletClient | AbstractEthersSigner | AbstractEthersV5Signer,
+> {
+    transport: T; // HttpTransport or WebSocketTransport
+    wallet: W; // viem, ethers, or ethers v5
+    isTestnet?: boolean; // Whether to use testnet API (default: false)
+    defaultVaultAddress?: Hex; // Vault address used by default if not provided in method call
+}
+
+class WalletClient<
+    T extends IRESTTransport,
+    W extends AbstractViemWalletClient | AbstractEthersSigner | AbstractEthersV5Signer,
+> {
+    constructor(args: WalletClientParameters<T, W>);
+
+    // Order Management
+    batchModify(args: BatchModifyParameters): Promise<OrderResponseSuccess>;
+    cancel(args: CancelParameters): Promise<CancelResponseSuccess>;
+    cancelByCloid(args: CancelByCloidParameters): Promise<CancelResponseSuccess>;
+    modify(args: ModifyParameters): Promise<SuccessResponse>;
+    order(args: OrderParameters): Promise<OrderResponseSuccess>;
+    scheduleCancel(args: ScheduleCancelParameters): Promise<SuccessResponse>;
+    twapCancel(args: TwapCancelParameters): Promise<TwapCancelResponseSuccess>;
+    twapOrder(args: TwapOrderParameters): Promise<TwapOrderResponseSuccess>;
+    updateIsolatedMargin(args: UpdateIsolatedMarginParameters): Promise<SuccessResponse>;
+    updateLeverage(args: UpdateLeverageParameters): Promise<SuccessResponse>;
+
+    // Account Management
+    approveAgent(args: ApproveAgentParameters): Promise<SuccessResponse>;
+    approveBuilderFee(args: ApproveBuilderFeeParameters): Promise<SuccessResponse>;
+    createSubAccount(args: CreateSubAccountParameters): Promise<CreateSubAccountResponse>;
+    setReferrer(args: SetReferrerParameters): Promise<SuccessResponse>;
+
+    // Transfers & Withdrawals
+    spotSend(args: SpotSendParameters): Promise<SuccessResponse>;
+    subAccountTransfer(args: SubAccountTransferParameters): Promise<SuccessResponse>;
+    usdClassTransfer(args: UsdClassTransferParameters): Promise<SuccessResponse>;
+    usdSend(args: UsdSendParameters): Promise<SuccessResponse>;
+    vaultTransfer(args: VaultTransferParameters): Promise<SuccessResponse>;
+    withdraw3(args: Withdraw3Parameters): Promise<SuccessResponse>;
+}
+```
+
+#### Event Client
+
+A Event Client which provides access to
+[Subscriptions API](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions), such as
+real-time updates for `l2Book` and `userFills`.
+
+The Event Client class sets up with a given [WebSocket Transport](#websocket-transport).
+
+<!-- deno-fmt-ignore-start -->
+```typescript
+interface EventClientParameters<T extends ISubscriptionTransport> {
+    transport: T; // WebSocketTransport
+}
+
+class EventClient<T extends ISubscriptionTransport> {
+    constructor(args: EventClientParameters<T>);
+
+    // Market Data
+    activeAssetCtx(args: EventActiveAssetCtxParameters, listener: (data: WsActiveAssetCtx | WsActiveSpotAssetCtx) => void): Promise<Subscription>;
+    activeAssetData(args: EventActiveAssetDataParameters, listener: (data: WsActiveAssetData) => void): Promise<Subscription>;
+    allMids(listener: (data: WsAllMids) => void): Promise<Subscription>;
+    candle(args: EventCandleParameters, listener: (data: Candle) => void): Promise<Subscription>;
+    l2Book(args: EventL2BookParameters, listener: (data: Book) => void): Promise<Subscription>;
+    trades(args: EventTradesParameters, listener: (data: WsTrade[]) => void): Promise<Subscription>;
+
+    // Account/User Data
+    notification(args: EventNotificationParameters, listener: (data: WsNotification) => void): Promise<Subscription>;
+    userEvents(args: EventUserEventsParameters, listener: (data: WsUserEvent) => void): Promise<Subscription>;
+    userFundings(args: EventUserFundingsParameters, listener: (data: WsUserFundings) => void): Promise<Subscription>;
+    userNonFundingLedgerUpdates(args: EventUserNonFundingLedgerUpdatesParameters, listener: (data: WsUserNonFundingLedgerUpdates) => void): Promise<Subscription>;
+    webData2(args: EventWebData2Parameters, listener: (data: WsWebData2) => void): Promise<Subscription>;
+
+    // Order Management
+    orderUpdates(args: EventOrderUpdatesParameters, listener: (data: OrderStatus) => void): Promise<Subscription>;
+    userFills(args: EventUserFillsParameters, listener: (data: WsUserFills) => void): Promise<Subscription>;
+    userTwapHistory(args: EventUserTwapHistory, listener: (data: WsUserTwapHistory) => void): Promise<Subscription>;
+    userTwapSliceFills(args: EventUserTwapSliceFills, listener: (data: WsUserTwapSliceFills) => void): Promise<Subscription>;
+}
+```
+<!-- deno-fmt-ignore-end -->
+
+### Transports
+
+A [Client](#clients) is instantiated with a **Transport**, which is the intermediary layer that is responsible for
+executing outgoing requests (ie. API calls and event listeners).
+
+There are two types of **Transports** in the sdk:
+
+#### HTTP Transport
+
+A HTTP Transport that executes requests via a [fetch](https://developer.mozilla.org/en-US/docs/Web/API/Window/fetch)
+API.
+
+```typescript
+class HttpTransport implements IRequestTransport, HttpTransportOptions {
+    constructor(options?: HttpTransportOptions);
+
+    request(endpoint: "info" | "action" | "explorer", payload: unknown, signal?: AbortSignal): Promise<unknown>;
+}
+
+interface HttpTransportOptions {
+    url?: string | URL; // Base URL for API endpoints (default: "https://api.hyperliquid.xyz")
+    timeout?: number; // Request timeout in ms (default: 10_000)
+    fetchOptions?: RequestInit; // A custom fetch options
+    onRequest?: (request: Request) => MaybePromise<Request | void | null | undefined>; // A callback before request is sent
+    onResponse?: (response: Response) => MaybePromise<Response | void | null | undefined>; // A callback after response is received
+}
+```
+
+#### WebSocket Transport
+
+A WebSocket Transport that executes requests and subscribes to events via a
+[WebSocket](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket) connection.
+
+```typescript
+class WebSocketTransport implements IRESTTransport, ISubscriptionTransport {
+    constructor(options?: WebSocketTransportOptions);
+
+    request(endpoint: "info" | "action" | "explorer", payload: unknown, signal?: AbortSignal): Promise<unknown>;
+    subscribe(
+        channel: string,
+        payload: unknown,
+        listener: (data: CustomEvent) => void,
+        signal?: AbortSignal,
+    ): Promise<Subscription>;
+
+    ready(signal?: AbortSignal): Promise<void>;
+    close(signal?: AbortSignal): Promise<void>;
+}
+
+interface WebSocketTransportOptions {
+    url?: string | URL; // WebSocket URL (default: "wss://api.hyperliquid.xyz/ws")
+    timeout?: number; // Request timeout in ms (default: 10_000)
+    keepAlive?: { // Keep-alive configuration
+        interval?: number; // Ping interval in ms (default: 20_000)
+    };
+    reconnect?: { // Reconnection policy configuration for closed connections
+        maxRetries?: number; // Maximum number of reconnection attempts (default: 3)
+        connectionTimeout?: number; // Connection timeout in ms (default: 10_000)
+        connectionDelay?: number | ((attempt: number) => number | Promise<number>); // Delay between reconnection (default: Exponential backoff (max 10s))
+        shouldReconnect?: (event: CloseEvent) => boolean | Promise<boolean>; // Custom reconnection logic (default: Always reconnect)
+        messageBuffer?: MessageBufferStrategy; // Message buffering strategy between reconnection (default: FIFO buffer)
+        WebSocketConstructor?: typeof WebSocket; // Custom WebSocket constructor (default: globalThis.WebSocket)
+    };
+}
+```
+
+## Semantic Versioning
+
+This library follows [Semantic Versioning](https://semver.org/) (or rather
+[this proposal](https://github.com/semver/semver/pull/923)) for its releases.
+
+> [!IMPORTANT]
+> To avoid rapid increase in the main version of the SDK due to changes in Hyperliquid API types, such changes are
+> reflected in updates to the patch version of this SDK.
+
+## CI/CD and Release
+
+Before publishing a new version of the SDK, tests are always run in
+[Github Actions](https://github.com/nktkas/hyperliquid/actions). Only if all tests pass successfully, the process of
+publishing the package takes place.
+
+For more details, see our [CI/CD configuration files](./.github/workflows/).
+
+## Contributing
+
+Contributions are welcome! Please see the [CONTRIBUTING](./CONTRIBUTING.md) file for guidelines on how to contribute to
+this project.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](./LICENSE) file for details.

package/SECURITY.md

@@ -0,0 +1,7 @@
+# Security Policy
+
+## For Issues in Hyperliquid
+
+If you have discovered a vulnerability or security issue related to the Hyperliquid service (e.g., buffer overflow, SQL
+injection, cross-site scripting, etc.), please refer to the
+[Hyperliquid Security Policy](https://github.com/hyperliquid-dex/hyperliquid-python-sdk/blob/master/SECURITY.md).

package/esm/deps/jsr.io/@derzade/typescript-event-target/1.1.1/mod.d.ts

@@ -0,0 +1,2 @@
+export * from './src/TypedEventTarget.js';
+//# sourceMappingURL=mod.d.ts.map

package/esm/deps/jsr.io/@derzade/typescript-event-target/1.1.1/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@derzade/typescript-event-target/1.1.1/mod.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC"}

package/esm/deps/jsr.io/@derzade/typescript-event-target/1.1.1/mod.js

@@ -0,0 +1 @@
+export * from './src/TypedEventTarget.js';

package/esm/deps/jsr.io/@derzade/typescript-event-target/1.1.1/src/TypedEventTarget.d.ts

@@ -0,0 +1,95 @@
+/**
+ * A function that can be passed to the `listener` parameter of {@link TypedEventTarget.addEventListener} and {@link TypedEventTarget.removeEventListener}.
+ *
+ * @template M A map of event types to their respective event classes.
+ * @template T The type of event to listen for (has to be keyof `M`).
+ */
+export type TypedEventListener<M, T extends keyof M> = (evt: M[T]) => void | Promise<void>;
+/**
+ * An object that can be passed to the `listener` parameter of {@link TypedEventTarget.addEventListener} and {@link TypedEventTarget.removeEventListener}.
+ *
+ * @template M A map of event types to their respective event classes.
+ * @template T The type of event to listen for (has to be keyof `M`).
+ */
+export interface TypedEventListenerObject<M, T extends keyof M> {
+    handleEvent: (evt: M[T]) => void | Promise<void>;
+}
+/**
+ * Type of parameter `listener` in {@link TypedEventTarget.addEventListener} and {@link TypedEventTarget.removeEventListener}.
+ *
+ * The object that receives a notification (an object that implements the Event interface) when an event of the specified type occurs.
+ *
+ * Can be either an object with a handleEvent() method, or a JavaScript function.
+ *
+ * @template M A map of event types to their respective event classes.
+ * @template T The type of event to listen for (has to be keyof `M`).
+ */
+export type TypedEventListenerOrEventListenerObject<M, T extends keyof M> = TypedEventListener<M, T> | TypedEventListenerObject<M, T>;
+type ValueIsEvent<T> = {
+    [key in keyof T]: Event;
+};
+/**
+ * Typescript friendly version of {@link EventTarget}
+ *
+ * @template M A map of event types to their respective event classes.
+ *
+ * @example
+ * ```typescript
+ * interface MyEventMap {
+ *     hello: Event;
+ *     time: CustomEvent<number>;
+ * }
+ *
+ * const eventTarget = new TypedEventTarget<MyEventMap>();
+ *
+ * eventTarget.addEventListener('time', (event) => {
+ *     // event is of type CustomEvent<number>
+ * });
+ * ```
+ */
+export interface TypedEventTarget<M extends ValueIsEvent<M>> {
+    /** Appends an event listener for events whose type attribute value is type.
+     * The callback argument sets the callback that will be invoked when the event
+     * is dispatched.
+     *
+     * The options argument sets listener-specific options. For compatibility this
+     * can be a boolean, in which case the method behaves exactly as if the value
+     * was specified as options's capture.
+     *
+     * When set to true, options's capture prevents callback from being invoked
+     * when the event's eventPhase attribute value is BUBBLING_PHASE. When false
+     * (or not present), callback will not be invoked when event's eventPhase
+     * attribute value is CAPTURING_PHASE. Either way, callback will be invoked if
+     * event's eventPhase attribute value is AT_TARGET.
+     *
+     * When set to true, options's passive indicates that the callback will not
+     * cancel the event by invoking preventDefault(). This is used to enable
+     * performance optimizations described in § 2.8 Observing event listeners.
+     *
+     * When set to true, options's once indicates that the callback will only be
+     * invoked once after which the event listener will be removed.
+     *
+     * The event listener is appended to target's event listener list and is not
+     * appended if it has the same type, callback, and capture. */
+    addEventListener: <T extends keyof M & string>(type: T, listener: TypedEventListenerOrEventListenerObject<M, T> | null, options?: boolean | AddEventListenerOptions) => void;
+    /** Removes the event listener in target's event listener list with the same
+     * type, callback, and options. */
+    removeEventListener: <T extends keyof M & string>(type: T, callback: TypedEventListenerOrEventListenerObject<M, T> | null, options?: EventListenerOptions | boolean) => void;
+    /**
+     * Dispatches a synthetic event event to target and returns true if either
+     * event's cancelable attribute value is false or its preventDefault() method
+     * was not invoked, and false otherwise.
+     * @deprecated To ensure type safety use `dispatchTypedEvent` instead.
+     */
+    dispatchEvent: (event: Event) => boolean;
+}
+export declare class TypedEventTarget<M extends ValueIsEvent<M>> extends EventTarget {
+    /**
+     * Dispatches a synthetic event event to target and returns true if either
+     * event's cancelable attribute value is false or its preventDefault() method
+     * was not invoked, and false otherwise.
+     */
+    dispatchTypedEvent<T extends keyof M>(_type: T, event: M[T]): boolean;
+}
+export {};
+//# sourceMappingURL=TypedEventTarget.d.ts.map

package/esm/deps/jsr.io/@derzade/typescript-event-target/1.1.1/src/TypedEventTarget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypedEventTarget.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@derzade/typescript-event-target/1.1.1/src/TypedEventTarget.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,IAAI,CACnD,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,KACR,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAE1B;;;;;GAKG;AACH,MAAM,WAAW,wBAAwB,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC;IAC1D,WAAW,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACpD;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,uCAAuC,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,IAClE,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,GACxB,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAErC,KAAK,YAAY,CAAC,CAAC,IAAI;KAClB,GAAG,IAAI,MAAM,CAAC,GAAG,KAAK;CAC1B,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,gBAAgB,CAAC,CAAC,SAAS,YAAY,CAAC,CAAC,CAAC;IACvD;;;;;;;;;;;;;;;;;;;;;;kEAsB8D;IAC9D,gBAAgB,EAAE,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EACzC,IAAI,EAAE,CAAC,EACP,QAAQ,EAAE,uCAAuC,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI,EAC9D,OAAO,CAAC,EAAE,OAAO,GAAG,uBAAuB,KAC1C,IAAI,CAAC;IAEV;sCACkC;IAClC,mBAAmB,EAAE,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EAC5C,IAAI,EAAE,CAAC,EACP,QAAQ,EAAE,uCAAuC,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI,EAC9D,OAAO,CAAC,EAAE,oBAAoB,GAAG,OAAO,KACvC,IAAI,CAAC;IAEV;;;;;OAKG;IACH,aAAa,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC;CAC5C;AACD,qBAAa,gBAAgB,CAAC,CAAC,SAAS,YAAY,CAAC,CAAC,CAAC,CAAE,SAAQ,WAAW;IACxE;;;;OAIG;IACI,kBAAkB,CAAC,CAAC,SAAS,MAAM,CAAC,EACvC,KAAK,EAAE,CAAC,EACR,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,GACZ,OAAO;CAGb"}

package/esm/deps/jsr.io/@derzade/typescript-event-target/1.1.1/src/TypedEventTarget.js

@@ -0,0 +1,10 @@
+export class TypedEventTarget extends EventTarget {
+    /**
+     * Dispatches a synthetic event event to target and returns true if either
+     * event's cancelable attribute value is false or its preventDefault() method
+     * was not invoked, and false otherwise.
+     */
+    dispatchTypedEvent(_type, event) {
+        return super.dispatchEvent(event);
+    }
+}

package/esm/deps/jsr.io/@noble/hashes/1.7.1/src/_assert.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Internal assertion helpers.
+ * @module
+ */
+/** Asserts something is positive integer. */
+declare function anumber(n: number): void;
+/** Asserts something is Uint8Array. */
+declare function abytes(b: Uint8Array | undefined, ...lengths: number[]): void;
+/** Hash interface. */
+export type Hash = {
+    (data: Uint8Array): Uint8Array;
+    blockLen: number;
+    outputLen: number;
+    create: any;
+};
+/** Asserts something is hash */
+declare function ahash(h: Hash): void;
+/** Asserts a hash instance has not been destroyed / finished */
+declare function aexists(instance: any, checkFinished?: boolean): void;
+/** Asserts output is properly-sized byte array */
+declare function aoutput(out: any, instance: any): void;
+export { anumber, abytes, ahash, aexists, aoutput };
+//# sourceMappingURL=_assert.d.ts.map

package/esm/deps/jsr.io/@noble/hashes/1.7.1/src/_assert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_assert.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@noble/hashes/1.7.1/src/_assert.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,6CAA6C;AAC7C,iBAAS,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAEhC;AAOD,uCAAuC;AACvC,iBAAS,MAAM,CAAC,CAAC,EAAE,UAAU,GAAG,SAAS,EAAE,GAAG,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,CAIrE;AAED,sBAAsB;AACtB,MAAM,MAAM,IAAI,GAAG;IACjB,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAAC;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,GAAG,CAAC;CACb,CAAC;AAEF,gCAAgC;AAChC,iBAAS,KAAK,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,CAK5B;AAED,gEAAgE;AAChE,iBAAS,OAAO,CAAC,QAAQ,EAAE,GAAG,EAAE,aAAa,UAAO,GAAG,IAAI,CAG1D;AAED,kDAAkD;AAClD,iBAAS,OAAO,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,GAAG,IAAI,CAM9C;AAED,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC"}

package/esm/deps/jsr.io/@noble/hashes/1.7.1/src/_assert.js

@@ -0,0 +1,43 @@
+/**
+ * Internal assertion helpers.
+ * @module
+ */
+/** Asserts something is positive integer. */
+function anumber(n) {
+    if (!Number.isSafeInteger(n) || n < 0)
+        throw new Error('positive integer expected, got ' + n);
+}
+/** Is number an Uint8Array? Copied from utils for perf. */
+function isBytes(a) {
+    return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');
+}
+/** Asserts something is Uint8Array. */
+function abytes(b, ...lengths) {
+    if (!isBytes(b))
+        throw new Error('Uint8Array expected');
+    if (lengths.length > 0 && !lengths.includes(b.length))
+        throw new Error('Uint8Array expected of length ' + lengths + ', got length=' + b.length);
+}
+/** Asserts something is hash */
+function ahash(h) {
+    if (typeof h !== 'function' || typeof h.create !== 'function')
+        throw new Error('Hash should be wrapped by utils.wrapConstructor');
+    anumber(h.outputLen);
+    anumber(h.blockLen);
+}
+/** Asserts a hash instance has not been destroyed / finished */
+function aexists(instance, checkFinished = true) {
+    if (instance.destroyed)
+        throw new Error('Hash instance has been destroyed');
+    if (checkFinished && instance.finished)
+        throw new Error('Hash#digest() has already been called');
+}
+/** Asserts output is properly-sized byte array */
+function aoutput(out, instance) {
+    abytes(out);
+    const min = instance.outputLen;
+    if (out.length < min) {
+        throw new Error('digestInto() expects output buffer of length at least ' + min);
+    }
+}
+export { anumber, abytes, ahash, aexists, aoutput };